import OAI.Computability.BinPacking.Computation.MachineFiniteAlphabet

namespace OAI

namespace BinPackingGap.MachineBoundedIteration

open Turing BinPackingGames.Foundations.Complexity

def inputBits {α : Type} (encode : α → List Bool) (p : Nat × α) : List Bool :=
  encodeWord p.1 ++ encode p.2

@[simp] theorem inputBits_length {α : Type} (encode : α → List Bool) (p : Nat × α) :
    (inputBits encode p).length = p.1 + 1 + (encode p.2).length := by
  simp [inputBits, encodeWord_length]

def iterate {α : Type} (step : α → α) (p : Nat × α) : α := step^[p.1] p.2

noncomputable def timeBound (body growth : Polynomial Nat) : Polynomial Nat :=
  Polynomial.X + 1 +
    Polynomial.X * (body.comp growth + Polynomial.C 2 * growth + Polynomial.C 3) +
    Polynomial.C 2 * growth + Polynomial.C 3

theorem timeBound_eval (body growth : Polynomial Nat) (n : Nat) :
    (timeBound body growth).eval n =
      n + 1 + n * (body.eval (growth.eval n) + 2 * growth.eval n + 3) +
        2 * growth.eval n + 3 := by
  simp [timeBound, Polynomial.eval_comp]

def GrowthBound {α : Type} (encode : α → List Bool) (step : α → α)
    (growth : Polynomial Nat) : Prop :=
  ∀ (p : Nat × α) (i : Nat), i ≤ p.1 →
    (encode (step^[i] p.2)).length ≤ growth.eval (inputBits encode p).length

noncomputable def computation {α : Type} (encode : α → List Bool) (step : α → α)
    (body : TM2ComputableInPolyTime encode encode step)
    (growth : Polynomial Nat) (bounded : GrowthBound encode step growth) :
    TM2ComputableInPolyTime (inputBits encode) encode (iterate step) where
  tm := MachineRepeat.machine body.tm body.inputAlphabet body.outputAlphabet
  inputAlphabet := body.inputAlphabet
  outputAlphabet := body.inputAlphabet
  time := timeBound body.time growth
  outputsFun p := by
    let words : Nat → List Bool := fun i => encode (step^[i] p.2)
    let budgets : Nat → Nat := fun i => body.time.eval (words i).length
    have runs : ∀ i, i < p.1 →
        TM2OutputsInTime body.tm ((words i).map body.inputAlphabet.symm)
          (some ((words (i + 1)).map body.outputAlphabet.symm)) (budgets i) := by
      intro i _
      simpa only [words, budgets, Function.iterate_succ_apply', Equiv.invFun_as_coe] using
        body.outputsFun (step^[i] p.2)
    have run := MachineRepeat.executeSequence body.tm body.inputAlphabet body.outputAlphabet
      p.1 words budgets runs
    have countBound : p.1 ≤ (inputBits encode p).length := by
      rw [inputBits_length]
      omega
    have bodyBound : ∀ i, i < p.1 →
        budgets i ≤ body.time.eval (growth.eval (inputBits encode p).length) := by
      intro i hi
      exact MachineComposition.natPolynomial_eval_mono body.time
        (bounded p i (Nat.le_of_lt hi))
    have lengthBound : ∀ i, i ≤ p.1 →
        (words i).length ≤ growth.eval (inputBits encode p).length := by
      intro i hi
      exact bounded p i hi
    have loopBound := MachineRepeat.loopBudget_le p.1 words budgets
      (body.time.eval (growth.eval (inputBits encode p).length))
      (growth.eval (inputBits encode p).length) bodyBound lengthBound
    have productBound := Nat.mul_le_mul_right
      (body.time.eval (growth.eval (inputBits encode p).length) +
        2 * growth.eval (inputBits encode p).length + 3) countBound
    refine { toEvalsTo := run.toEvalsTo, steps_le_m := ?_ }
    have actualBound := run.steps_le_m
    rw [timeBound_eval]
    omega

theorem computation_finiteAlphabet {α : Type} (encode : α → List Bool) (step : α → α)
    (body : TM2ComputableInPolyTime encode encode step)
    (growth : Polynomial Nat) (bounded : GrowthBound encode step growth)
    (finite : MachineFiniteAlphabet.FiniteAlphabet body.tm) :
    MachineFiniteAlphabet.FiniteAlphabet (computation encode step body growth bounded).tm :=
  MachineFiniteAlphabet.repeat_machine body.tm body.inputAlphabet body.outputAlphabet finite

end BinPackingGap.MachineBoundedIteration

end OAI