lean/OAI/Combinatorics/LowSpaceSubsetSum/Counting/MatchFold.lean

import OAI.Combinatorics.LowSpaceSubsetSum.Counting.MatchPotential

namespace OAI

/-! Exact callback semantics for matching Cartesian occurrences. -/

namespace LowSpaceSubsetSum
namespace MatchFold

universe u v w
variable {α : Type u} {β : Type v} {τ : Type w}

def run (key₁ : α → ℤ) (key₂ : β → ℤ) (report : α → β → τ → τ × Bool) :
    List α → List β → τ → τ
  | [], _, a => a
  | x :: xs, ys, a => run key₁ key₂ report xs ys
      ((ys.filter (fun y => decide (key₁ x = key₂ y))).foldl (fun a y => (report x y a).1) a)

theorem nil_right (key₁ : α → ℤ) (key₂ : β → ℤ) (report : α → β → τ → τ × Bool)
    (xs : List α) (a : τ) : run key₁ key₂ report xs [] a = a := by
  induction xs with
  | nil => rfl
  | cons x xs ih => simpa only [run, List.filter_nil, List.foldl_nil] using ih

theorem append_left (key₁ : α → ℤ) (key₂ : β → ℤ) (report : α → β → τ → τ × Bool)
    (xs rest : List α) (ys : List β) (a : τ) :
    run key₁ key₂ report (xs ++ rest) ys a =
      run key₁ key₂ report rest ys (run key₁ key₂ report xs ys a) := by
  induction xs generalizing a with
  | nil => rfl
  | cons x xs ih => simp only [List.cons_append, run, ih]

theorem filter_congr (key₁ : α → ℤ) (key₂ : β → ℤ) (report : α → β → τ → τ × Bool)
    (xs : List α) (ys zs : List β) (a : τ)
    (h : ∀ x ∈ xs, ys.filter (fun y => decide (key₁ x = key₂ y)) =
      zs.filter (fun y => decide (key₁ x = key₂ y))) :
    run key₁ key₂ report xs ys a = run key₁ key₂ report xs zs a := by
  induction xs generalizing a with
  | nil => rfl
  | cons x xs ih =>
    rw [run, h x (by simp), run]
    exact ih _ (fun z hz => h z (by simp [hz]))

theorem group_eq (key₁ : α → ℤ) (key₂ : β → ℤ) (report : α → β → τ → τ × Bool)
    (K : ℤ) (xs : List α) (ys : List β) (a : τ)
    (hx : ∀ x ∈ xs, key₁ x = K) (hy : ∀ y ∈ ys, key₂ y = K) :
    run key₁ key₂ report xs ys a =
      xs.foldl (fun a x => ys.foldl (fun a y => (report x y a).1) a) a := by
  induction xs generalizing a with
  | nil => rfl
  | cons x xs ih =>
    have hfilter : ys.filter (fun y => decide (key₁ x = key₂ y)) = ys := by
      apply List.filter_eq_self.mpr
      intro y hym
      simp only [hx x (by simp), hy y hym, decide_true]
    rw [run, hfilter, List.foldl_cons]
    exact ih _ (fun z hz => hx z (by simp [hz]))

theorem split_groups (key₁ : α → ℤ) (key₂ : β → ℤ) (report : α → β → τ → τ × Bool)
    (K : ℤ) (xs rest₁ : List α) (ys rest₂ : List β) (a : τ)
    (hx : ∀ x ∈ xs, key₁ x = K) (hy : ∀ y ∈ ys, key₂ y = K)
    (hr₁ : ∀ x ∈ rest₁, key₁ x ≠ K) (hr₂ : ∀ y ∈ rest₂, key₂ y ≠ K) :
    run key₁ key₂ report (xs ++ rest₁) (ys ++ rest₂) a =
      run key₁ key₂ report rest₁ rest₂
        (xs.foldl (fun a x => ys.foldl (fun a y => (report x y a).1) a) a) := by
  have hleft : ∀ a, run key₁ key₂ report xs (ys ++ rest₂) a = run key₁ key₂ report xs ys a := by
    intro a
    apply filter_congr
    intro x hxm
    have hz : rest₂.filter (fun y => decide (key₁ x = key₂ y)) = [] := by
      apply List.filter_eq_nil_iff.mpr
      intro y hym
      simpa only [decide_eq_true_eq, hx x hxm] using (hr₂ y hym).symm
    simp only [List.filter_append, hz, List.append_nil]
  have hright : ∀ a, run key₁ key₂ report rest₁ (ys ++ rest₂) a =
      run key₁ key₂ report rest₁ rest₂ a := by
    intro a
    apply filter_congr
    intro x hxm
    have hz : ys.filter (fun y => decide (key₁ x = key₂ y)) = [] := by
      apply List.filter_eq_nil_iff.mpr
      intro y hym
      simpa only [decide_eq_true_eq, hy y hym] using hr₁ x hxm
    simp only [List.filter_append, hz, List.nil_append]
  rw [append_left, hleft, hright, group_eq key₁ key₂ report K xs ys a hx hy]

theorem skip_left (key₁ : α → ℤ) (key₂ : β → ℤ) (report : α → β → τ → τ × Bool)
    (x : α) (xs : List α) (ys : List β) (a : τ)
    (h : ∀ y ∈ ys, key₁ x < key₂ y) :
    run key₁ key₂ report (x :: xs) ys a = run key₁ key₂ report xs ys a := 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 [run, he, List.foldl_nil]

theorem skip_right (key₁ : α → ℤ) (key₂ : β → ℤ) (report : α → β → τ → τ × Bool)
    (xs : List α) (y : β) (ys : List β) (a : τ)
    (h : ∀ x ∈ xs, key₂ y < key₁ x) :
    run key₁ key₂ report xs (y :: ys) a = run key₁ key₂ report xs ys a := by
  apply filter_congr
  intro x hx
  have he : key₁ x ≠ key₂ y := (h x hx).ne.symm
  simp only [List.filter_cons, he, decide_false, Bool.false_eq_true, ite_false]

end MatchFold
end LowSpaceSubsetSum

end OAI