import OAI.Combinatorics.LowSpaceSubsetSum.Separators.SeparatorBlocks

namespace OAI

/-! # Polynomial charge bound for the composed separator traversal -/

namespace LowSpaceSubsetSum.SeparatorBlocks

open SeparatorIncidenceTable

variable {α β : Type*}

def coefficient (n : ℕ) (bs : List (Block α β)) : ℕ :=
  6 * n + 8 + 2 * (bs.map depth).sum

def multiplicityLeft (bs : List (Block α β)) (x : α) : ℕ :=
  (bs.map (fun b => 1 + count (b.left x) 0 b.size)).prod

def multiplicityRight (bs : List (Block α β)) (y : β) : ℕ :=
  (bs.map (fun b => 1 + count (b.right y) 0 b.size)).prod

theorem chargeLeft_le (n : ℕ) (bs : List (Block α β)) (x : α) :
    chargeLeft n bs x ≤ coefficient n bs * multiplicityLeft bs x := by
  induction bs with
  | nil => simp [chargeLeft, coefficient, multiplicityLeft]
  | cons b rest ih =>
    have hp : 1 ≤ multiplicityLeft rest x := by
      unfold multiplicityLeft
      apply List.one_le_prod
      intro k hk
      obtain ⟨a, _, rfl⟩ := List.mem_map.mp hk
      omega
    have hc : 1 ≤ coefficient n rest := by simp [coefficient]; omega
    have hm := Nat.add_le_add (Nat.mul_le_mul_left (2 * depth b) hp) ih
    have hone : 1 ≤ (2 * depth b + coefficient n rest) * multiplicityLeft rest x := by
      have hh : 1 ≤ 2 * depth b + coefficient n rest := by omega
      simpa using Nat.mul_le_mul hh hp
    calc
      chargeLeft n (b :: rest) x =
          1 + (2 * depth b + chargeLeft n rest x) * count (b.left x) 0 b.size := rfl
      _ ≤ 1 + ((2 * depth b + coefficient n rest) * multiplicityLeft rest x) *
          count (b.left x) 0 b.size := by
        apply Nat.add_le_add_left
        apply Nat.mul_le_mul_right
        nlinarith [hm]
      _ ≤ ((2 * depth b + coefficient n rest) * multiplicityLeft rest x) +
          ((2 * depth b + coefficient n rest) * multiplicityLeft rest x) *
            count (b.left x) 0 b.size := Nat.add_le_add_right hone _
      _ = coefficient n (b :: rest) * multiplicityLeft (b :: rest) x := by
        simp only [coefficient, multiplicityLeft, List.map_cons, List.sum_cons, List.prod_cons]
        ring

theorem chargeRight_le (n : ℕ) (bs : List (Block α β)) (y : β) :
    chargeRight n bs y ≤ coefficient n bs * multiplicityRight bs y := by
  induction bs with
  | nil => simp [chargeRight, coefficient, multiplicityRight]
  | cons b rest ih =>
    have hp : 1 ≤ multiplicityRight rest y := by
      unfold multiplicityRight
      apply List.one_le_prod
      intro k hk
      obtain ⟨a, _, rfl⟩ := List.mem_map.mp hk
      omega
    have hc : 1 ≤ coefficient n rest := by simp [coefficient]; omega
    have hm := Nat.add_le_add (Nat.mul_le_mul_left (2 * depth b) hp) ih
    have hone : 1 ≤ (2 * depth b + coefficient n rest) * multiplicityRight rest y := by
      have hh : 1 ≤ 2 * depth b + coefficient n rest := by omega
      simpa using Nat.mul_le_mul hh hp
    calc
      chargeRight n (b :: rest) y =
          1 + (2 * depth b + chargeRight n rest y) * count (b.right y) 0 b.size := rfl
      _ ≤ 1 + ((2 * depth b + coefficient n rest) * multiplicityRight rest y) *
          count (b.right y) 0 b.size := by
        apply Nat.add_le_add_left
        apply Nat.mul_le_mul_right
        nlinarith [hm]
      _ ≤ ((2 * depth b + coefficient n rest) * multiplicityRight rest y) +
          ((2 * depth b + coefficient n rest) * multiplicityRight rest y) *
            count (b.right y) 0 b.size := Nat.add_le_add_right hone _
      _ = coefficient n (b :: rest) * multiplicityRight (b :: rest) y := by
        simp only [coefficient, multiplicityRight, List.map_cons, List.sum_cons, List.prod_cons]
        ring

theorem scans_le_multiplicities (n : ℕ) (wx : α → ℤ) (wy : β → ℤ) (target : ℤ)
    (bs : List (Block α β)) (xs : List α) (ys : List β) :
    (check n wx wy target bs xs ys).scans ≤ coefficient n bs *
      ((xs.map (multiplicityLeft bs)).sum + (ys.map (multiplicityRight bs)).sum) := by
  have hl : (xs.map (chargeLeft n bs)).sum ≤
      coefficient n bs * (xs.map (multiplicityLeft bs)).sum := by
    induction xs with
    | nil => simp
    | cons x xs ih =>
      simp only [List.map_cons, List.sum_cons]
      nlinarith [chargeLeft_le n bs x]
  have hr : (ys.map (chargeRight n bs)).sum ≤
      coefficient n bs * (ys.map (multiplicityRight bs)).sum := by
    induction ys with
    | nil => simp
    | cons y ys ih =>
      simp only [List.map_cons, List.sum_cons]
      nlinarith [chargeRight_le n bs y]
  have hs := scans_le n wx wy target bs xs ys
  nlinarith

end LowSpaceSubsetSum.SeparatorBlocks

end OAI