lean/OAI/Computability/BinPacking/CookLevin/TransitionIterationTime.lean

import OAI.Computability.BinPacking.CookLevin.ProducerFrontStage
import OAI.Computability.BinPacking.CookLevin.TransitionIteration

namespace OAI

noncomputable section

namespace BinPackingGames.Foundations.Complexity.CookLevin.AcceptanceMachine

open Turing MachineComposition TermMachine TransitionTemplate PostfixModel

inductive RootLabel
  | seed | scan | restore
  | lookup (label : LookupLabel)
  deriving DecidableEq, Fintype

def widthAddress (coefficient offset : Nat) (input : Input) : Nat :=
  coefficient * input.capacity + offset

def rootProgram (coefficient offset : Nat) : RootLabel → TM2.Stmt Alphabet RootLabel State
  | .seed => MachineUnaryAffineAt.seed .address offset .scan
  | .scan => MachineUnaryAffineAt.scan .capacity .scratch .address coefficient .scan .restore
  | .restore => Reduction.MachineTransfer.loopAt .scratch .capacity id false .restore
      (some (.lookup (.lookup (.run .copyFirst))))
  | .lookup label => MachineSubroutine.statement RootLabel.lookup none (lookupProgram 0 label)

def rootSteps (coefficient offset : Nat) (input : Input) : Nat :=
  (2 * (input.capacity + 1) + 1) +
    (MachinePreservingLookupClean.steps input.roots (widthAddress coefficient offset input) +
      rootLookup input.roots (widthAddress coefficient offset input) + 4)

private theorem trace_trans {α : Type*} (f : α → α) {a b : Nat} {x y z : α}
    (first : f^[a] x = y) (second : f^[b] y = z) : f^[a + b] x = z := by
  rw [Nat.add_comm, Function.iterate_add_apply, first, second]

theorem rootTrace (coefficient offset : Nat) (input : Input)
    (present : input.roots[widthAddress coefficient offset input]? =
      some (rootLookup input.roots (widthAddress coefficient offset input)))
    (base : Tape → List Bool) (frame : Frame input base) :
    (advance (TM2.step (rootProgram coefficient offset)))^[rootSteps coefficient offset input]
      (some ⟨some .seed, initialState, base⟩) =
      some ⟨none, initialState, emitTapes base
        [.input (rootLookup input.roots (widthAddress coefficient offset input))]⟩ := by
  have ha := frame.clean .address (by rfl)
  have hs := frame.clean .scratch (by rfl)
  have affine := MachineUnaryAffineAt.seededAffineTrace .capacity .scratch .address
    (by decide) (by decide) (by decide) coefficient offset RootLabel.seed
    RootLabel.scan RootLabel.restore (some (.lookup (.lookup (.run .copyFirst))))
    (rootProgram coefficient offset) rfl rfl rfl base input.capacity []
    (by simpa using frame.capacityWord) hs ((), false) none
  simp only [ha, List.append_nil] at affine
  have source := lookupTailTrace 0 input (widthAddress coefficient offset input) present base frame
  have lookup := MachineSubroutine.trace RootLabel.lookup none (lookupProgram 0)
    (rootProgram coefficient offset) (fun _ => rfl)
    (MachinePreservingLookupClean.steps input.roots (widthAddress coefficient offset input) +
      rootLookup input.roots (widthAddress coefficient offset input) + 4) _ _ source
  simp only [MachineSubroutine.configuration, MachineSubroutine.label] at lookup
  exact trace_trans _ affine lookup

theorem rootSteps_le (coefficient offset : Nat) (input : Input)
    (present : input.roots[widthAddress coefficient offset input]? =
      some (rootLookup input.roots (widthAddress coefficient offset input))) :
    rootSteps coefficient offset input ≤ 12 * (input.size + 1) := by
  have hl := MachinePreservingLookupClean.steps_le input.roots
    (widthAddress coefficient offset input) _ present
  have hw := MachineLookupSpec.output_length_le input.roots
    (widthAddress coefficient offset input) _ present
  rw [encodeWord_length] at hw
  unfold rootSteps Input.size
  omega

def rootEmitter (valid : Input → Prop) (coefficient offset : Nat)
    (present : ∀ input, valid input →
      input.roots[widthAddress coefficient offset input]? =
        some (rootLookup input.roots (widthAddress coefficient offset input))) :
    Emitter valid (fun input =>
      [.input (rootLookup input.roots (widthAddress coefficient offset input))]) where
  Label := RootLabel
  finite := inferInstance
  entry := .seed
  program := rootProgram coefficient offset
  steps := rootSteps coefficient offset
  constant := 12
  trace input hv base frame := rootTrace coefficient offset input (present input hv) base frame
  bound input hv := rootSteps_le coefficient offset input (present input hv)

def closurePorts : OrClosure.Ports Tape :=
  ⟨.position, .reversed, .count, by decide, by decide, by decide⟩

inductive ClosureLabel
  | seed | scan | restore | orSeed | orLoop | finish
  deriving DecidableEq

protected abbrev ClosureLabel.enumList : List ClosureLabel := [.seed, .scan, .restore, .orSeed,
  .orLoop, .finish]

protected theorem ClosureLabel.enumList_getElem?_ctorIdx_eq (x : ClosureLabel) :
    ClosureLabel.enumList[x.ctorIdx]? = some x := by
  cases x <;> rfl

protected theorem ClosureLabel.enumList_nodup : ClosureLabel.enumList.Nodup := by decide

instance : Fintype ClosureLabel where
  elems := ⟨ClosureLabel.enumList, ClosureLabel.enumList_nodup⟩
  complete x := by cases x <;> decide

def closureProgram (coefficient offset : Nat) :
    ClosureLabel → TM2.Stmt Alphabet ClosureLabel State
  | .seed => MachineUnaryAffineAt.seed .position offset .scan
  | .scan => MachineUnaryAffineAt.scan .capacity .scratch .position coefficient .scan .restore
  | .restore => Reduction.MachineTransfer.loopAt .scratch .capacity id false .restore (some .orSeed)
  | .orSeed => OrClosure.seed closurePorts .orLoop
  | .orLoop => OrClosure.loop closurePorts .orLoop (some .finish)
  | .finish => .pop .position (fun _ _ => initialState) .halt

def closureSteps (coefficient offset : Nat) (input : Input) : Nat :=
  (2 * (input.capacity + 1) + 1) + (widthAddress coefficient offset input + 2) + 1

theorem closureTrace (coefficient offset : Nat) (input : Input)
    (base : Tape → List Bool) (frame : Frame input base) :
    (advance (TM2.step (closureProgram coefficient offset)))^[closureSteps coefficient offset input]
      (some ⟨some .seed, initialState, base⟩) =
      some ⟨none, initialState, emitTapes base
        (InitializationTemplate.closeOr (widthAddress coefficient offset input))⟩ := by
  let width := widthAddress coefficient offset input
  let finished := OrClosure.frame closurePorts base (encodeWord 0)
    ((tokenBits (InitializationTemplate.closeOr width)).reverse ++ base .reversed)
    (List.replicate (width + 1) true ++ base .count)
  have hp := frame.clean .position (by rfl)
  have hs := frame.clean .scratch (by rfl)
  have affine := MachineUnaryAffineAt.seededAffineTrace .capacity .scratch .position
    (by decide) (by decide) (by decide) coefficient offset ClosureLabel.seed
    ClosureLabel.scan ClosureLabel.restore (some .orSeed)
    (closureProgram coefficient offset) rfl rfl rfl base input.capacity []
    (by simpa using frame.capacityWord) hs ((), false) none
  simp only [hp, List.append_nil] at affine
  have closure := OrClosure.closureTrace closurePorts ClosureLabel.orSeed ClosureLabel.orLoop
    (some .finish) (closureProgram coefficient offset) rfl rfl base width []
    (base .reversed) (base .count) ((), false) none
  have startFrame : OrClosure.frame closurePorts base (encodeWord width ++ [])
      (base .reversed) (base .count) = Function.update base .position (encodeWord width) := by
    funext tape
    cases tape <;> simp [OrClosure.frame, closurePorts]
  rw [startFrame] at closure
  simp only [List.append_nil] at closure
  have finish : (advance (TM2.step (closureProgram coefficient offset)))^[1]
      (some ⟨some .finish, initialState, finished⟩) =
      some ⟨none, initialState, emitTapes base (InitializationTemplate.closeOr width)⟩ := by
    change some (TM2.stepAux (closureProgram coefficient offset .finish) initialState finished) = _
    simp only [closureProgram, TM2.stepAux]
    congr 2
    funext tape
    cases tape <;> simp [finished, OrClosure.frame, closurePorts, emitTapes,
      InitializationTemplate.closeOr, encodeWord, hp, Nat.add_comm]
  exact trace_trans _ (trace_trans _ affine closure) finish

theorem closureSteps_le (coefficient offset : Nat) (input : Input) :
    closureSteps coefficient offset input ≤ (coefficient + offset + 8) * (input.size + 1) := by
  have hs : input.capacity ≤ input.size := by simp [Input.size]; omega
  have hmul := Nat.mul_le_mul_left coefficient hs
  unfold closureSteps widthAddress
  nlinarith

def closureEmitter (valid : Input → Prop) (coefficient offset : Nat) :
    Emitter valid (fun input => InitializationTemplate.closeOr (widthAddress coefficient offset input)) where
  Label := ClosureLabel
  finite := inferInstance
  entry := .seed
  program := closureProgram coefficient offset
  steps := closureSteps coefficient offset
  constant := coefficient + offset + 8
  trace input _ base frame := closureTrace coefficient offset input base frame
  bound input _ := closureSteps_le coefficient offset input

section Indexed

variable {K Λ σ : Type} {Γ : K → Type}

def Valid (indexing : ConfigIndex.Indexing Γ Λ σ) (input : Input) : Prop :=
  indexing.width input.capacity < input.roots.length

theorem Valid.roots {indexing : ConfigIndex.Indexing Γ Λ σ} {input : Input}
    (valid : Valid indexing input) : RootsValid indexing input := Nat.le_of_lt valid

theorem Valid.transition {indexing : ConfigIndex.Indexing Γ Λ σ} {input : Input}
    (valid : Valid indexing input) (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) :
    TransitionMachine.Valid indexing plan input := by
  unfold Valid at valid
  unfold TransitionMachine.Valid
  cases plan.carry <;> simp only [Bool.false_eq_true, ite_true, ite_false] <;> omega

theorem Valid.withCursor {indexing : ConfigIndex.Indexing Γ Λ σ} {input : Input}
    (valid : Valid indexing input) (cursor : Nat) :
    Valid indexing (TransitionMachine.withCursor input cursor) := valid

theorem widthAddress_eq (indexing : ConfigIndex.Indexing Γ Λ σ) (input : Input) :
    widthAddress indexing.symbolCount (indexing.labelCount + indexing.stateCount) input =
      indexing.width input.capacity := by
  simp [widthAddress, ConfigIndex.Indexing.width, Nat.mul_comm,
    Nat.add_comm, Nat.add_assoc]

def carryTokens (indexing : ConfigIndex.Indexing Γ Λ σ) (input : Input) : List Token :=
  [.input (rootLookup input.roots (indexing.width input.capacity))]

variable [DecidableEq K] [Fintype σ] [DecidableEq σ]
variable [∀ k, DecidableEq (Γ k)] [∀ k, Fintype (Γ k)] [DecidableEq Λ] [Fintype Λ]

def carryEmitter (indexing : ConfigIndex.Indexing Γ Λ σ) :
    Emitter (Valid indexing) (carryTokens indexing) :=
  (rootEmitter (Valid indexing) indexing.symbolCount (indexing.labelCount + indexing.stateCount)
    (fun input hv => by
      rw [widthAddress_eq]
      simp only [rootLookup, List.getElem?_eq_getElem hv, Option.getD_some])).congr
        (fun input => by rw [widthAddress_eq]; rfl)

def orEmitter (indexing : ConfigIndex.Indexing Γ Λ σ) :
    Emitter (Valid indexing) (fun input => InitializationTemplate.closeOr (indexing.width input.capacity)) :=
  (closureEmitter (Valid indexing) indexing.symbolCount (indexing.labelCount + indexing.stateCount)).congr
    (fun input => by rw [widthAddress_eq])

def finishEmitter (indexing : ConfigIndex.Indexing Γ Λ σ) :
    Emitter (Valid indexing) (fun _ => [.not, .and]) :=
  Emitter.literal (Valid indexing) [.not, .and]

inductive Label (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ))
  | carry (label : (carryEmitter indexing).Label)
  | mismatch (label : TransitionMachine.Label indexing plan)
  | close (label : (orEmitter indexing).Label)
  | finish (label : (finishEmitter indexing).Label)
  deriving Fintype

attribute [-instance] instFintypeLabel

instance labelFintype (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : Fintype (Label indexing plan) :=
  Fintype.ofEquiv
    ((carryEmitter indexing).Label ⊕ TransitionMachine.Label indexing plan ⊕
      (orEmitter indexing).Label ⊕ (finishEmitter indexing).Label)
    (Label.proxyTypeEquiv indexing plan)

def program (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) :
    Label indexing plan → TM2.Stmt Alphabet (Label indexing plan) State
  | .carry label => MachineSubroutine.statement Label.carry
      (some (.mismatch (.prefix (TransitionMachine.compilePrefix indexing plan.prefix).entry)))
      ((carryEmitter indexing).program label)
  | .mismatch label => MachineSubroutine.statement Label.mismatch
      (some (.close (orEmitter indexing).entry)) (TransitionMachine.program indexing plan label)
  | .close label => MachineSubroutine.statement Label.close
      (some (.finish (finishEmitter indexing).entry)) ((orEmitter indexing).program label)
  | .finish label => MachineSubroutine.statement Label.finish none ((finishEmitter indexing).program label)

def machine (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : FinTM2 where
  K := Tape
  k₀ := .capacity
  k₁ := .reversed
  Γ := Alphabet
  Λ := Label indexing plan
  main := .carry (carryEmitter indexing).entry
  σ := State
  initialState := initialState
  m := program indexing plan

def outputTokens (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : List Token :=
  carryTokens indexing input ++ TransitionMachine.outputTokens indexing plan input ++
    InitializationTemplate.closeOr (indexing.width input.capacity) ++ [.not, .and]

def steps (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : Nat :=
  (carryEmitter indexing).steps (TransitionMachine.withCursor input 0) +
    TransitionMachine.steps indexing plan input +
    (orEmitter indexing).steps (TransitionMachine.withCursor input 0) + 1

omit [DecidableEq K] [Fintype σ] [DecidableEq σ]
  [(tape : K) → DecidableEq (Γ tape)] [(tape : K) → Fintype (Γ tape)]
  [DecidableEq Λ] [Fintype Λ] in
theorem fullTrace (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input)
    (valid : Valid indexing input) (base : Tape → List Bool)
    (frame : Frame (TransitionMachine.withCursor input 0) base) :
    (advance (TM2.step (program indexing plan)))^[steps indexing plan input]
      (some ⟨some (Label.carry (carryEmitter indexing).entry), initialState, base⟩) =
      some ⟨none, initialState, emitTapes base (outputTokens indexing plan input)⟩ := by
  let carried := emitTapes base (carryTokens indexing input)
  let mismatch := emitTapes carried (TransitionMachine.outputTokens indexing plan input)
  let closed := emitTapes mismatch (InitializationTemplate.closeOr (indexing.width input.capacity))
  have carry := (carryEmitter indexing).traceAt Label.carry
    (some (.mismatch (.prefix (TransitionMachine.compilePrefix indexing plan.prefix).entry)))
    (program indexing plan) (fun _ => rfl) (TransitionMachine.withCursor input 0)
    (valid.withCursor 0) base frame
  have hcarry : Frame (TransitionMachine.withCursor input 0) carried :=
    frame.emit (carryTokens indexing input)
  have mid := TransitionMachine.traceAt indexing plan Label.mismatch
    (some (.close (orEmitter indexing).entry)) (program indexing plan) (fun _ => rfl)
    input (valid.transition plan) carried hcarry
  have hmid := hcarry.emit (TransitionMachine.outputTokens indexing plan input)
  have close := (orEmitter indexing).traceAt Label.close
    (some (.finish (finishEmitter indexing).entry)) (program indexing plan) (fun _ => rfl)
    (TransitionMachine.withCursor input 0) (valid.withCursor 0) mismatch hmid
  have hclose := hmid.emit (InitializationTemplate.closeOr (indexing.width input.capacity))
  have finish := (finishEmitter indexing).traceAt Label.finish none
    (program indexing plan) (fun _ => rfl) (TransitionMachine.withCursor input 0)
    (valid.withCursor 0) closed hclose
  have h := trace_trans _ (trace_trans _ (trace_trans _ carry mid) close) finish
  simpa only [steps, carried, mismatch, closed, finishEmitter, Emitter.literal,
    TransitionMachine.withCursor_capacity, TransitionMachine.withCursor_roots,
    carryTokens, emitTapes_append, outputTokens, List.append_assoc] using h

def timeConstant (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : Nat :=
  (carryEmitter indexing).constant + TransitionMachine.timeConstant indexing plan +
    (orEmitter indexing).constant + 1

noncomputable def timePolynomial (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : Polynomial Nat :=
  Polynomial.C (timeConstant indexing plan) * (Polynomial.X + 1)^2

omit [DecidableEq K] [Fintype σ] [DecidableEq σ]
  [(tape : K) → DecidableEq (Γ tape)] [(tape : K) → Fintype (Γ tape)]
  [DecidableEq Λ] [Fintype Λ] in
theorem steps_le (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input)
    (valid : Valid indexing input) :
    steps indexing plan input ≤ timeConstant indexing plan * (TransitionMachine.dataSize input + 1)^2 := by
  have hc := (carryEmitter indexing).bound (TransitionMachine.withCursor input 0) (valid.withCursor 0)
  have hm := TransitionMachine.steps_le indexing plan input (valid.transition plan)
  have ho := (orEmitter indexing).bound (TransitionMachine.withCursor input 0) (valid.withCursor 0)
  have hs : (TransitionMachine.withCursor input 0).size = TransitionMachine.dataSize input := by
    simp [TransitionMachine.withCursor, Input.size, TransitionMachine.dataSize]
  rw [hs] at hc ho
  have hsq : TransitionMachine.dataSize input + 1 ≤ (TransitionMachine.dataSize input + 1)^2 := by
    nlinarith
  have hc' := hc.trans (Nat.mul_le_mul_left (carryEmitter indexing).constant hsq)
  have ho' := ho.trans (Nat.mul_le_mul_left (orEmitter indexing).constant hsq)
  unfold steps timeConstant
  nlinarith

def inPolynomialTime (indexing : ConfigIndex.Indexing Γ Λ σ)
    (plan : TransitionMachine.Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input)
    (valid : Valid indexing input) (base : Tape → List Bool)
    (frame : Frame (TransitionMachine.withCursor input 0) base) :
    StateTransition.EvalsToInTime (machine indexing plan).step
      ⟨some (Label.carry (carryEmitter indexing).entry), initialState, base⟩
      (some ⟨none, initialState, emitTapes base (outputTokens indexing plan input)⟩)
      ((timePolynomial indexing plan).eval (TransitionMachine.dataSize input)) where
  steps := steps indexing plan input
  evals_in_steps := fullTrace indexing plan input valid base frame
  steps_le_m := by
    simpa only [timePolynomial, Polynomial.eval_mul, Polynomial.eval_C, Polynomial.eval_pow,
      Polynomial.eval_add, Polynomial.eval_X, Polynomial.eval_one] using steps_le indexing plan input valid

end Indexed

open VerifierCircuit AcceptanceTemplate

local instance iterationTimeVerifierLabelFintype (V : NPVerifier) : Fintype V.computation.tm.Λ := V.computation.tm.ΛFin
local instance iterationTimeVerifierStateFintype (V : NPVerifier) : Fintype V.computation.tm.σ := V.computation.tm.σFin
local instance iterationTimeVerifierAlphabetFintype (V : NPVerifier) : ∀ k, Fintype (V.computation.tm.Γ k) := V.finiteAlphabet
local instance iterationTimeVerifierLabelDecidableEq (V : NPVerifier) : DecidableEq V.computation.tm.Λ := Classical.decEq _
local instance iterationTimeVerifierStateDecidableEq (V : NPVerifier) : DecidableEq V.computation.tm.σ := Classical.decEq _
local instance iterationTimeVerifierAlphabetDecidableEq (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) :=
  fun _ => Classical.decEq _

theorem rootLookup_ofFn {n : Nat} (wire : Fin n → Nat) (i : Fin n) :
    rootLookup (List.ofFn wire) i.val = wire i := by
  simp [rootLookup, i.isLt]

theorem mismatchForest_ofFn (V : NPVerifier) (input : List Bool)
    (wire : Fin (width V input + 1) → Nat) :
    AcceptancePlan.mismatchForest V (List.ofFn wire) (capacity V input.length) =
      (List.ofFn fun j : Fin (width V input) =>
        mismatchTokens (targetBit V input j) (wire j.castSucc)).flatten := by
  rw [AcceptancePlan.mismatchForest_circuit]
  apply congrArg List.flatten
  apply congrArg List.ofFn
  funext j
  exact congrArg (mismatchTokens (targetBit V input j)) (rootLookup_ofFn wire j.castSucc)

def verifierInput (V : NPVerifier) (input : List Bool)
    (wire : Fin (width V input + 1) → Nat) : Input :=
  ⟨0, capacity V input.length, List.ofFn wire⟩

theorem verifierInput_valid (V : NPVerifier) (input : List Bool)
    (wire : Fin (width V input + 1) → Nat) :
    Valid (indexing V) (verifierInput V input wire) := by
  simp [Valid, verifierInput, width]

theorem outputTokens_eq_acceptance (V : NPVerifier) (input : List Bool)
    (wire : Fin (width V input + 1) → Nat) :
    outputTokens (indexing V) (AcceptancePlan.plan V) (verifierInput V input wire) =
      AcceptanceTemplate.tokens V input wire := by
  have hw : (fun j : Fin (width V input + 1) => rootLookup (List.ofFn wire) j.val) = wire :=
    funext (rootLookup_ofFn wire)
  have h := (AcceptancePlan.fullTokens_eq V input (List.ofFn wire)).symm
  rw [hw] at h
  simpa only [outputTokens, carryTokens, verifierInput, width] using h

theorem compile_outputTokens (V : NPVerifier) (input : List Bool)
    (wire : Fin (width V input + 1) → Nat) (start : Nat) (oldRoots : List Nat) :
    compileTokens start oldRoots
      (outputTokens (indexing V) (AcceptancePlan.plan V) (verifierInput V input wire)) =
      some (start + (acceptanceExpr V input).size,
        (acceptanceExpr V input).root start :: oldRoots,
        (acceptanceExpr V input).gates wire start) := by
  rw [outputTokens_eq_acceptance]
  exact AcceptanceTemplate.compile_tokens V input wire start oldRoots

theorem outputTokens_length_le (V : NPVerifier) (input : List Bool)
    (wire : Fin (width V input + 1) → Nat) :
    (outputTokens (indexing V) (AcceptancePlan.plan V) (verifierInput V input wire)).length ≤
      3 * width V input + 4 := by
  rw [outputTokens_eq_acceptance]
  exact AcceptanceTemplate.tokens_length_le V input wire

def verifierMachine (V : NPVerifier) : FinTM2 :=
  machine (indexing V) (AcceptancePlan.plan V)

def verifierInPolynomialTime (V : NPVerifier) (input : List Bool)
    (wire : Fin (width V input + 1) → Nat) (base : Tape → List Bool)
    (frame : Frame (verifierInput V input wire) base) :
    StateTransition.EvalsToInTime (verifierMachine V).step
      ⟨some (Label.carry (carryEmitter (indexing V)).entry), initialState, base⟩
      (some ⟨none, initialState, emitTapes base (AcceptanceTemplate.tokens V input wire)⟩)
      ((timePolynomial (indexing V) (AcceptancePlan.plan V)).eval
        (TransitionMachine.dataSize (verifierInput V input wire))) := by
  have run := inPolynomialTime (indexing V) (AcceptancePlan.plan V) (verifierInput V input wire)
    (verifierInput_valid V input wire) base frame
  rw [outputTokens_eq_acceptance] at run
  exact run

end BinPackingGames.Foundations.Complexity.CookLevin.AcceptanceMachine

namespace BinPackingGames.Foundations.Complexity.CookLevin.AcceptanceStage

open Turing MachineComposition StatementCircuit CircuitBatch
open PostfixModel PostfixAlignment ProducerInvariant VerifierCircuit
open TransitionArena

local instance iterationTimeVerifierLabelFintype (V : NPVerifier) : Fintype V.computation.tm.Λ := V.computation.tm.ΛFin
local instance iterationTimeVerifierStateFintype (V : NPVerifier) : Fintype V.computation.tm.σ := V.computation.tm.σFin
local instance iterationTimeVerifierAlphabetFintype (V : NPVerifier) : ∀ k, Fintype (V.computation.tm.Γ k) := V.finiteAlphabet
local instance iterationTimeVerifierLabelDecidableEq (V : NPVerifier) : DecidableEq V.computation.tm.Λ := Classical.decEq _
local instance iterationTimeVerifierStateDecidableEq (V : NPVerifier) : DecidableEq V.computation.tm.σ := Classical.decEq _
local instance iterationTimeVerifierAlphabetDecidableEq (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) :=
  fun _ => Classical.decEq _

abbrev EmitLabel (V : NPVerifier) :=
  AcceptanceMachine.Label (indexing V) (AcceptancePlan.plan V)

abbrev Label (V : NPVerifier) := EmitLabel V ⊕ ForestStage.Label

def entry (V : NPVerifier) : Label V :=
  .inl (.carry (AcceptanceMachine.carryEmitter (indexing V)).entry)

def program (V : NPVerifier) : Label V → TM2.Stmt Alphabet (Label V) State
  | .inl label => ForestPlacement.statement termPorts Sum.inl
      (some (.inr .reverseTokens))
      (AcceptanceMachine.program (indexing V) (AcceptancePlan.plan V) label)
  | .inr label => ForestStage.statement forestPorts Sum.inr none label

def machine (V : NPVerifier) : FinTM2 where
  K := Tape
  k₀ := .inr .capacity
  k₁ := .inl .records
  Γ := Alphabet
  Λ := Label V
  main := entry V
  σ := State
  initialState := TermMachine.initialState
  m := program V

def expressions (V : NPVerifier) (input : List Bool) :
    Fin 1 → Expr (Fin (width V input + 1)) :=
  fun _ => acceptanceExpr V input

def wireValues {inputs count : Nat} (frame : Frame inputs count) : Fin count → Nat :=
  fun i => (frame.wires i).val

theorem tokens_eq_forest (V : NPVerifier) (input : List Bool)
    (wire : Fin (width V input + 1) → Nat) :
    AcceptanceTemplate.tokens V input wire =
      forestTokens wire (List.ofFn (expressions V input)) := by
  rw [AcceptanceTemplate.tokens_eq]
  simp [expressions, List.ofFn_succ, forestTokens]

theorem finish_termFrame (base : Tape → List Bool) (S : Nat) (s : Snapshot) :
    TermMachine.Frame (termInput S s)
      (fun tape => finishTapes base S s (termPorts tape)) := by
  have restriction : (fun tape => finishTapes base S s (termPorts tape)) =
      (fun tape => tapes base S 0 s (termPorts tape)) := by
    simp only [termPorts]
    funext tape
    change Function.update (tapes base S 0 s) (Sum.inr Extra.countdown) [] (termTape tape) =
      tapes base S 0 s (termTape tape)
    cases tape <;> simp [termTape]
  rw [restriction]
  exact termFrame base S 0 s

def prepared (base : Tape → List Bool) (S : Nat) (s : Snapshot)
    (tokens : List Token) : Tape → List Bool :=
  Function.update
    (Function.update (finishTapes base S s) (.inl .tokens) (tokenBits tokens).reverse)
    (.inl (.lower .remaining)) (encodeWord tokens.length)

theorem finish_place_emitTapes (base : Tape → List Bool) (S : Nat) (s : Snapshot)
    (tokens : List Token) :
    ForestPlacement.fill termPorts (finishTapes base S s)
      (TermMachine.emitTapes (fun tape => finishTapes base S s (termPorts tape)) tokens) =
      prepared base S s tokens := by
  simp only [TermMachine.emitTapes, ForestPlacement.fill_update, ForestPlacement.fill_self]
  simp [termTape, tapes, finishTapes, prepared, encodeWord]

theorem prepared_eq_lower (base : Tape → List Bool) (S : Nat) (s : Snapshot)
    (tokens : List Token) :
    prepared base S s tokens =
      ForestPlacement.fill forestPorts (finishTapes base S s)
        (ForestStage.initialLocal s.current tokens s.reversedRecords (encodeWords s.roots)) := by
  rw [fill_forest]
  funext tape
  cases tape with
  | inl tape =>
    cases tape with
    | lower tape => cases tape <;>
        simp [prepared, finishTapes, tapes, ForestStage.initialLocal]
    | tokens => simp [prepared, finishTapes, ForestStage.initialLocal]
    | records => simp [prepared, finishTapes, tapes, ForestStage.initialLocal]
    | rootTable => simp [prepared, finishTapes, tapes, ForestStage.initialLocal]
  | inr tape => cases tape <;>
      simp [prepared, finishTapes, tapes]

theorem lower_final_eq {inputs oldWidth newWidth : Nat}
    (base : Tape → List Bool) (S : Nat) (frame : Frame inputs oldWidth)
    (es : Fin newWidth → Expr (Fin oldWidth)) :
    ForestPlacement.fill forestPorts (finishTapes base S (snapshot frame))
      (ForestStage.finalLocal (next (frame.step es)) (rootValues (frame.step es)).reverse
        (recordsBits (gateRecords (next frame)
          (Batch.gates (wireValues frame) (next frame) (List.ofFn es))))
        (recordBits frame).reverse) =
      finishTapes base S (snapshot (frame.step es)) := by
  rw [fill_forest]
  funext tape
  cases tape with
  | inl tape =>
    cases tape with
    | lower tape => cases tape <;> rfl
    | tokens => rfl
    | records =>
      change (recordsBits (gateRecords (next frame)
        (Batch.gates (wireValues frame) (next frame) (List.ofFn es)))).reverse ++
        (recordBits frame).reverse = (recordBits (frame.step es)).reverse
      rw [recordBits_step, List.reverse_append]
      rfl
    | rootTable =>
      change encodeWords (rootValues (frame.step es)).reverse.reverse =
        encodeWords (rootValues (frame.step es))
      rw [List.reverse_reverse]
  | inr tape => cases tape <;> rfl

def emissionSteps (V : NPVerifier) (input : List Bool) {inputs : Nat}
    (frame : Frame inputs (width V input + 1)) : Nat :=
  AcceptanceMachine.steps (indexing V) (AcceptancePlan.plan V)
    (AcceptanceMachine.verifierInput V input (wireValues frame))

def loweringSteps (V : NPVerifier) (input : List Bool) {inputs : Nat}
    (frame : Frame inputs (width V input + 1)) : Nat :=
  ForestStage.steps (AcceptanceTemplate.tokens V input (wireValues frame)) (next frame)
    (rootValues (frame.step (expressions V input))).reverse
    (Batch.gates (wireValues frame) (next frame) (List.ofFn (expressions V input)))
    (encodeWords (rootValues frame))

def steps (V : NPVerifier) (input : List Bool) {inputs : Nat}
    (frame : Frame inputs (width V input + 1)) : Nat :=
  emissionSteps V input frame + loweringSteps V input frame

private theorem chain {α : Type*} (f : α → α) {n m : Nat} {a b c : α}
    (first : f^[n] a = b) (second : f^[m] b = c) : f^[n + m] a = c := by
  rw [Nat.add_comm n m, Function.iterate_add_apply, first, second]

theorem fullTrace (V : NPVerifier) (input : List Bool) {inputs : Nat}
    (frame : Frame inputs (width V input + 1)) (base : Tape → List Bool) :
    (advance (TM2.step (program V)))^[steps V input frame]
      (some ⟨some (entry V), TermMachine.initialState,
        finishTapes base (capacity V input.length) (snapshot frame)⟩) =
      some ⟨none, TermMachine.initialState,
        finishTapes base (capacity V input.length)
          (snapshot (frame.step (expressions V input)))⟩ := by
  let boundary := finishTapes base (capacity V input.length) (snapshot frame)
  let wire := wireValues frame
  let inp := AcceptanceMachine.verifierInput V input wire
  let tokens := AcceptanceTemplate.tokens V input wire
  have hframe : TermMachine.Frame inp (fun tape => boundary (termPorts tape)) :=
    finish_termFrame base (capacity V input.length) (snapshot frame)
  have source := AcceptanceMachine.fullTrace (indexing V) (AcceptancePlan.plan V) inp
    (AcceptanceMachine.verifierInput_valid V input wire)
    (fun tape => boundary (termPorts tape)) hframe
  rw [AcceptanceMachine.outputTokens_eq_acceptance] at source
  have emitter := ForestPlacement.trace termPorts Sum.inl (some (.inr .reverseTokens))
    boundary (AcceptanceMachine.program (indexing V) (AcceptancePlan.plan V))
    (program V) (fun _ => rfl) _ _ _ source
  change (advance (TM2.step (program V)))^[emissionSteps V input frame]
    (some ⟨some (entry V), TermMachine.initialState,
      ForestPlacement.fill termPorts boundary (fun tape => boundary (termPorts tape))⟩) =
      some ⟨some (.inr .reverseTokens), TermMachine.initialState,
        ForestPlacement.fill termPorts boundary
          (TermMachine.emitTapes (fun tape => boundary (termPorts tape)) tokens)⟩ at emitter
  rw [ForestPlacement.fill_self] at emitter
  rw [finish_place_emitTapes, prepared_eq_lower] at emitter
  have valid := compile_frameForest frame (expressions V input)
  rw [← tokens_eq_forest] at valid
  have lower := ForestStage.traceAt forestPorts Sum.inr none (program V) (fun _ => rfl)
    boundary ((), false) tokens (next frame) (next (frame.step (expressions V input)))
    (rootValues (frame.step (expressions V input))).reverse
    (Batch.gates wire (next frame) (List.ofFn (expressions V input)))
    (recordBits frame).reverse (encodeWords (rootValues frame)) valid
  rw [lower_final_eq] at lower
  exact chain _ emitter lower

def budget (V : NPVerifier) (input : List Bool) {inputs : Nat}
    (frame : Frame inputs (width V input + 1)) : Nat :=
  (AcceptanceMachine.timePolynomial (indexing V) (AcceptancePlan.plan V)).eval
      (TransitionMachine.dataSize
        (AcceptanceMachine.verifierInput V input (wireValues frame))) +
    ForestStage.timePolynomial.eval
      (next frame + Batch.cost (List.ofFn (expressions V input)) +
        (tokenBits (AcceptanceTemplate.tokens V input (wireValues frame))).length +
        (encodeWords (rootValues frame)).length + 1)

theorem steps_le_budget (V : NPVerifier) (input : List Bool) {inputs : Nat}
    (frame : Frame inputs (width V input + 1)) : steps V input frame ≤ budget V input frame := by
  have he := AcceptanceMachine.steps_le (indexing V) (AcceptancePlan.plan V)
    (AcceptanceMachine.verifierInput V input (wireValues frame))
    (AcceptanceMachine.verifierInput_valid V input (wireValues frame))
  have hl := ForestStage.forest_steps_le (wireValues frame) (List.ofFn (expressions V input))
    (next frame) (encodeWords (rootValues frame)) (fun i => (frame.wires i).isLt)
  have roots : rootValues (frame.step (expressions V input)) =
      Batch.roots (next frame) (List.ofFn (expressions V input)) :=
    step_roots frame (expressions V input)
  rw [← tokens_eq_forest] at hl
  unfold steps emissionSteps loweringSteps budget
  rw [roots]
  apply Nat.add_le_add _ hl
  simpa only [AcceptanceMachine.timePolynomial, Polynomial.eval_mul, Polynomial.eval_C,
    Polynomial.eval_pow, Polynomial.eval_add, Polynomial.eval_X, Polynomial.eval_one] using he

def inTime (V : NPVerifier) (input : List Bool) {inputs : Nat}
    (frame : Frame inputs (width V input + 1)) (base : Tape → List Bool) :
    StateTransition.EvalsToInTime (machine V).step
      ⟨some (entry V), TermMachine.initialState,
        finishTapes base (capacity V input.length) (snapshot frame)⟩
      (some ⟨none, TermMachine.initialState,
        finishTapes base (capacity V input.length)
          (snapshot (frame.step (expressions V input)))⟩)
      (budget V input frame) where
  steps := steps V input frame
  evals_in_steps := fullTrace V input frame base
  steps_le_m := steps_le_budget V input frame

theorem verifierTrace (V : NPVerifier) (input : List Bool) (base : Tape → List Bool) :
    (advance (TM2.step (program V)))^[
      steps V input (timeFrame V input (V.horizon input.length))]
      (some ⟨some (entry V), TermMachine.initialState,
        finishTapes base (capacity V input.length)
          (snapshot (timeFrame V input (V.horizon input.length)))⟩) =
      some ⟨none, TermMachine.initialState,
        finishTapes base (capacity V input.length) (snapshot (finalFrame V input))⟩ :=
  fullTrace V input (timeFrame V input (V.horizon input.length)) base

theorem final_root_singleton (V : NPVerifier) (input : List Bool) (base : Tape → List Bool) :
    finishTapes base (capacity V input.length) (snapshot (finalFrame V input))
      (.inl .rootTable) = encodeWords [((finalFrame V input).wires 0).val] := by
  simp [finishTapes, tapes, snapshot, List.ofFn_succ]

end BinPackingGames.Foundations.Complexity.CookLevin.AcceptanceStage

namespace BinPackingGames.Foundations.Complexity.CookLevin.ProducerTime

open CircuitBatch StatementCircuit PostfixModel PostfixAlignment ProducerInvariant
open MachineComposition VerifierCircuit
open scoped BigOperators

local instance iterationTimeVerifierLabelFintype (V : NPVerifier) : Fintype V.computation.tm.Λ := V.computation.tm.ΛFin
local instance iterationTimeVerifierStateFintype (V : NPVerifier) : Fintype V.computation.tm.σ := V.computation.tm.σFin
local instance iterationTimeVerifierAlphabetFintype (V : NPVerifier) : ∀ k, Fintype (V.computation.tm.Γ k) := V.finiteAlphabet
local instance iterationTimeVerifierLabelDecidableEq (V : NPVerifier) : DecidableEq V.computation.tm.Λ := Classical.decEq _
local instance iterationTimeVerifierStateDecidableEq (V : NPVerifier) : DecidableEq V.computation.tm.σ := Classical.decEq _
local instance iterationTimeVerifierAlphabetDecidableEq (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) :=
  fun _ => Classical.decEq _

def bootstrapPolynomial (V : NPVerifier) : Polynomial Nat :=
  2 * WitnessEncoding.freeInputPolynomial V.witnessBound + 5

def validityPolynomial (V : NPVerifier) : Polynomial Nat :=
  ValidityMachine.Full.timePolynomial.comp V.witnessBound

def loweringPolynomial (V : NPVerifier) : Polynomial Nat :=
  ForestStage.timePolynomial.comp (4 * stageEnvelopePolynomial V + 1)

def transitionEmissionPolynomial (V : NPVerifier) : Polynomial Nat :=
  (TransitionMachine.timePolynomial (indexing V)
    (TransitionMachine.transitionPlan (indexing V) V.computation.tm.m)).comp
      (2 * stageEnvelopePolynomial V)

def acceptanceEmissionPolynomial (V : NPVerifier) : Polynomial Nat :=
  (AcceptanceMachine.timePolynomial (indexing V) (AcceptancePlan.plan V)).comp
    (2 * stageEnvelopePolynomial V)

def finishPolynomial (V : NPVerifier) : Polynomial Nat :=
  9 * budgetPolynomial V + tapePolynomial V + 18

def iterationPolynomial (V : NPVerifier) : Polynomial Nat :=
  Bounds.horizonPolynomial V.computation.time V.witnessBound *
    (1 + transitionEmissionPolynomial V + loweringPolynomial V) + 1

def knownPhasePolynomial (V : NPVerifier) : Polynomial Nat :=
  VerifierFront.timePolynomial V + bootstrapPolynomial V + 1 + validityPolynomial V +
    loweringPolynomial V + iterationPolynomial V + acceptanceEmissionPolynomial V +
    loweringPolynomial V + finishPolynomial V

def producerPolynomial (V : NPVerifier) (cellTime : Polynomial Nat) : Polynomial Nat :=
  knownPhasePolynomial V + cellTime

theorem bootstrapPolynomial_eval (V : NPVerifier) (n : Nat) :
    (bootstrapPolynomial V).eval n = 2 * (2 * V.witnessBound.eval n + 1) + 5 := by
  simp [bootstrapPolynomial]

theorem validity_steps_le (V : NPVerifier) (n : Nat) :
    ValidityMachine.Full.steps (V.witnessBound.eval n) ≤ (validityPolynomial V).eval n := by
  simpa only [validityPolynomial, Polynomial.eval_comp] using
    ValidityMachine.Full.steps_le_time (V.witnessBound.eval n)

theorem front_steps_le (V : NPVerifier) (input : List Bool) :
    (VerifierFront.prepareInTime V input ()).steps ≤
      (VerifierFront.timePolynomial V).eval input.length :=
  (VerifierFront.prepareInTime V input ()).steps_le_m

theorem loweringPolynomial_eval (V : NPVerifier) (n : Nat) :
    (loweringPolynomial V).eval n =
      25 * (4 * (stageEnvelopePolynomial V).eval n + 1)^2 +
      80 * (4 * (stageEnvelopePolynomial V).eval n + 1) + 20 := by
  simp [loweringPolynomial, ForestStage.timePolynomial]

theorem transitionEmissionPolynomial_eval (V : NPVerifier) (n : Nat) :
    (transitionEmissionPolynomial V).eval n =
      TransitionMachine.timeConstant (indexing V)
        (TransitionMachine.transitionPlan (indexing V) V.computation.tm.m) *
          (2 * (stageEnvelopePolynomial V).eval n + 1)^2 := by
  simp [transitionEmissionPolynomial, TransitionMachine.timePolynomial]

theorem acceptanceEmissionPolynomial_eval (V : NPVerifier) (n : Nat) :
    (acceptanceEmissionPolynomial V).eval n =
      AcceptanceMachine.timeConstant (indexing V) (AcceptancePlan.plan V) *
        (2 * (stageEnvelopePolynomial V).eval n + 1)^2 := by
  simp [acceptanceEmissionPolynomial, AcceptanceMachine.timePolynomial]

variable {inputs oldWidth newWidth : Nat}

def forestSteps (f : Frame inputs oldWidth) (es : Fin newWidth → Expr (Fin oldWidth))
    (oldRoots : List Bool) : Nat :=
  ForestStage.steps (forestTokens (fun i => (f.wires i).val) (List.ofFn es))
    (next f) (Batch.roots (next f) (List.ofFn es)).reverse
    (Batch.gates (fun i => (f.wires i).val) (next f) (List.ofFn es)) oldRoots

theorem forestSteps_le (V : NPVerifier) (input : List Bool)
    (f : Frame inputs oldWidth) (es : Fin newWidth → Expr (Fin oldWidth))
    (oldRoots : List Bool)
    (hc : next f ≤ (stageEnvelopePolynomial V).eval input.length)
    (he : Batch.cost (List.ofFn es) ≤ (stageEnvelopePolynomial V).eval input.length)
    (ht : (tokenBits (forestTokens (fun i => (f.wires i).val) (List.ofFn es))).length ≤
      (stageEnvelopePolynomial V).eval input.length)
    (hr : oldRoots.length ≤ (stageEnvelopePolynomial V).eval input.length) :
    forestSteps f es oldRoots ≤ (loweringPolynomial V).eval input.length := by
  have h := ForestStage.forest_steps_le (fun i => (f.wires i).val)
    (List.ofFn es) (next f) oldRoots (fun i => (f.wires i).isLt)
  change ForestStage.steps _ _ _ _ _ ≤ _
  apply h.trans
  rw [loweringPolynomial, Polynomial.eval_comp]
  apply natPolynomial_eval_mono
  simp only [Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_ofNat,
    Polynomial.eval_one]
  omega

def initialForestSteps (V : NPVerifier) (input : List Bool) : Nat :=
  forestSteps (Frame.initial (id : Fin (2 * V.witnessBound.eval input.length + 1) →
    Fin (2 * V.witnessBound.eval input.length + 1))) (initialExpressions V input) []

theorem initialForestSteps_le (V : NPVerifier) (input : List Bool) :
    initialForestSteps V input ≤ (loweringPolynomial V).eval input.length := by
  have hg := circuitOfVerifier_gates_le_polynomial V input
  rw [circuitOfVerifier_gate_count] at hg
  have hb := budgetPolynomial_eval V input
  have hE := stageEnvelopePolynomial_eval V input
  have ht := initial_tokens_length_le V input
  apply forestSteps_le
  · change _ + 0 ≤ _
    omega
  · omega
  · exact ht.trans (by omega)
  · simp

def transitionForestSteps (V : NPVerifier) (input : List Bool) (t : Nat) : Nat :=
  forestSteps (timeFrame V input t) (VerifierCircuit.stepExpressions V input)
    (snapshot (timeFrame V input t)).rootBits

theorem transitionForestSteps_le (V : NPVerifier) (input : List Bool) (t : Nat)
    (ht : t < V.horizon input.length) :
    transitionForestSteps V input t ≤ (loweringPolynomial V).eval input.length := by
  obtain ⟨_, hc, he, hr, htok⟩ := timeFrame_stageEnvelope V input t ht
  exact forestSteps_le V input _ _ _ hc he htok hr

def acceptanceForestSteps (V : NPVerifier) (input : List Bool) : Nat :=
  forestSteps (timeFrame V input (V.horizon input.length))
    (fun _ : Fin 1 => acceptanceExpr V input)
    (snapshot (timeFrame V input (V.horizon input.length))).rootBits

theorem acceptanceForestSteps_le (V : NPVerifier) (input : List Bool) :
    acceptanceForestSteps V input ≤ (loweringPolynomial V).eval input.length := by
  have hg := circuitOfVerifier_gates_le_polynomial V input
  rw [circuitOfVerifier_gate_count] at hg
  have hb := budgetPolynomial_eval V input
  have hE := stageEnvelopePolynomial_eval V input
  have hc := timeFrame_current_le V input (V.horizon input.length) le_rfl
  have hr := (timeFrame_lengths_le V input (V.horizon input.length) le_rfl).2.1
  have htok := acceptance_tokens_length_le V input
  apply forestSteps_le
  · omega
  · simp only [List.ofFn_succ, List.ofFn_zero, Batch.cost_cons, Batch.cost_nil, Nat.add_zero]
    omega
  · exact htok.trans (by omega)
  · exact hr.trans (by omega)

def frameInput (V : NPVerifier) (input : List Bool) (t : Nat) : TermMachine.Input :=
  AcceptanceMachine.verifierInput V input (fun i => ((timeFrame V input t).wires i).val)

theorem frameInput_dataSize_le (V : NPVerifier) (input : List Bool) (t : Nat)
    (ht : t ≤ V.horizon input.length) :
    TransitionMachine.dataSize (frameInput V input t) ≤
      2 * (stageEnvelopePolynomial V).eval input.length := by
  have hE := stageEnvelopePolynomial_eval V input
  have hr := (timeFrame_lengths_le V input t ht).2.1
  change capacity V input.length + (snapshot (timeFrame V input t)).rootBits.length ≤ _
  omega

def transitionEmissionSteps (V : NPVerifier) (input : List Bool) (t : Nat) : Nat :=
  TransitionMachine.steps (indexing V) (TransitionMachine.transitionPlan (indexing V)
    V.computation.tm.m) (frameInput V input t)

theorem transitionEmissionSteps_le (V : NPVerifier) (input : List Bool) (t : Nat)
    (ht : t ≤ V.horizon input.length) :
    transitionEmissionSteps V input t ≤ (transitionEmissionPolynomial V).eval input.length := by
  have hv : TransitionMachine.Valid (indexing V)
      (TransitionMachine.transitionPlan (indexing V) V.computation.tm.m)
      (frameInput V input t) := by
    simp [TransitionMachine.Valid, TransitionMachine.transitionPlan, frameInput,
      AcceptanceMachine.verifierInput, width]
  have h := TransitionMachine.steps_le (indexing V)
    (TransitionMachine.transitionPlan (indexing V) V.computation.tm.m) (frameInput V input t) hv
  change TransitionMachine.steps _ _ _ ≤ _
  have he : TransitionMachine.timeConstant (indexing V)
      (TransitionMachine.transitionPlan (indexing V) V.computation.tm.m) *
      (TransitionMachine.dataSize (frameInput V input t) + 1)^2 =
      (TransitionMachine.timePolynomial (indexing V)
        (TransitionMachine.transitionPlan (indexing V) V.computation.tm.m)).eval
          (TransitionMachine.dataSize (frameInput V input t)) := by
    simp [TransitionMachine.timePolynomial]
  rw [he] at h
  apply h.trans
  rw [transitionEmissionPolynomial, Polynomial.eval_comp]
  apply natPolynomial_eval_mono
  simpa using frameInput_dataSize_le V input t ht

def acceptanceEmissionSteps (V : NPVerifier) (input : List Bool) : Nat :=
  AcceptanceMachine.steps (indexing V) (AcceptancePlan.plan V)
    (frameInput V input (V.horizon input.length))

theorem acceptanceEmissionSteps_le (V : NPVerifier) (input : List Bool) :
    acceptanceEmissionSteps V input ≤ (acceptanceEmissionPolynomial V).eval input.length := by
  have hv := AcceptanceMachine.verifierInput_valid V input
    (fun i => ((timeFrame V input (V.horizon input.length)).wires i).val)
  have h := AcceptanceMachine.steps_le (indexing V) (AcceptancePlan.plan V)
    (frameInput V input (V.horizon input.length)) hv
  change AcceptanceMachine.steps _ _ _ ≤ _
  have he : AcceptanceMachine.timeConstant (indexing V) (AcceptancePlan.plan V) *
      (TransitionMachine.dataSize (frameInput V input (V.horizon input.length)) + 1)^2 =
      (AcceptanceMachine.timePolynomial (indexing V) (AcceptancePlan.plan V)).eval
        (TransitionMachine.dataSize (frameInput V input (V.horizon input.length))) := by
    simp [AcceptanceMachine.timePolynomial]
  rw [he] at h
  apply h.trans
  rw [acceptanceEmissionPolynomial, Polynomial.eval_comp]
  apply natPolynomial_eval_mono
  simpa using frameInput_dataSize_le V input (V.horizon input.length) le_rfl

def finishSteps (V : NPVerifier) (input : List Bool) : Nat :=
  let C := circuitOfVerifier V input
  CircuitFinish.totalTime C.wires C.inputs C.output.val (recordsBits C.records).length

theorem finishSteps_le (V : NPVerifier) (input : List Bool) :
    finishSteps V input ≤ (finishPolynomial V).eval input.length := by
  let C := circuitOfVerifier V input
  have hf : C.inputs ≤ C.wires := Nat.le_add_right _ _
  have h := CircuitFinish.totalTime_le C.wires C.inputs C.output.val
    (recordsBits C.records).length hf C.output.isLt
  have hg := circuitOfVerifier_gates_le_polynomial V input
  have hb := budgetPolynomial_eval V input
  have hr := (finalFrame_lengths_le V input).2.2
  have hr' : (recordsBits C.records).length ≤ (tapePolynomial V).eval input.length := by
    simpa only [snapshot, List.length_reverse, Circuit.records, finalFrame, C,
      circuitOfVerifier, Frame.toCircuit, Fragment.toCircuit] using hr
  have hc : C.wires ≤ (budgetPolynomial V).eval input.length := by
    change (2 * V.witnessBound.eval input.length + 1) +
      (circuitOfVerifier V input).gates.length ≤ _
    omega
  unfold finishSteps
  apply h.trans
  simp only [finishPolynomial, Polynomial.eval_add, Polynomial.eval_mul,
    Polynomial.eval_ofNat]
  omega

theorem iterationPolynomial_eval (V : NPVerifier) (input : List Bool) :
    (iterationPolynomial V).eval input.length = V.horizon input.length *
      (1 + (transitionEmissionPolynomial V).eval input.length +
        (loweringPolynomial V).eval input.length) + 1 := by
  simp [iterationPolynomial, NPVerifier.horizon]

def iterationSteps (V : NPVerifier) (input : List Bool) : Nat :=
  (∑ t ∈ Finset.range (V.horizon input.length),
    (1 + transitionEmissionSteps V input t + transitionForestSteps V input t)) + 1

theorem iterationSteps_le (V : NPVerifier) (input : List Bool) :
    iterationSteps V input ≤ (iterationPolynomial V).eval input.length := by
  rw [iterationPolynomial_eval]
  unfold iterationSteps
  apply Nat.add_le_add_right
  calc
    _ ≤ ∑ _t ∈ Finset.range (V.horizon input.length),
        (1 + (transitionEmissionPolynomial V).eval input.length +
          (loweringPolynomial V).eval input.length) := by
      apply Finset.sum_le_sum
      intro t ht
      have hlt := Finset.mem_range.mp ht
      exact Nat.add_le_add
        (Nat.add_le_add_left (transitionEmissionSteps_le V input t (Nat.le_of_lt hlt)) 1)
        (transitionForestSteps_le V input t hlt)
    _ = _ := by simp

def knownPhaseSteps (V : NPVerifier) (input : List Bool) : Nat :=
  (VerifierFront.prepareInTime V input ()).steps +
    (2 * (2 * V.witnessBound.eval input.length + 1) + 5) + 1 +
    ValidityMachine.Full.steps (V.witnessBound.eval input.length) + initialForestSteps V input +
    iterationSteps V input + acceptanceEmissionSteps V input + acceptanceForestSteps V input +
    finishSteps V input

theorem knownPhaseSteps_le (V : NPVerifier) (input : List Bool) :
    knownPhaseSteps V input ≤ (knownPhasePolynomial V).eval input.length := by
  have hf := front_steps_le V input
  have hb := bootstrapPolynomial_eval V input.length
  have hv := validity_steps_le V input.length
  have hi := initialForestSteps_le V input
  have ht := iterationSteps_le V input
  have ha := acceptanceEmissionSteps_le V input
  have hl := acceptanceForestSteps_le V input
  have he := finishSteps_le V input
  simp only [knownPhasePolynomial, Polynomial.eval_add, Polynomial.eval_one]
  unfold knownPhaseSteps
  omega

theorem producerPolynomial_eval (V : NPVerifier) (cellTime : Polynomial Nat) (n : Nat) :
    (producerPolynomial V cellTime).eval n =
      (knownPhasePolynomial V).eval n + cellTime.eval n := by
  simp only [producerPolynomial, Polynomial.eval_add]

end BinPackingGames.Foundations.Complexity.CookLevin.ProducerTime

namespace BinPackingGames.Foundations.Complexity.CookLevin.TransitionIteration

open Turing MachineComposition StatementCircuit CircuitBatch TransitionArena
open scoped BigOperators

section Generic
variable {K Λ σ : Type} {Γ : K → Type}
variable [DecidableEq K] [Fintype σ] [DecidableEq σ]
variable [∀ k, DecidableEq (Γ k)] [∀ k, Fintype (Γ k)] [DecidableEq Λ] [Fintype Λ]
variable {inputs : Nat}

theorem steps_eq_sum (indexing : ConfigIndex.Indexing Γ Λ σ)
    (machineProgram : Λ → TM2.Stmt Γ Λ σ) (S : Nat)
    (frame : Frame inputs (indexing.width S + 1)) (remaining : Nat) :
    steps indexing machineProgram S frame remaining =
      (∑ t ∈ Finset.range remaining,
        (1 + stageSteps indexing machineProgram S
          (frame.repeat (ProducerInvariant.stepExpressions indexing machineProgram S) t))) + 1 := by
  induction remaining generalizing frame with
  | zero => simp [steps]
  | succ remaining ih =>
    rw [steps, ih, Finset.sum_range_succ']
    simp only [ProducerInvariant.step_repeat, Frame.repeat]
    omega

theorem tokens_frame_eq_forest (indexing : ConfigIndex.Indexing Γ Λ σ)
    (machineProgram : Λ → TM2.Stmt Γ Λ σ) (S : Nat)
    (frame : Frame inputs (indexing.width S + 1)) :
    tokens indexing machineProgram S (ProducerInvariant.snapshot frame) =
      PostfixAlignment.forestTokens (fun i => (frame.wires i).val)
        (List.ofFn (ProducerInvariant.stepExpressions indexing machineProgram S)) := by
  rw [tokens, ProducerInvariant.transitionTokens_eq]
  have hw : (fun i : Fin (indexing.width S + 1) =>
      (ProducerInvariant.snapshot frame).roots[i.val]?.getD 0) =
      (fun i => (frame.wires i).val) := by
    funext i
    change (List.ofFn (fun i => (frame.wires i).val))[i.val]?.getD 0 = _
    rw [List.getElem?_eq_getElem (by simpa only [List.length_ofFn] using i.isLt), List.getElem_ofFn]
    rfl
  rw [hw]

theorem lowerSteps_eq_forestSteps (indexing : ConfigIndex.Indexing Γ Λ σ)
    (machineProgram : Λ → TM2.Stmt Γ Λ σ) (S : Nat)
    (frame : Frame inputs (indexing.width S + 1)) :
    lowerSteps indexing machineProgram S frame =
      ProducerTime.forestSteps frame (ProducerInvariant.stepExpressions indexing machineProgram S)
        (encodeWords (ProducerInvariant.rootValues frame)) := by
  unfold lowerSteps ProducerTime.forestSteps
  rw [tokens_frame_eq_forest]
  have roots := ProducerInvariant.step_roots frame (ProducerInvariant.stepExpressions indexing machineProgram S)
  change ProducerInvariant.rootValues (frame.step (ProducerInvariant.stepExpressions indexing machineProgram S)) = _ at roots
  rw [roots]
  rfl

end Generic

local instance iterationTimeVerifierLabelFintype (V : NPVerifier) : Fintype V.computation.tm.Λ := V.computation.tm.ΛFin
local instance iterationTimeVerifierStateFintype (V : NPVerifier) : Fintype V.computation.tm.σ := V.computation.tm.σFin
local instance iterationTimeVerifierAlphabetFintype (V : NPVerifier) : ∀ k, Fintype (V.computation.tm.Γ k) := V.finiteAlphabet
local instance iterationTimeVerifierLabelDecidableEq (V : NPVerifier) : DecidableEq V.computation.tm.Λ := Classical.decEq _
local instance iterationTimeVerifierStateDecidableEq (V : NPVerifier) : DecidableEq V.computation.tm.σ := Classical.decEq _
local instance iterationTimeVerifierAlphabetDecidableEq (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) :=
  fun _ => Classical.decEq _

theorem stageSteps_verifier (V : NPVerifier) (input : List Bool) (t : Nat) :
    stageSteps (VerifierCircuit.indexing V) V.computation.tm.m
      (VerifierCircuit.capacity V input.length) (VerifierCircuit.timeFrame V input t) =
      ProducerTime.transitionEmissionSteps V input t + ProducerTime.transitionForestSteps V input t := by
  rw [stageSteps, lowerSteps_eq_forestSteps, ProducerInvariant.stepExpressions_verifier]
  rfl

theorem verifier_steps_eq (V : NPVerifier) (input : List Bool) :
    steps (VerifierCircuit.indexing V) V.computation.tm.m
      (VerifierCircuit.capacity V input.length) (VerifierCircuit.initialFrame V input)
      (V.horizon input.length) = ProducerTime.iterationSteps V input := by
  rw [steps_eq_sum, ProducerInvariant.stepExpressions_verifier]
  unfold ProducerTime.iterationSteps
  congr 1
  apply Finset.sum_congr rfl
  intro t _
  change 1 + stageSteps (VerifierCircuit.indexing V) V.computation.tm.m
    (VerifierCircuit.capacity V input.length) (VerifierCircuit.timeFrame V input t) = _
  rw [stageSteps_verifier]
  omega

theorem verifier_steps_le (V : NPVerifier) (input : List Bool) :
    steps (VerifierCircuit.indexing V) V.computation.tm.m
      (VerifierCircuit.capacity V input.length) (VerifierCircuit.initialFrame V input)
      (V.horizon input.length) ≤ (ProducerTime.iterationPolynomial V).eval input.length := by
  rw [verifier_steps_eq]
  exact ProducerTime.iterationSteps_le V input

noncomputable def verifierInPolynomialTime (V : NPVerifier) (input : List Bool)
    (base : Tape → List Bool) :
    StateTransition.EvalsToInTime
      (machine (VerifierCircuit.indexing V) V.computation.tm.m).step
      ⟨some (entry (VerifierCircuit.indexing V) V.computation.tm.m), TermMachine.initialState,
        tapes base (VerifierCircuit.capacity V input.length) (V.horizon input.length)
          (ProducerInvariant.snapshot (VerifierCircuit.initialFrame V input))⟩
      (some ⟨none, TermMachine.initialState,
        finishTapes base (VerifierCircuit.capacity V input.length)
          (ProducerInvariant.snapshot (VerifierCircuit.timeFrame V input (V.horizon input.length)))⟩)
      ((ProducerTime.iterationPolynomial V).eval input.length) where
  steps := steps (VerifierCircuit.indexing V) V.computation.tm.m
    (VerifierCircuit.capacity V input.length) (VerifierCircuit.initialFrame V input) (V.horizon input.length)
  evals_in_steps := repeatTrace (VerifierCircuit.indexing V) V.computation.tm.m base
    (VerifierCircuit.capacity V input.length) (VerifierCircuit.initialFrame V input) (V.horizon input.length)
  steps_le_m := verifier_steps_le V input

noncomputable def verifierPlacedInPolynomialTime {CallerTape CallerLabel : Type}
    [DecidableEq CallerTape] (V : NPVerifier) (input : List Bool)
    (ports : Tape ↪ CallerTape)
    (labels : Label (VerifierCircuit.indexing V) V.computation.tm.m → CallerLabel)
    (exit : Option CallerLabel)
    (target : CallerLabel → TM2.Stmt (fun _ : CallerTape => Bool) CallerLabel State)
    (code : ∀ label, target (labels label) = ForestPlacement.statement ports labels exit
      (program (VerifierCircuit.indexing V) V.computation.tm.m label))
    (ambient : CallerTape → List Bool) (base : Tape → List Bool) :
    StateTransition.EvalsToInTime (TM2.step target)
      ⟨some (labels (entry (VerifierCircuit.indexing V) V.computation.tm.m)), TermMachine.initialState,
        ForestPlacement.fill ports ambient
          (tapes base (VerifierCircuit.capacity V input.length) (V.horizon input.length)
            (ProducerInvariant.snapshot (VerifierCircuit.initialFrame V input)))⟩
      (some ⟨exit, TermMachine.initialState,
        ForestPlacement.fill ports ambient (finishTapes base (VerifierCircuit.capacity V input.length)
          (ProducerInvariant.snapshot (VerifierCircuit.timeFrame V input (V.horizon input.length))))⟩)
      ((ProducerTime.iterationPolynomial V).eval input.length) := by
  simpa only [ForestPlacement.configuration, ForestPlacement.placedLabel] using
    ForestPlacement.execution ports labels exit ambient
      (program (VerifierCircuit.indexing V) V.computation.tm.m) target code
      (verifierInPolynomialTime V input base)

end BinPackingGames.Foundations.Complexity.CookLevin.TransitionIteration

end

end OAI