import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationBucketProgram

namespace OAI

/-! # A family-independent list of the completed prefix checks

These lists describe the hypothetical full traversal for analysis. The
executable search regenerates one task at a time and stops at its first YES.
-/

namespace LowSpaceSubsetSum.RepresentationParentData

variable {n : ℕ} (D : RepresentationParentData n)

def completedArrays (B : ℕ) : List (Fin n) → MaskRestriction n → List (Array (Entry (Fin n)))
  | order, P =>
    let task := { D with maskRestriction := P }
    let out := (task.collect B).state.user
    if out.keys.overflow then
      match order with
      | [] => []
      | i :: rest => completedArrays B rest (P.force i false) ++
          completedArrays B rest (P.force i true)
    else [out.records]

theorem searchRight_eq_any (B : ℕ) (check : Array (Entry (Fin n)) → Bool)
    (order : List (Fin n)) (P : MaskRestriction n) :
    D.searchRight B check order P = (D.completedArrays B order P).any check := by
  induction order generalizing P with
  | nil =>
    simp only [searchRight, completedArrays]
    split <;> simp
  | cons i order ih =>
    simp only [searchRight, completedArrays]
    split
    · rw [List.any_append, ← ih, ← ih]
      split <;> simp_all
    · simp

theorem mem_completedArrays (B : ℕ) (order : List (Fin n)) (P : MaskRestriction n)
    (a : Array (Entry (Fin n))) (ha : a ∈ D.completedArrays B order P) :
    ∃ Q : MaskRestriction n,
      ({ D with maskRestriction := Q }.collect B).state.user.keys.overflow = false ∧
        a = { D with maskRestriction := Q }.entries B := by
  induction order generalizing P with
  | nil =>
    simp only [completedArrays] at ha
    split at ha
    · simp at ha
    · rename_i hc
      have he : a = ({ D with maskRestriction := P }.collect B).state.user.records := by
        simpa only [List.mem_singleton] using ha
      exact ⟨P, Bool.eq_false_iff.mpr hc, he⟩
  | cons i order ih =>
    simp only [completedArrays] at ha
    split at ha
    · rcases List.mem_append.mp ha with hl | hr
      · exact ih (P.force i false) hl
      · exact ih (P.force i true) hr
    · rename_i hc
      have he : a = ({ D with maskRestriction := P }.collect B).state.user.records := by
        simpa only [List.mem_singleton] using ha
      exact ⟨P, Bool.eq_false_iff.mpr hc, he⟩

end LowSpaceSubsetSum.RepresentationParentData

namespace LowSpaceSubsetSum.RepresentationBucketData

variable {n g : ℕ} (D : RepresentationBucketData n g)

def checkList (B : ℕ) : List (Array (Entry (Fin n)) × Array (Entry (Fin n))) :=
  let left := (D.left.collect B).state.user
  if left.keys.overflow then []
  else if left.records.isEmpty then []
  else (D.right.completedArrays B D.topOrder MaskRestriction.empty).map (left.records, ·)

theorem run_eq_any (B : ℕ) (families : Fin 4 → Array (Finset (Fin g))) :
    D.run B families = (D.checkList B).any (fun p => D.check families p.1 p.2) := by
  unfold run checkList
  dsimp only
  split
  · simp
  split
  · simp
  rw [D.right.searchRight_eq_any, List.any_map]
  rfl

end LowSpaceSubsetSum.RepresentationBucketData

end OAI