import Mathlib
import OAI.Computability.DeterministicSum.Interpolation

namespace OAI

/-! Exact polynomial-filter decision, false-triple charges and distinct-position role searches. -/

namespace DeterministicThreeSum.DeterministicDecision
open scoped BigOperators
open Finset

structure Grouping {n : ℕ} (A : Finset (Fin n)) (k : ℕ) where
  members : Fin k → Finset (Fin n)
  nonempty : ∀ g, (members g).Nonempty
  cover : ∀ a, a ∈ A ↔ ∃ g, a ∈ members g
  unique : ∀ g h a, a ∈ members g → a ∈ members h → g = h

variable {n k J T : ℕ} {A B C : Finset (Fin n)}

lemma Grouping.subset (P : Grouping A k) (g : Fin k) : P.members g ⊆ A := by
  intro a ha
  exact (P.cover a).mpr ⟨g, ha⟩

lemma Grouping.size_le (P : Grouping A k) (g : Fin k) : (P.members g).card ≤ n := by
  simpa using (Finset.card_le_univ (P.members g))

def ExactPair (x : Fin n → ℤ) (B : Finset (Fin n)) (a c : Fin n) : Prop :=
  ∃ b ∈ B, x a + x b + x c = 0

def ModularHit (J : ℕ) (x : Fin n → ℤ) (B : Finset (Fin n)) (a c : Fin n) : Prop :=
  ∃ b ∈ B, (J : ℤ) ∣ x a + x b + x c

def ExactCell (x : Fin n → ℤ) (B : Finset (Fin n)) (P : Grouping A k)
    (gc : Fin k × Fin n) : Prop :=
  ∃ a ∈ P.members gc.1, ExactPair x B a gc.2

def RoleSolution (x : Fin n → ℤ) (A B C : Finset (Fin n)) : Prop :=
  ∃ a ∈ A, ∃ b ∈ B, ∃ c ∈ C, x a + x b + x c = 0

noncomputable def hitCount (J : ℕ) (x : Fin n → ℤ) (B : Finset (Fin n))
    (P : Grouping A k) (gc : Fin k × Fin n) : ℕ := by
  classical
  exact ((P.members gc.1).filter (fun a => ModularHit J x B a gc.2)).card

noncomputable def groupSum (E : Fin n → Fin n → ZMod T)
    (P : Grouping A k) (gc : Fin k × Fin n) : ZMod T :=
  ∑ a ∈ P.members gc.1, E a gc.2

def allCells (k : ℕ) (C : Finset (Fin n)) : Finset (Fin k × Fin n) :=
  univ ×ˢ C

noncomputable def selectedCells (E : Fin n → Fin n → ZMod T) (P : Grouping A k)
    (C : Finset (Fin n)) (D : Finset (Fin k × Fin n)) : Finset (Fin k × Fin n) := by
  classical
  exact (allCells k C).filter (fun gc => gc ∈ D ∨ groupSum E P gc ≠ 0)

def CleanAgreement (J : ℕ) (x : Fin n → ℤ) (B C : Finset (Fin n))
    (P : Grouping A k) (D : Finset (Fin k × Fin n))
    (E : Fin n → Fin n → ZMod T) : Prop := by
  classical
  exact ∀ g c, c ∈ C → (g,c) ∉ D → ∀ a ∈ P.members g,
    E a c = if ModularHit J x B a c then 1 else 0

lemma hitCount_le (x : Fin n → ℤ) (P : Grouping A k) (gc : Fin k × Fin n) :
    hitCount J x B P gc ≤ n := by
  classical
  exact (Finset.card_le_card (Finset.filter_subset _ _)).trans (P.size_le gc.1)

lemma clean_sum (x : Fin n → ℤ) (P : Grouping A k)
    (D : Finset (Fin k × Fin n)) (E : Fin n → Fin n → ZMod T)
    (h : CleanAgreement J x B C P D E) {gc : Fin k × Fin n}
    (hc : gc.2 ∈ C) (hd : gc ∉ D) :
    groupSum E P gc = (hitCount J x B P gc : ZMod T) := by
  classical
  unfold groupSum hitCount
  rw [Finset.natCast_card_filter]
  exact Finset.sum_congr rfl (fun a ha => h gc.1 gc.2 hc hd a ha)

lemma cast_count_ne_zero {h : ℕ} (ht : h < T) :
    (h : ZMod T) ≠ 0 ↔ 0 < h := by
  constructor
  · intro hn
    by_contra hz
    have : h = 0 := by omega
    simp [this] at hn
  · intro hp hz
    have hv := congrArg ZMod.val hz
    rw [ZMod.val_natCast_of_lt ht, ZMod.val_zero] at hv
    omega

lemma hitCount_pos_iff (x : Fin n → ℤ) (P : Grouping A k) (gc : Fin k × Fin n) :
    0 < hitCount J x B P gc ↔ ∃ a ∈ P.members gc.1, ModularHit J x B a gc.2 := by
  classical
  simp [hitCount, Finset.card_pos, Finset.Nonempty]

lemma clean_selected_iff (x : Fin n → ℤ) (P : Grouping A k)
    (D : Finset (Fin k × Fin n)) (E : Fin n → Fin n → ZMod T)
    (h : CleanAgreement J x B C P D E) (hn : n < T) {gc : Fin k × Fin n}
    (hc : gc.2 ∈ C) (hd : gc ∉ D) :
    gc ∈ selectedCells E P C D ↔ ∃ a ∈ P.members gc.1, ModularHit J x B a gc.2 := by
  classical
  simp only [selectedCells, mem_filter, allCells, mem_product, mem_univ, true_and,
    hc, true_and, hd, false_or]
  rw [clean_sum x P D E h hc hd,
    cast_count_ne_zero ((hitCount_le x P gc).trans_lt hn), hitCount_pos_iff]

lemma exact_modular (x : Fin n → ℤ) {a c : Fin n} (h : ExactPair x B a c) :
    ModularHit J x B a c := by
  obtain ⟨b, hb, hz⟩ := h
  exact ⟨b, hb, hz ▸ dvd_zero _⟩

lemma exact_cell_selected (x : Fin n → ℤ) (P : Grouping A k)
    (D : Finset (Fin k × Fin n)) (E : Fin n → Fin n → ZMod T)
    (h : CleanAgreement J x B C P D E) (hn : n < T) {gc : Fin k × Fin n}
    (hc : gc.2 ∈ C) (hex : ExactCell x B P gc) : gc ∈ selectedCells E P C D := by
  classical
  by_cases hd : gc ∈ D
  · exact mem_filter.mpr ⟨mem_product.mpr ⟨mem_univ _, hc⟩, Or.inl hd⟩
  · apply (clean_selected_iff x P D E h hn hc hd).mpr
    obtain ⟨a, ha, hp⟩ := hex
    exact ⟨a, ha, exact_modular x hp⟩

theorem role_decision_iff (x : Fin n → ℤ) (P : Grouping A k)
    (D : Finset (Fin k × Fin n)) (E : Fin n → Fin n → ZMod T)
    (h : CleanAgreement J x B C P D E) (hn : n < T) :
    (∃ gc ∈ selectedCells E P C D, ExactCell x B P gc) ↔ RoleSolution x A B C := by
  constructor
  · rintro ⟨⟨g,c⟩, hgc, a, ha, b, hb, hz⟩
    have hc : c ∈ C := (mem_product.mp (mem_filter.mp hgc).1).2
    exact ⟨a, P.subset g ha, b, hb, c, hc, hz⟩
  · rintro ⟨a, ha, b, hb, c, hc, hz⟩
    obtain ⟨g, hg⟩ := (P.cover a).mp ha
    have hex : ExactCell x B P (g,c) := ⟨a,hg,b,hb,hz⟩
    exact ⟨(g,c), exact_cell_selected x P D E h hn hc hex, hex⟩

noncomputable def falseTriples (J : ℕ) (x : Fin n → ℤ)
    (A B C : Finset (Fin n)) : Finset (Fin n × Fin n × Fin n) := by
  classical
  exact (A ×ˢ (B ×ˢ C)).filter (fun t =>
    x t.1 + x t.2.1 + x t.2.2 ≠ 0 ∧ (J : ℤ) ∣ x t.1 + x t.2.1 + x t.2.2)

noncomputable def unsuccessfulClean (x : Fin n → ℤ) (B C : Finset (Fin n))
    (P : Grouping A k) (D : Finset (Fin k × Fin n))
    (E : Fin n → Fin n → ZMod T) : Finset (Fin k × Fin n) := by
  classical
  exact (selectedCells E P C D).filter (fun gc => gc ∉ D ∧ ¬ ExactCell x B P gc)

lemma unsuccessful_has_false (x : Fin n → ℤ) (P : Grouping A k)
    (D : Finset (Fin k × Fin n)) (E : Fin n → Fin n → ZMod T)
    (h : CleanAgreement J x B C P D E) (hn : n < T)
    {gc : Fin k × Fin n} (hu : gc ∈ unsuccessfulClean x B C P D E) :
    ∃ t ∈ falseTriples J x A B C, t.1 ∈ P.members gc.1 ∧ t.2.2 = gc.2 := by
  classical
  obtain ⟨hgc, hd, he⟩ := mem_filter.mp hu
  have hc : gc.2 ∈ C := (mem_product.mp (mem_filter.mp hgc).1).2
  obtain ⟨a, ha, b, hb, hm⟩ := (clean_selected_iff x P D E h hn hc hd).mp hgc
  have hz : x a + x b + x gc.2 ≠ 0 := fun hz => he ⟨a, ha, b, hb, hz⟩
  refine ⟨(a,b,gc.2), ?_, ha, rfl⟩
  exact mem_filter.mpr ⟨mem_product.mpr ⟨P.subset gc.1 ha,
    mem_product.mpr ⟨hb,hc⟩⟩, hz, hm⟩

theorem unsuccessful_clean_card_le (x : Fin n → ℤ) (P : Grouping A k)
    (D : Finset (Fin k × Fin n)) (E : Fin n → Fin n → ZMod T)
    (h : CleanAgreement J x B C P D E) (hn : n < T) :
    (unsuccessfulClean x B C P D E).card ≤ (falseTriples J x A B C).card := by
  classical
  choose f hf hm hc using fun gc : ↥(unsuccessfulClean x B C P D E) =>
    unsuccessful_has_false x P D E h hn gc.property
  let φ : ↥(unsuccessfulClean x B C P D E) → ↥(falseTriples J x A B C) :=
    fun gc => ⟨f gc, hf gc⟩
  have hi : Function.Injective φ := by
    intro u v huv
    have heq : f u = f v := congrArg Subtype.val huv
    apply Subtype.ext
    apply Prod.ext
    · apply P.unique _ _ (f u).1 (hm u)
      rw [heq]
      exact hm v
    · rw [← hc u, ← hc v, heq]
  simpa using Fintype.card_le_of_injective φ hi

lemma threeSUM_of_distinct (x : Fin n → ℤ) (a b c : Fin n)
    (hab : a ≠ b) (hbc : b ≠ c) (hac : a ≠ c) (hz : x a + x b + x c = 0) :
    ThreeSUM x := by
  rcases lt_or_gt_of_ne hab with hab | hba
  · rcases lt_or_gt_of_ne hbc with hbc | hcb
    · exact ⟨a,b,c,hab,hbc,hz⟩
    · rcases lt_or_gt_of_ne hac with hac | hca
      · exact ⟨a,c,b,hac,hcb,by omega⟩
      · exact ⟨c,a,b,hca,hab,by omega⟩
  · rcases lt_or_gt_of_ne hbc with hbc | hcb
    · rcases lt_or_gt_of_ne hac with hac | hca
      · exact ⟨b,a,c,hba,hac,by omega⟩
      · exact ⟨b,c,a,hbc,hca,by omega⟩
    · exact ⟨c,b,a,hcb,hba,by omega⟩

lemma role_solution_threeSUM (x : Fin n → ℤ)
    (hAB : Disjoint A B) (hBC : Disjoint B C) (hAC : Disjoint A C)
    (h : RoleSolution x A B C) : ThreeSUM x := by
  obtain ⟨a,ha,b,hb,c,hc,hz⟩ := h
  have hab : a ≠ b := by
    rintro rfl
    exact Finset.disjoint_left.mp hAB ha hb
  have hbc : b ≠ c := by
    rintro rfl
    exact Finset.disjoint_left.mp hBC hb hc
  have hac : a ≠ c := by
    rintro rfl
    exact Finset.disjoint_left.mp hAC ha hc
  exact threeSUM_of_distinct x a b c hab hbc hac hz

def residue (J : ℕ) (z : ℤ) : ℕ := (z : ZMod J).val

lemma residue_cast (hJ : 0 < J) (z : ℤ) :
    (residue J z : ZMod J) = (z : ZMod J) := by
  let : NeZero J := ⟨ne_of_gt hJ⟩
  exact ZMod.natCast_zmod_val _

lemma residue_lt (hJ : 0 < J) (z : ℤ) : residue J z < J := by
  let : NeZero J := ⟨ne_of_gt hJ⟩
  exact ZMod.val_lt _

noncomputable def shiftedTable (J T : ℕ) (x : Fin n → ℤ)
    (B : Finset (Fin n)) (θ : ℤ) : Fin J → ZMod T := by
  classical
  exact fun t => if ∃ j ∈ B, (t.val : ZMod J) = ((θ - x j : ℤ) : ZMod J)
    then 1 else 0

lemma shiftedTable_agreement (hJ : 0 < J) (x : Fin n → ℤ)
    (B : Finset (Fin n)) (θ : ℤ) (a c : Fin n) (u v : ℕ)
    (hu : (u : ZMod J) = (x a : ZMod J))
    (hv : (v : ZMod J) = ((x c + θ : ℤ) : ZMod J)) :
    letI : Decidable (ModularHit J x B a c) := Classical.propDecidable _
    shiftedTable J T x B θ ⟨(u + v) % J, Nat.mod_lt _ hJ⟩ =
      if ModularHit J x B a c then 1 else 0 := by
  classical
  have hsum : (((u + v) % J : ℕ) : ZMod J) =
      (x a : ZMod J) + (x c : ZMod J) + (θ : ZMod J) := by
    rw [ZMod.natCast_mod, Nat.cast_add, hu, hv, Int.cast_add, add_assoc]
  have htest : (∃ j ∈ B, (((u + v) % J : ℕ) : ZMod J) =
      ((θ - x j : ℤ) : ZMod J)) ↔ ModularHit J x B a c := by
    simp only [hsum, Int.cast_sub]
    constructor
    · rintro ⟨j,hj,hz⟩
      refine ⟨j, hj, (ZMod.intCast_zmod_eq_zero_iff_dvd _ J).mp ?_⟩
      push_cast
      linear_combination hz
    · rintro ⟨j,hj,hz⟩
      have hz' := (ZMod.intCast_zmod_eq_zero_iff_dvd _ J).mpr hz
      push_cast at hz'
      refine ⟨j,hj,?_⟩
      linear_combination hz'
  simp only [shiftedTable, htest]

variable {base m d p e : ℕ}

def baseDigits (base : ℕ) (hb : 0 < base) : (d : ℕ) → ℕ → (Fin d → Fin base)
  | 0, _ => Fin.elim0
  | d + 1, u => Fin.cons ⟨u % base, Nat.mod_lt _ hb⟩ (baseDigits base hb d (u / base))

lemma baseDigits_value (hb : 0 < base) (d u : ℕ) (hu : u < base ^ d) :
    Digits.value base (fun i => (baseDigits base hb d u i).val) = u := by
  induction d generalizing u with
  | zero =>
    have hz : u = 0 := by simpa using hu
    simp [Digits.value, hz]
  | succ d ih =>
    have hu' : u / base < base ^ d := (Nat.div_lt_iff_lt_mul hb).mpr (by
      simpa [pow_succ] using hu)
    rw [Digits.value_succ]
    simp only [baseDigits, Fin.cons_zero, Fin.cons_succ]
    rw [ih (u / base) hu']
    exact Nat.mod_add_div u base

def residueDigits (base : ℕ) (hb : 0 < base) (d J : ℕ) (z : ℤ) : Fin d → Fin base :=
  baseDigits base hb d (residue J z)

lemma residueDigits_value (hb : 0 < base) (hJ : 0 < J) (hJpow : J ≤ base ^ d)
    (z : ℤ) : Digits.value base (fun i => (residueDigits base hb d J z i).val) =
      residue J z :=
  baseDigits_value hb d _ ((residue_lt hJ z).trans_le hJpow)

def splitOffset (m : ℕ) (z : Fin d → Fin base) : Fin d → ℕ :=
  fun i => m * ((z i).val / m)

def splitLocal (hm : 1 ≤ m) (z : Fin d → Fin base) : Fin d → Fin m :=
  fun i => ⟨(z i).val % m, Nat.mod_lt _ hm⟩

lemma splitOffset_multiple (z : Fin d → Fin base) (i : Fin d) :
    m ∣ splitOffset m z i := ⟨(z i).val / m, rfl⟩

lemma splitOffset_bound (hm : 1 ≤ m) (hdiv : m ∣ base) (z : Fin d → Fin base)
    (i : Fin d) : splitOffset m z i ≤ base - m := by
  obtain ⟨k, hk⟩ := hdiv
  have hdivlt : (z i).val / m < k := (Nat.div_lt_iff_lt_mul hm).mpr (by
    simpa [hk, Nat.mul_comm] using (z i).isLt)
  have hle := Nat.mul_le_mul_left m (Nat.succ_le_iff.mpr hdivlt)
  dsimp [splitOffset]
  rw [Nat.mul_succ, ← hk] at hle
  omega

lemma split_value (hm : 1 ≤ m) (z : Fin d → Fin base) :
    Digits.value base (fun i => splitOffset m z i + (splitLocal hm z i).val) =
      Digits.value base (fun i => (z i).val) := by
  congr 1
  funext i
  simpa only [splitOffset, splitLocal, Nat.mul_comm] using Nat.div_add_mod' (z i).val m

noncomputable def polynomialEntries (hm : 1 ≤ m) (hmb : m ≤ base) (hJ : 0 < J)
    (x : Fin n → ℤ) (B : Finset (Fin n)) (θ : ℤ)
    (offset : Fin n → Fin d → ℕ) (localDigit : Fin n → Fin d → Fin m)
    (queryDigit : Fin n → Fin d → Fin base) : Fin n → Fin n → ZMod (p ^ e) :=
  fun a c => MvPolynomial.eval
    (fun i => ((localDigit a i).val : ZMod (p ^ e)) + ((queryDigit c i).val : ZMod (p ^ e)))
    (Filter.polynomial hm hmb hJ (offset a) (shiftedTable J (p ^ e) x B θ))

noncomputable def dirtyCells (hm : 1 ≤ m) (hmb : m ≤ base)
    (P : Grouping A k) (C : Finset (Fin n))
    (localDigit : Fin n → Fin d → Fin m)
    (queryDigit : Fin n → Fin d → Fin base) : Finset (Fin k × Fin n) := by
  classical
  exact (allCells k C).filter (fun gc => ∃ a ∈ P.members gc.1,
    Digits.value base (fun i => (queryDigit gc.2 i).val) ∈
      Filter.exceptionalResidues hm hmb (localDigit a))

theorem polynomial_clean_agreement (hp : p.Prime) (he : 0 < e)
    (hq : base + m - 1 < p) (hm : 1 ≤ m) (hmb : m ≤ base) (hJ : 0 < J)
    (x : Fin n → ℤ) (B C : Finset (Fin n)) (P : Grouping A k) (θ : ℤ)
    (offset : Fin n → Fin d → ℕ) (localDigit : Fin n → Fin d → Fin m)
    (queryDigit : Fin n → Fin d → Fin base)
    (hu : ∀ a ∈ A, Digits.value base (fun i => offset a i + (localDigit a i).val) =
      residue J (x a))
    (hv : ∀ c ∈ C, Digits.value base (fun i => (queryDigit c i).val) =
      residue J (x c + θ)) :
    CleanAgreement J x B C P (dirtyCells hm hmb P C localDigit queryDigit)
      (polynomialEntries (p := p) (e := e) hm hmb hJ x B θ offset localDigit queryDigit) := by
  classical
  intro g c hc hd a ha
  have hnot : Digits.value base (fun i => (queryDigit c i).val) ∉
      Filter.exceptionalResidues hm hmb (localDigit a) := by
    intro hex
    apply hd
    exact mem_filter.mpr ⟨mem_product.mpr ⟨mem_univ g, hc⟩, a, ha, hex⟩
  unfold polynomialEntries
  rw [Filter.agreement hp he hq hm hmb hJ _ _ _ _ hnot]
  apply shiftedTable_agreement hJ x B θ a c
  · rw [hu a (P.subset g ha), residue_cast hJ]
  · rw [hv c hc, residue_cast hJ]

theorem polynomial_decision_iff (hp : p.Prime) (he : 0 < e)
    (hq : base + m - 1 < p) (hm : 1 ≤ m) (hmb : m ≤ base) (hJ : 0 < J)
    (x : Fin n → ℤ) (B C : Finset (Fin n)) (P : Grouping A k) (θ : ℤ)
    (offset : Fin n → Fin d → ℕ) (localDigit : Fin n → Fin d → Fin m)
    (queryDigit : Fin n → Fin d → Fin base)
    (hu : ∀ a ∈ A, Digits.value base (fun i => offset a i + (localDigit a i).val) =
      residue J (x a))
    (hv : ∀ c ∈ C, Digits.value base (fun i => (queryDigit c i).val) =
      residue J (x c + θ)) (hn : n < p ^ e) :
    (∃ gc ∈ selectedCells
      (polynomialEntries (p := p) (e := e) hm hmb hJ x B θ offset localDigit queryDigit)
      P C (dirtyCells hm hmb P C localDigit queryDigit), ExactCell x B P gc) ↔
        RoleSolution x A B C :=
  role_decision_iff x P _ _
    (polynomial_clean_agreement hp he hq hm hmb hJ x B C P θ offset
      localDigit queryDigit hu hv) hn

theorem residue_polynomial_decision_iff (hp : p.Prime) (he : 0 < e)
    (hq : base + m - 1 < p) (hm : 1 ≤ m) (hmb : m ≤ base) (hJ : 0 < J)
    (hJpow : J ≤ base ^ d) (x : Fin n → ℤ) (B C : Finset (Fin n))
    (P : Grouping A k) (θ : ℤ) (hn : n < p ^ e) :
    let hb : 0 < base := hm.trans hmb
    let inputs := fun a : Fin n => residueDigits base hb d J (x a)
    let queries := fun c : Fin n => residueDigits base hb d J (x c + θ)
    let offsets := fun a => splitOffset m (inputs a)
    let locals := fun a => splitLocal hm (inputs a)
    (∃ gc ∈ selectedCells
      (polynomialEntries (p := p) (e := e) hm hmb hJ x B θ offsets locals queries)
      P C (dirtyCells hm hmb P C locals queries), ExactCell x B P gc) ↔
        RoleSolution x A B C := by
  dsimp only
  apply polynomial_decision_iff hp he hq hm hmb hJ x B C P θ _ _ _ _ _ hn
  · intro a _
    rw [split_value]
    exact residueDigits_value _ hJ hJpow _
  · intro c _
    exact residueDigits_value _ hJ hJpow _

def checkedPrefix {α : Type*} (p : α → Prop) [DecidablePred p] : List α → List α
  | [] => []
  | a :: l => a :: (if p a then [] else checkedPrefix p l)

lemma checkedPrefix_sublist {α : Type*} (p : α → Prop) [DecidablePred p]
    (l : List α) : (checkedPrefix p l).Sublist l := by
  induction l with
  | nil => exact List.Sublist.refl []
  | cons a l ih =>
    simp only [checkedPrefix]
    split_ifs
    · exact List.Sublist.cons_cons a (List.nil_sublist l)
    · exact List.Sublist.cons_cons a ih

lemma checkedPrefix_success_unique {α : Type*} (p : α → Prop) [DecidablePred p]
    (l : List α) (a b : α) (ha : a ∈ checkedPrefix p l)
    (hb : b ∈ checkedPrefix p l) (hpa : p a) (hpb : p b) : a = b := by
  induction l with
  | nil => simp [checkedPrefix] at ha
  | cons c l ih =>
    by_cases hc : p c
    · simp only [checkedPrefix, ite_eq_left hc, List.mem_singleton] at ha hb
      exact ha.trans hb.symm
    · simp only [checkedPrefix, ite_eq_right hc, List.mem_cons] at ha hb
      have ha' : a ∈ checkedPrefix p l := ha.resolve_left (fun he => hc (he ▸ hpa))
      have hb' : b ∈ checkedPrefix p l := hb.resolve_left (fun he => hc (he ▸ hpb))
      exact ih ha' hb'

lemma checkedPrefix_success_iff {α : Type*} (p : α → Prop) [DecidablePred p]
    (l : List α) : (∃ a ∈ checkedPrefix p l, p a) ↔ ∃ a ∈ l, p a := by
  constructor
  · rintro ⟨a,ha,hp⟩
    exact ⟨a, (checkedPrefix_sublist p l).subset ha, hp⟩
  · induction l with
    | nil => simp
    | cons c l ih =>
      intro hex
      by_cases hc : p c
      · exact ⟨c, by simp [checkedPrefix, hc], hc⟩
      · obtain ⟨a,ha,hp⟩ := hex
        obtain ⟨b,hb,hpb⟩ := ih ⟨a, (List.mem_cons.mp ha).resolve_left
          (fun he => hc (he ▸ hp)), hp⟩
        exact ⟨b, by simp [checkedPrefix, hc, hb], hpb⟩

theorem checked_cell_count (x : Fin n → ℤ) (P : Grouping A k)
    (D : Finset (Fin k × Fin n)) (E : Fin n → Fin n → ZMod T)
    (h : CleanAgreement J x B C P D E) (hn : n < T)
    (l : List (Fin k × Fin n)) (hl : l.toFinset ⊆ selectedCells E P C D) :
    letI : DecidablePred (ExactCell x B P) := Classical.decPred _
    ((checkedPrefix (ExactCell x B P) l).toFinset).card ≤
      D.card + (falseTriples J x A B C).card + 1 := by
  classical
  let v := (checkedPrefix (ExactCell x B P) l).toFinset
  have hsub : v ⊆ (D ∪ unsuccessfulClean x B C P D E) ∪
      v.filter (ExactCell x B P) := by
    intro gc hgc
    by_cases he : ExactCell x B P gc
    · exact mem_union_right _ (mem_filter.mpr ⟨hgc,he⟩)
    · by_cases hd : gc ∈ D
      · exact mem_union_left _ (mem_union_left _ hd)
      · apply mem_union_left
        apply mem_union_right
        apply mem_filter.mpr
        exact ⟨hl (List.mem_toFinset.mpr ((checkedPrefix_sublist _ l).subset
          (List.mem_toFinset.mp hgc))), hd, he⟩
  have hone : (v.filter (ExactCell x B P)).card ≤ 1 := by
    apply card_le_one.mpr
    intro u hu v hv
    obtain ⟨hu, he⟩ := mem_filter.mp hu
    obtain ⟨hv, he'⟩ := mem_filter.mp hv
    exact checkedPrefix_success_unique _ l u v
      (List.mem_toFinset.mp hu) (List.mem_toFinset.mp hv) he he'
  have hun := unsuccessful_clean_card_le x P D E h hn
  have hu1 := card_union_le D (unsuccessfulClean x B C P D E)
  have hu2 := card_union_le (D ∪ unsuccessfulClean x B C P D E)
    (v.filter (ExactCell x B P))
  have hv := card_le_card hsub
  change v.card ≤ _
  omega

theorem pair_check_count (x : Fin n → ℤ) (P : Grouping A k)
    (D : Finset (Fin k × Fin n)) (E : Fin n → Fin n → ZMod T)
    (h : CleanAgreement J x B C P D E) (hn : n < T)
    (s : ℕ) (hs : ∀ g, (P.members g).card ≤ s)
    (l : List (Fin k × Fin n)) (hl : l.toFinset ⊆ selectedCells E P C D)
    (hlnd : l.Nodup) :
    letI : DecidablePred (ExactCell x B P) := Classical.decPred _
    let v := checkedPrefix (ExactCell x B P) l
    v.Nodup ∧ (∑ gc ∈ v.toFinset, (P.members gc.1).card) ≤
      s * (D.card + (falseTriples J x A B C).card + 1) := by
  classical
  let v := checkedPrefix (ExactCell x B P) l
  refine ⟨hlnd.sublist (checkedPrefix_sublist _ l), ?_⟩
  calc
    ∑ gc ∈ v.toFinset, (P.members gc.1).card ≤ ∑ _gc ∈ v.toFinset, s :=
      sum_le_sum (fun gc _ => hs gc.1)
    _ = s * v.toFinset.card := by simp [Nat.mul_comm]
    _ ≤ s * (D.card + (falseTriples J x A B C).card + 1) :=
      Nat.mul_le_mul_left s (checked_cell_count x P D E h hn l hl)

namespace Roles

variable {r : ℕ}

def bitLength (n : ℕ) : ℕ := Nat.clog 2 (n + 1)

def positionBits (i : Fin n) : Fin (bitLength n) → Bool :=
  fun j => (i.val + 1).testBit j.val

lemma positionBits_injective : Function.Injective (positionBits (n := n)) := by
  intro a b hab
  apply Fin.ext
  have he : a.val + 1 = b.val + 1 := by
    apply Nat.eq_of_testBit_eq
    intro j
    by_cases hj : j < bitLength n
    · exact congrFun hab ⟨j,hj⟩
    · have hpow : n + 1 ≤ 2 ^ bitLength n := Nat.le_pow_clog (by decide) _
      have hpj : 2 ^ bitLength n ≤ 2 ^ j := Nat.pow_le_pow_right (by decide) (by omega)
      have ha : a.val + 1 < 2 ^ j := lt_of_lt_of_le (by omega) hpj
      have hb : b.val + 1 < 2 ^ j := lt_of_lt_of_le (by omega) hpj
      rw [Nat.testBit_lt_two_pow ha, Nat.testBit_lt_two_pow hb]
  omega

abbrev Color := Fin 3 → Bool

def sampledColor (code : Fin n → Fin r → Bool) (coords : Fin 3 → Fin r)
    (i : Fin n) : Color := fun j => code i (coords j)

lemma separating_coordinates (code : Fin n → Fin r → Bool)
    (hcode : Function.Injective code) (a b c : Fin n)
    (hab : a ≠ b) (hbc : b ≠ c) (hac : a ≠ c) :
    ∃ coords : Fin 3 → Fin r,
      sampledColor code coords a ≠ sampledColor code coords b ∧
      sampledColor code coords b ≠ sampledColor code coords c ∧
      sampledColor code coords a ≠ sampledColor code coords c := by
  classical
  have hdiff : ∀ u v : Fin n, u ≠ v → ∃ t : Fin r, code u t ≠ code v t := by
    intro u v huv
    by_contra! h
    exact huv (hcode (funext h))
  obtain ⟨i,hi⟩ := hdiff a b hab
  obtain ⟨j,hj⟩ := hdiff b c hbc
  obtain ⟨l,hl⟩ := hdiff a c hac
  let coords : Fin 3 → Fin r := ![i,j,l]
  refine ⟨coords, ?_, ?_, ?_⟩
  · intro he
    exact hi (congrFun he 0)
  · intro he
    exact hj (congrFun he 1)
  · intro he
    exact hl (congrFun he 2)

abbrev Search (r : ℕ) := (Fin 3 → Fin r) × (Fin 3 ↪ Color)

def role (code : Fin n → Fin r → Bool) (s : Search r) (j : Fin 3) : Finset (Fin n) :=
  univ.filter (fun i => sampledColor code s.1 i = s.2 j)

lemma role_disjoint (code : Fin n → Fin r → Bool) (s : Search r)
    {i j : Fin 3} (hij : i ≠ j) : Disjoint (role code s i) (role code s j) := by
  apply Finset.disjoint_left.mpr
  intro a hi hj
  exact hij (s.2.injective ((mem_filter.mp hi).2.symm.trans (mem_filter.mp hj).2))

lemma search_card (r : ℕ) : Fintype.card (Search r) = 8 * 7 * 6 * r ^ 3 := by
  simp only [Search, Fintype.card_prod, Fintype.card_fun, Fintype.card_fin,
    Fintype.card_embedding_eq, Color, Fintype.card_bool]
  norm_num [Nat.descFactorial]
  omega

lemma positions_covered (code : Fin n → Fin r → Bool)
    (hcode : Function.Injective code) (a b c : Fin n)
    (hab : a ≠ b) (hbc : b ≠ c) (hac : a ≠ c) :
    ∃ s : Search r, a ∈ role code s 0 ∧ b ∈ role code s 1 ∧ c ∈ role code s 2 := by
  classical
  obtain ⟨coords,hAB,hBC,hAC⟩ := separating_coordinates code hcode a b c hab hbc hac
  let colors : Fin 3 → Color :=
    ![sampledColor code coords a, sampledColor code coords b, sampledColor code coords c]
  have hcolors : Function.Injective colors := by
    intro i j hij
    fin_cases i <;> fin_cases j <;> simp_all [colors]
  let s : Search r := ⟨coords, ⟨colors, hcolors⟩⟩
  refine ⟨s, ?_, ?_, ?_⟩ <;> exact mem_filter.mpr ⟨mem_univ _, rfl⟩

theorem threeSUM_iff_search (x : Fin n → ℤ) :
    ThreeSUM x ↔ ∃ s : Search (bitLength n),
      RoleSolution x (role positionBits s 0) (role positionBits s 1) (role positionBits s 2) := by
  constructor
  · rintro ⟨a,b,c,hab,hbc,hz⟩
    obtain ⟨s,ha,hb,hc⟩ := positions_covered positionBits positionBits_injective a b c
      (ne_of_lt hab) (ne_of_lt hbc) (ne_of_lt (hab.trans hbc))
    exact ⟨s,a,ha,b,hb,c,hc,hz⟩
  · rintro ⟨s,hs⟩
    exact role_solution_threeSUM x (role_disjoint _ s (by decide))
      (role_disjoint _ s (by decide)) (role_disjoint _ s (by decide)) hs

end Roles
end DeterministicThreeSum.DeterministicDecision

end OAI