import OAI.Combinatorics.LowSpaceSubsetSum.Storage.FiniteSetCells
import OAI.Combinatorics.LowSpaceSubsetSum.Search.ComputedParentFuels

namespace OAI

/-! # Constant-state loop limits and their live domain scans

The length, binomial, and doubling loops retain scalar accumulators only.
No leaf occurrence is enumerated. The three domain lists are retained
through the scalar computation and released when the leaf limit returns.
-/

namespace LowSpaceSubsetSum.ComputedFuelCells

variable {n : ℕ}

def lengthLoop {α : Type*} : List α → ℕ → ℕ → (ℕ × ℕ) × ℕ
  | [], value, work => ((value, work+1), 8)
  | _ :: xs, value, work => lengthLoop xs (value+1) (work+2)

theorem lengthLoop_formula {α : Type*} (xs : List α) (value work : ℕ) :
    lengthLoop xs value work = ((value+xs.length, work+2*xs.length+1), 8) := by
  induction xs generalizing value work with
  | nil => simp only [lengthLoop, List.length_nil, Nat.add_zero, Nat.mul_zero]
  | cons x xs ih =>
    simp only [lengthLoop, ih, List.length_cons]
    congr 2 <;> omega

def powerLoop : ℕ → ℕ → ℕ → (ℕ × ℕ) × ℕ
  | 0, value, work => ((value, work+1), 8)
  | k+1, value, work => powerLoop k (2*value) (work+3)

theorem powerLoop_formula (k value work : ℕ) :
    powerLoop k value work = ((value*2^k, work+3*k+1), 8) := by
  induction k generalizing value work with
  | zero => simp only [powerLoop, pow_zero, Nat.mul_one, Nat.mul_zero, Nat.add_zero]
  | succ k ih =>
    simp only [powerLoop, ih, pow_succ]
    congr 2 <;> ring

def chooseAcc (n : ℕ) : ℕ → CountedBinomial.State → CountedBinomial.State × ℕ
  | 0, s => (s, 16)
  | k+1, s => chooseAcc n k (CountedBinomial.step n s)

theorem chooseAcc_value (n k : ℕ) (s : CountedBinomial.State) :
    (chooseAcc n k s).1 = CountedBinomial.runAcc n k s := by
  induction k generalizing s with
  | zero => rfl
  | succ k ih => exact ih _

theorem chooseAcc_cells (n k : ℕ) (s : CountedBinomial.State) :
    (chooseAcc n k s).2 ≤ 16 := by
  induction k generalizing s with
  | zero => exact le_rfl
  | succ k ih => exact ih _

def choose (n k : ℕ) : CountedBinomial.State × ℕ :=
  if k ≤ n then chooseAcc n k CountedBinomial.initial else (⟨k, 0, 0⟩, 16)

theorem choose_value (n k : ℕ) : (choose n k).1 = CountedBinomial.run n k := by
  simp only [choose, CountedBinomial.run]
  split
  · exact chooseAcc_value _ _ _
  · rfl

theorem choose_cells (n k : ℕ) : (choose n k).2 ≤ 16 := by
  rw [choose]
  split
  · exact chooseAcc_cells _ _ _
  · exact le_rfl

def leaf (L : RepresentationLeaf (Fin n)) : (ℕ × ℕ) × ℕ :=
  let ts := FiniteSetCells.domain L.top
  let ms := FiniteSetCells.domain L.mixer
  let bs := FiniteSetCells.domain L.background
  let nt := lengthLoop ts.1.1 0 0
  let nm := lengthLoop ms.1.1 0 0
  let nb := lengthLoop bs.1.1 0 0
  let a := choose nt.1.1 L.topCount
  let b := choose nm.1.1 L.localCount
  let c := powerLoop nb.1.1 1 0
  ((a.1.value*b.1.value*c.1.1,
      ts.1.2+ms.1.2+bs.1.2+nt.1.2+nm.1.2+nb.1.2+
        8*a.1.steps+8*b.1.steps+c.1.2+12),
    ts.2+ms.2+bs.2+nt.2+nm.2+nb.2+a.2+b.2+c.2+6*n+32)

theorem leaf_value (L : RepresentationLeaf (Fin n)) :
    (leaf L).1 = ComputedParentFuels.leaf L := by
  rw [ComputedParentFuels.leaf_formula]
  simp only [leaf, lengthLoop_formula, powerLoop_formula, FiniteSetCells.domain_value,
    RepresentationLeaf.domainSort_length, choose_value, CountedBinomial.run_value,
    Nat.zero_add, Nat.one_mul]

theorem leaf_cells (L : RepresentationLeaf (Fin n)) :
    (leaf L).2 ≤ 256*(n+1)^2 := by
  have ht := FiniteSetCells.domain_cells L.top
  have hm := FiniteSetCells.domain_cells L.mixer
  have hb := FiniteSetCells.domain_cells L.background
  have ha := choose_cells (lengthLoop (FiniteSetCells.domain L.top).1.1 0 0).1.1 L.topCount
  have hbb := choose_cells (lengthLoop (FiniteSetCells.domain L.mixer).1.1 0 0).1.1 L.localCount
  simp only [lengthLoop_formula, Nat.zero_add] at ha hbb
  simp only [leaf, lengthLoop_formula, powerLoop_formula, Nat.zero_add]
  nlinarith only [ht, hm, hb, ha, hbb, Nat.zero_le n]

def run (D : RepresentationParentData n) : (ComputedParentFuels.Values × ℕ) × ℕ :=
  let a := leaf (D.leaves 0)
  let b := leaf (D.leaves 1)
  let c := leaf (D.leaves 2)
  let d := leaf (D.leaves 3)
  let f := a.1.1*b.1.1
  let g := c.1.1*d.1.1
  ((⟨f, g, f+g+1⟩, a.1.2+b.1.2+c.1.2+d.1.2+7), a.2+b.2+c.2+d.2+32)

theorem run_value (D : RepresentationParentData n) :
    (run D).1 = ComputedParentFuels.run D := by
  simp only [run, leaf_value, ComputedParentFuels.run]

theorem run_cells (D : RepresentationParentData n) (hn : 10000 ≤ n) :
    (run D).2 ≤ inputScale D.input^3 := by
  have h₀ := leaf_cells (D.leaves 0)
  have h₁ := leaf_cells (D.leaves 1)
  have h₂ := leaf_cells (D.leaves 2)
  have h₃ := leaf_cells (D.leaves 3)
  have hu : n+1 ≤ inputScale D.input := by unfold inputScale; omega
  have hu0 : 10000 ≤ inputScale D.input := by omega
  have hq := Nat.pow_le_pow_left hu 2
  have hpos : 1 ≤ (n+1)^2 := Nat.one_le_pow _ _ (by omega)
  have hmajor : 1056*inputScale D.input^2 ≤ inputScale D.input^3 := by
    calc
      _ ≤ inputScale D.input*inputScale D.input^2 := Nat.mul_le_mul_right _ (by omega)
      _ = _ := (pow_succ' _ _).symm
  change _+_+_+_+32 ≤ _
  nlinarith only [h₀, h₁, h₂, h₃, hq, hpos, hmajor]

end LowSpaceSubsetSum.ComputedFuelCells

end OAI