import Mathlib
import OAI.RepresentationTheory.Saxl.Main
import OAI.RepresentationTheory.UniversalSquare.Support.ResidualTrees

namespace OAI

/-! Row Checker. -/

section

namespace UniversalTensorSquare

def quickRejected (fuel n upper : ℕ) (A B : List (ℕ × ℕ)) : Bool :=
  decide (n < fuel) || decide (fuel*upper < n) ||
    A.any (fun p => decide (0 < p.1) && decide (p.2 < fuel)) ||
    B.any (fun p => decide (fuel ≤ p.1) && decide (p.2 < n)) ||
    A.any (fun p => decide (p.2*upper < n*min p.1 upper)) ||
    B.any (fun p => decide (p.2*fuel < n*min p.1 fuel))

lemma quickRejected_iff (fuel n upper : ℕ) (A B : List (ℕ × ℕ)) :
    quickRejected fuel n upper A B = true ↔ rejectedRows fuel n upper A B := by
  simp only [quickRejected,rejectedRows,Bool.or_eq_true,Bool.and_eq_true,
    List.any_eq_true,decide_eq_true_eq]
  simp only [or_assoc]

def quickAllowed (a : ℕ) (A B : List (ℕ × ℕ)) : Bool :=
  A.all (fun p => decide (min p.1 a ≤ p.2)) &&
    B.all (fun p => decide (p.1 = 0) || decide (a ≤ p.2))

lemma quickAllowed_iff (a : ℕ) (A B : List (ℕ × ℕ)) :
    quickAllowed a A B = true ↔ allowedRow a A B := by
  simp only [quickAllowed,allowedRow,Bool.and_eq_true,List.all_eq_true,
    Bool.or_eq_true,decide_eq_true_eq]
  constructor
  · rintro ⟨hA,hB⟩
    refine ⟨hA,fun p hp hk => ?_⟩
    obtain h | h := hB p hp
    · omega
    · exact h
  · rintro ⟨hA,hB⟩
    refine ⟨hA,fun p hp => ?_⟩
    by_cases hz : p.1 = 0
    · exact Or.inl hz
    · exact Or.inr (hB p hp (by omega))

def checkRowPrefixes (P : List ℕ → Bool) : ℕ → ℕ → ℕ →
    List (ℕ × ℕ) → List (ℕ × ℕ) → List ℕ → Bool
  | fuel,n,upper,A,B,pref =>
      if quickRejected fuel n upper A B then true else
      match fuel with
      | 0 => if n = 0 then P pref.reverse else true
      | k+1 =>
          let lo := max 1 (n/(k+1))
          (List.range' lo (min n upper+1-lo)).all fun a =>
            if quickAllowed a A B && decide (n ≤ (k+1)*a) then
              checkRowPrefixes P k (n-a) a (clipBudget A a) (rowBudget B a) (a::pref)
            else true

lemma checkRowPrefixes_sound (P : List ℕ → Bool) (fuel n upper : ℕ)
    (A B : List (ℕ × ℕ)) (pref : List ℕ)
    (hc : checkRowPrefixes P fuel n upper A B pref = true) :
    ∀ rs ∈ constrainedRows fuel n upper A B, P (pref.reverse ++ rs) = true := by
  induction fuel generalizing n upper A B pref with
  | zero =>
    intro rs hrs
    rw [constrainedRows] at hrs
    split_ifs at hrs with hrej hn
    · simp at hrs
    · simp only [List.mem_singleton] at hrs
      subst rs
      simpa only [checkRowPrefixes, quickRejected_iff, ite_eq_right hrej, ite_eq_left hn, List.append_nil] using hc
    · simp at hrs
  | succ k ih =>
    intro rs hrs
    rw [constrainedRows] at hrs
    split_ifs at hrs with hrej
    · simp at hrs
    · obtain ⟨a,ha,hr⟩ := List.mem_flatMap.mp hrs
      split_ifs at hr with hallowed
      · obtain ⟨ys,hy,rfl⟩ := List.mem_map.mp hr
        have hlo : max 1 (n/(k+1)) ≤ a := by
          have hh := Nat.div_le_of_le_mul hallowed.2
          have ha' := (List.mem_range'_1.mp ha).1
          exact max_le ha' hh
        have hai : a ∈ List.range' (max 1 (n/(k+1)))
            (min n upper+1-max 1 (n/(k+1))) := by
          have ha' := List.mem_range'_1.mp ha
          apply List.mem_range'_1.mpr
          refine ⟨hlo, ?_⟩
          have he : max 1 (n/(k+1)) + (min n upper+1-max 1 (n/(k+1))) = min n upper+1 := by
            apply Nat.add_sub_of_le
            omega
          rw [he]
          omega
        rw [checkRowPrefixes] at hc
        simp only [quickRejected_iff, ite_eq_right hrej] at hc
        have hh := List.all_eq_true.mp hc a hai
        simp only [Bool.and_eq_true,quickAllowed_iff,decide_eq_true_eq,ite_eq_left hallowed] at hh
        have hi := ih (n-a) a (clipBudget A a) (rowBudget B a) (a::pref) hh ys hy
        simpa only [List.reverse_cons, List.append_assoc, List.singleton_append] using hi
      · simp at hr

lemma checked_constrainedRows (P : List ℕ → Prop) [DecidablePred P]
    (fuel n upper : ℕ) (A B : List (ℕ × ℕ))
    (h : checkRowPrefixes (fun rs => decide (P rs)) fuel n upper A B [] = true) :
    ∀ rs ∈ constrainedRows fuel n upper A B, P rs := by
  intro rs hrs
  have hh := checkRowPrefixes_sound (fun rs => decide (P rs)) fuel n upper A B [] h rs hrs
  simp only [List.reverse_nil,List.nil_append] at hh
  exact of_decide_eq_true hh

end UniversalTensorSquare
end

end OAI