import OAI.Combinatorics.LowSpaceSubsetSum.Storage.ComputedFuelCells
import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationAllocationExecution

namespace OAI

/-! # Constant-state integer allocation and its six stored widths -/

namespace LowSpaceSubsetSum.AllocationCells

open scoped BigOperators

def logarithm : ℕ → ℕ → ℕ → ℕ → (ℕ × ℕ) × ℕ
  | 0, _, value, work => ((value, work+1), 8)
  | fuel+1, x, value, work =>
    if 2 ≤ x then logarithm fuel (x/2) (value+1) (work+3)
    else ((value, work+1), 8)

theorem logarithm_value (fuel x value work : ℕ) :
    (logarithm fuel x value work).1 = MeasuredLog2.loop fuel x value work := by
  induction fuel generalizing x value work with
  | zero => rfl
  | succ fuel ih => simp only [logarithm, MeasuredLog2.loop]; split <;> simp_all only

theorem logarithm_cells (fuel x value work : ℕ) : (logarithm fuel x value work).2 ≤ 8 := by
  induction fuel generalizing x value work with
  | zero => exact le_rfl
  | succ fuel ih => simp only [logarithm]; split <;> simp_all only [le_refl]

def bits (m k : ℕ) : (ℕ × ℕ) × ℕ :=
  let choose := ComputedFuelCells.choose m k
  let log := logarithm m choose.1.value 0 0
  ((log.1.1, 8*choose.1.steps+log.1.2+8), choose.2+log.2+16)

theorem bits_value (m k : ℕ) : (bits m k).1 = RepresentationAllocationExecution.bits m k := by
  simp only [bits, ComputedFuelCells.choose_value, logarithm_value,
    RepresentationAllocationExecution.bits, MeasuredLog2.run]

theorem bits_cells (m k : ℕ) : (bits m k).2 ≤ 40 := by
  have hc := ComputedFuelCells.choose_cells m k
  have hl := logarithm_cells m (ComputedFuelCells.choose m k).1.value 0 0
  change _+_+16 ≤ _
  omega

def run (n : ℕ) (guesses : Vector ℕ 3) : (Vector ℕ 8 × ℕ) × ℕ :=
  let bs := Vector.ofFn (fun side : Fin 2 => Vector.ofFn (fun j : Fin 3 =>
    bits (mixerSize n) (if side = 0 then guesses[j.val] else mixerSize n/2-guesses[j.val])))
  let counts := computedLeafCounts (representationBackgroundSize n)
    bs[0][0].1.1 bs[1][0].1.1 bs[0][1].1.1 bs[1][1].1.1 bs[0][2].1.1 bs[1][2].1.1
  ((Vector.ofFn counts, (∑ side : Fin 2, ∑ j : Fin 3, bs[side.val][j.val].1.2)+100),
    (∑ side : Fin 2, ∑ j : Fin 3, bs[side.val][j.val].2)+64)

theorem value (n : ℕ) (guesses : Vector ℕ 3) :
    (run n guesses).1 = RepresentationAllocationExecution.run n guesses := by
  simp only [run, RepresentationAllocationExecution.run, Vector.getElem_ofFn, bits_value]

theorem cells (n : ℕ) (guesses : Vector ℕ 3) : (run n guesses).2 ≤ 304 := by
  have h := Finset.sum_le_sum (fun side (_ : side ∈ (Finset.univ : Finset (Fin 2))) =>
    Finset.sum_le_sum (fun j (_ : j ∈ (Finset.univ : Finset (Fin 3))) =>
      bits_cells (mixerSize n) (if side = 0 then guesses[j.val] else mixerSize n/2-guesses[j.val])))
  simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] at h
  simp only [run, Vector.getElem_ofFn, Fin.eta]
  omega

end LowSpaceSubsetSum.AllocationCells

end OAI