import Mathlib
import OAI.Combinatorics.IndependentSets.Machines.MachineFiniteAlphabet
import OAI.Combinatorics.IndependentSets.Machines.GraphCounterFinish

namespace OAI

namespace LargeIndependentSets.BoundedIteration
open Turing
open IndependentSetsGames.Foundations.Complexity

variable {α β : Type}

def counted (count : α → ℕ) (enc : β → List Bool) (start : α → β) (a : α) : List Bool :=
  encodeWord (count a) ++ enc (start a)

lemma count_le (count : α → ℕ) (enc : β → List Bool) (start : α → β) (a : α) :
    count a ≤ (counted count enc start a).length := by
  simp [counted,encodeWord]

noncomputable def runtime (body length : Polynomial ℕ) : Polynomial ℕ :=
  Polynomial.X*(body.comp length + 2*length + 4) + 2*length + 4

lemma runtime_eval (body length : Polynomial ℕ) (n : ℕ) :
    (runtime body length).eval n = n*(body.eval (length.eval n)+2*length.eval n+4)+2*length.eval n+4 := by
  simp [runtime]

noncomputable def certificate (enc : β → List Bool) (step : β → β) (start : α → β)
    (count : α → ℕ) (body : TM2ComputableInPolyTime enc enc step) (length : Polynomial ℕ)
    (growth : ∀ a i, i≤count a → (enc (step^[i] (start a))).length ≤
      length.eval (counted count enc start a).length) :
    TM2ComputableInPolyTime (counted count enc start) enc
      (fun a => step^[count a] (start a)) where
  tm := MachineRepeat.machine body.tm body.inputAlphabet body.outputAlphabet
  inputAlphabet := body.inputAlphabet
  outputAlphabet := body.inputAlphabet
  time := runtime body.time length
  outputsFun a := by
    let words : ℕ → List Bool := fun i => enc (step^[i] (start a))
    let budgets : ℕ → ℕ := fun i => body.time.eval (words i).length
    have runs (i : ℕ) (_hi : i<count a) :
        TM2OutputsInTime body.tm ((words i).map body.inputAlphabet.symm)
          (some ((words (i+1)).map body.outputAlphabet.symm)) (budgets i) := by
      simpa only [words,budgets,Function.iterate_succ_apply',Equiv.symm,Equiv.coe_fn_mk] using
        body.outputsFun (step^[i] (start a))
    let run := MachineRepeat.executeSequence body.tm body.inputAlphabet body.outputAlphabet
      (count a) words budgets runs
    have start_eq : encodeWord (count a) ++ words 0 = counted count enc start a := rfl
    rw [start_eq] at run
    refine { toEvalsTo := run.toEvalsTo, steps_le_m := ?_ }
    let N := (counted count enc start a).length
    let L := length.eval N
    let B := body.time.eval L
    have hl (i : ℕ) (hi : i≤count a) : (words i).length≤L := growth a i hi
    have hb (i : ℕ) (hi : i<count a) : budgets i≤B :=
      MachineComposition.natPolynomial_eval_mono body.time (hl i hi.le)
    have hloop := MachineRepeat.loopBudget_le (count a) words budgets B L hb hl
    have hc : count a≤N := count_le count enc start a
    rw [runtime_eval]
    calc
      run.steps ≤ count a+1+MachineRepeat.loopBudget (count a) words budgets := run.steps_le_m
      _ ≤ count a+1+(count a*(B+2*L+3)+2*L+3) := Nat.add_le_add_left hloop _
      _ = count a*(B+2*L+4)+2*L+4 := by ring
      _ ≤ N*(B+2*L+4)+2*L+4 := by gcongr

lemma certificate_finiteAlphabet (enc : β → List Bool) (step : β → β) (start : α → β)
    (count : α → ℕ) (body : TM2ComputableInPolyTime enc enc step) (length : Polynomial ℕ)
    (growth) (hbody : MachineFiniteAlphabet.FiniteAlphabet body.tm)
    (k : (certificate enc step start count body length growth).tm.K) :
    Finite ((certificate enc step start count body length growth).tm.Γ k) :=
  MachineFiniteAlphabet.repeat_machine body.tm body.inputAlphabet body.outputAlphabet hbody k
end LargeIndependentSets.BoundedIteration

end OAI