import OAI.Combinatorics.LowSpaceSubsetSum.Streams.TieGroup

namespace OAI

/-!
# Potential matching occurrences in sorted streams

This count uses list occurrences, so repeated values and equal records are
counted separately. Removing a completed equal-key group subtracts its full
Cartesian product; this is the potential used to charge stopped replays.
-/

namespace LowSpaceSubsetSum
namespace MatchPotential

variable {α β : Type*}

def count (key₁ : α → ℤ) (key₂ : β → ℤ) : List α → List β → ℕ
  | [], _ => 0
  | x :: xs, ys => (ys.filter (fun y => decide (key₁ x = key₂ y))).length + count key₁ key₂ xs ys

theorem positive_iff (key₁ : α → ℤ) (key₂ : β → ℤ) (xs : List α) (ys : List β) :
    0 < count key₁ key₂ xs ys ↔ ∃ x ∈ xs, ∃ y ∈ ys, key₁ x = key₂ y := by
  induction xs with
  | nil => simp [count]
  | cons x xs ih =>
    have hf : 0 < (ys.filter (fun y => decide (key₁ x = key₂ y))).length ↔
        ∃ y ∈ ys, key₁ x = key₂ y := by
      simp only [List.length_pos_iff_exists_mem, List.mem_filter, decide_eq_true_eq]
    rw [count, Nat.add_pos_iff_pos_or_pos, hf, ih]
    constructor
    · rintro (⟨y, hy, heq⟩ | ⟨a, ha, b, hb, heq⟩)
      · exact ⟨x, by simp, y, hy, heq⟩
      · exact ⟨a, by simp [ha], b, hb, heq⟩
    · rintro ⟨a, ha, b, hb, heq⟩
      rcases List.mem_cons.mp ha with rfl | ha
      · exact Or.inl ⟨b, hb, heq⟩
      · exact Or.inr ⟨a, ha, b, hb, heq⟩

theorem append_left (key₁ : α → ℤ) (key₂ : β → ℤ) (xs zs : List α) (ys : List β) :
    count key₁ key₂ (xs ++ zs) ys = count key₁ key₂ xs ys + count key₁ key₂ zs ys := by
  induction xs with
  | nil => simp [count]
  | cons x xs ih => simp [count, ih, Nat.add_assoc]

theorem append_right (key₁ : α → ℤ) (key₂ : β → ℤ) (xs : List α) (ys zs : List β) :
    count key₁ key₂ xs (ys ++ zs) = count key₁ key₂ xs ys + count key₁ key₂ xs zs := by
  induction xs with
  | nil => simp [count]
  | cons x xs ih => simp only [count, List.filter_append, List.length_append, ih]; omega

theorem eq_zero (key₁ : α → ℤ) (key₂ : β → ℤ) (xs : List α) (ys : List β)
    (h : ∀ x ∈ xs, ∀ y ∈ ys, key₁ x ≠ key₂ y) : count key₁ key₂ xs ys = 0 := by
  induction xs with
  | nil => rfl
  | cons x xs ih =>
    have hx : ys.filter (fun y => decide (key₁ x = key₂ y)) = [] := by
      apply List.filter_eq_nil_iff.mpr
      intro y hy
      simpa only [decide_eq_true_eq] using h x (by simp) y hy
    rw [count, hx, List.length_nil, Nat.zero_add]
    exact ih (fun z hz => h z (by simp [hz]))

theorem eq_product (key₁ : α → ℤ) (key₂ : β → ℤ) (K : ℤ)
    (xs : List α) (ys : List β) (hx : ∀ x ∈ xs, key₁ x = K)
    (hy : ∀ y ∈ ys, key₂ y = K) : count key₁ key₂ xs ys = xs.length * ys.length := by
  induction xs with
  | nil => simp [count]
  | cons x xs ih =>
    have hxK := hx x (by simp)
    have he : ys.filter (fun y => decide (key₁ x = key₂ y)) = ys := by
      apply List.filter_eq_self.mpr
      intro y hmem
      simp only [hxK, hy y hmem, decide_true]
    rw [count, he, ih (fun z hz => hx z (by simp [hz])), List.length_cons]
    ring

theorem split_groups (key₁ : α → ℤ) (key₂ : β → ℤ) (K : ℤ)
    (xs rest₁ : List α) (ys rest₂ : List β)
    (hx : ∀ x ∈ xs, key₁ x = K) (hy : ∀ y ∈ ys, key₂ y = K)
    (hr₁ : ∀ x ∈ rest₁, key₁ x ≠ K) (hr₂ : ∀ y ∈ rest₂, key₂ y ≠ K) :
    count key₁ key₂ (xs ++ rest₁) (ys ++ rest₂) =
      xs.length * ys.length + count key₁ key₂ rest₁ rest₂ := by
  rw [append_left, append_right, append_right, eq_product key₁ key₂ K xs ys hx hy]
  have hz₁ : count key₁ key₂ xs rest₂ = 0 := eq_zero key₁ key₂ xs rest₂ (by
    intro x hxm y hym
    rw [hx x hxm]
    exact (hr₂ y hym).symm)
  have hz₂ : count key₁ key₂ rest₁ ys = 0 := eq_zero key₁ key₂ rest₁ ys (by
    intro x hxm y hym
    rw [hy y hym]
    exact hr₁ x hxm)
  simp only [hz₁, hz₂, Nat.add_zero, Nat.zero_add]

theorem sorted_dropWhile_avoids {γ : Type*} (key : γ → ℤ) (K : ℤ) (xs : List γ)
    (hsort : xs.Pairwise (fun x y => key x ≤ key y))
    (hlower : ∀ x ∈ xs, K ≤ key x) :
    ∀ x ∈ xs.dropWhile (fun x => decide (key x = K)), key x ≠ K := by
  induction xs with
  | nil => simp
  | cons x xs ih =>
    obtain ⟨hhead, htail⟩ := List.pairwise_cons.mp hsort
    by_cases hx : key x = K
    · simpa only [List.dropWhile, hx, decide_true, ↓reduceIte] using
        ih htail (fun y hy => hlower y (by simp [hy]))
    · have hxlow := hlower x (by simp)
      simp only [List.dropWhile, hx, decide_false]
      intro y hy
      rcases List.mem_cons.mp hy with rfl | hy
      · exact hx
      · have hxy := hhead y hy
        omega

theorem remaining_eq_dropWhile {γ : Type*} (p : γ → Bool) (xs rest : List γ)
    (h : xs = xs.takeWhile p ++ rest) : rest = xs.dropWhile p := by
  apply List.append_cancel_left
  exact h.symm.trans List.takeWhile_append_dropWhile.symm

theorem remaining_sublist {γ : Type*} (p : γ → Bool) (xs rest : List γ)
    (h : xs = xs.takeWhile p ++ rest) : rest.Sublist xs := by
  rw [remaining_eq_dropWhile p xs rest h]
  exact List.dropWhile_sublist p

theorem remaining_avoids {γ : Type*} (key : γ → ℤ) (K : ℤ) (xs rest : List γ)
    (h : xs = xs.takeWhile (fun x => decide (key x = K)) ++ rest)
    (hsort : xs.Pairwise (fun x y => key x ≤ key y))
    (hlower : ∀ x ∈ xs, K ≤ key x) : ∀ x ∈ rest, key x ≠ K := by
  rw [remaining_eq_dropWhile _ xs rest h]
  exact sorted_dropWhile_avoids key K xs hsort hlower

theorem lower_bound_head {γ : Type*} (key : γ → ℤ) (x : γ) (xs : List γ)
    (hsort : (x :: xs).Pairwise (fun x y => key x ≤ key y)) :
    ∀ y ∈ x :: xs, key x ≤ key y := by
  intro y hy
  rcases List.mem_cons.mp hy with rfl | hy
  · rfl
  · exact (List.pairwise_cons.mp hsort).1 y hy

theorem skip_left (key₁ : α → ℤ) (key₂ : β → ℤ) (x : α) (xs : List α) (ys : List β)
    (h : ∀ y ∈ ys, key₁ x < key₂ y) :
    count key₁ key₂ (x :: xs) ys = count key₁ key₂ xs ys := by
  have he : ys.filter (fun y => decide (key₁ x = key₂ y)) = [] := by
    apply List.filter_eq_nil_iff.mpr
    intro y hy
    simpa only [decide_eq_true_eq] using (h y hy).ne
  simp only [count, he, List.length_nil, Nat.zero_add]

theorem skip_right (key₁ : α → ℤ) (key₂ : β → ℤ) (xs : List α) (y : β) (ys : List β)
    (h : ∀ x ∈ xs, key₂ y < key₁ x) :
    count key₁ key₂ xs (y :: ys) = count key₁ key₂ xs ys := by
  induction xs with
  | nil => rfl
  | cons x xs ih =>
    have he : key₁ x ≠ key₂ y := (h x (by simp)).ne.symm
    simp only [count, List.filter_cons, he, decide_false, Bool.false_eq_true, ite_false]
    rw [ih (fun z hz => h z (by simp [hz]))]

end MatchPotential
end LowSpaceSubsetSum

end OAI