lean/OAI/Computability/BinPacking/CookLevin/PaddingCellsMachine.lean

import OAI.Computability.BinPacking.CookLevin.ValidityMachine

namespace OAI

noncomputable section

namespace BinPackingGames.Foundations.Complexity.CookLevin.InputCellsMachine

open Turing PostfixModel InitializationTemplate
open Reduction.MachineSubstitution (pushWord stepAux_pushWord)

variable {K Λ σ : Type} [DecidableEq K] {A : Nat}

abbrev Ports (K : Type) := Fin 3 ↪ K
abbrev Alphabet (_ : K) := Bool

def tapes (p : Ports K) (base : K → List Bool) (input output count : List Bool) :
    K → List Bool :=
  Function.update (Function.update (Function.update base (p 0) input) (p 1) output) (p 2) count

@[simp] theorem tapes_input (p : Ports K) (base : K → List Bool)
    (input output count : List Bool) : tapes p base input output count (p 0) = input := by
  simp [tapes, p.injective.ne (by decide : (0 : Fin 3) ≠ 1),
    p.injective.ne (by decide : (0 : Fin 3) ≠ 2)]

@[simp] theorem tapes_output (p : Ports K) (base : K → List Bool)
    (input output count : List Bool) : tapes p base input output count (p 1) = output := by
  simp [tapes, p.injective.ne (by decide : (1 : Fin 3) ≠ 2)]

@[simp] theorem tapes_count (p : Ports K) (base : K → List Bool)
    (input output count : List Bool) : tapes p base input output count (p 2) = count := by
  simp [tapes]

theorem tapes_other (p : Ports K) (base : K → List Bool)
    (input output count : List Bool) (k : K) (hk : ∀ j, k ≠ p j) :
    tapes p base input output count k = base k := by
  simp [tapes, hk]

theorem update_input (p : Ports K) (base : K → List Bool)
    (input output count replacement : List Bool) :
    Function.update (tapes p base input output count) (p 0) replacement =
      tapes p base replacement output count := by
  funext k
  by_cases hk : ∃ j, p j = k
  · obtain ⟨j, rfl⟩ := hk
    fin_cases j <;> simp [tapes, p.injective.eq_iff]
  · have hn : ∀ j, k ≠ p j := fun j h => hk ⟨j, h.symm⟩
    simp [tapes, hn]

theorem update_output (p : Ports K) (base : K → List Bool)
    (input output count replacement : List Bool) :
    Function.update (tapes p base input output count) (p 1) replacement =
      tapes p base input replacement count := by
  funext k
  by_cases hk : ∃ j, p j = k
  · obtain ⟨j, rfl⟩ := hk
    fin_cases j <;> simp [tapes, p.injective.eq_iff]
  · have hn : ∀ j, k ≠ p j := fun j h => hk ⟨j, h.symm⟩
    simp [tapes, hn]

theorem update_count (p : Ports K) (base : K → List Bool)
    (input output count replacement : List Bool) :
    Function.update (tapes p base input output count) (p 2) replacement =
      tapes p base input output replacement := by
  simp [tapes]

abbrev TruthTable (A : Nat) := Bool → Fin A → Bool

def tableAt (table : TruthTable A) (bit : Bool) (i : Nat) : Bool :=
  if hi : i < A then table bit ⟨i, hi⟩ else false

def rowFrom (table : TruthTable A) (bit : Bool) (start count : Nat) : List Token :=
  forTokens count (fun j => [.const (tableAt table bit (start + j))])

def rowTokens (table : TruthTable A) (bit : Bool) : List Token := rowFrom table bit 0 A

def streamTokens (table : TruthTable A) (input : List Bool) : List Token :=
  input.flatMap (rowTokens table)

theorem rowFrom_succ (table : TruthTable A) (bit : Bool) (start count : Nat) :
    rowFrom table bit start (count + 1) =
      .const (tableAt table bit start) :: rowFrom table bit (start + 1) count := by
  simp only [rowFrom, forTokens_succ_first, Nat.add_zero, List.singleton_append]
  congr 1
  apply forTokens_congr
  intro j _
  simp only [Nat.add_assoc, Nat.add_comm 1 j]

@[simp] theorem rowFrom_length (table : TruthTable A) (bit : Bool) (start count : Nat) :
    (rowFrom table bit start count).length = count := by
  simpa only [rowFrom, Nat.mul_one] using
    forTokens_length_eq count (fun j => [.const (tableAt table bit (start + j))]) 1
      (fun _ _ => rfl)

@[simp] theorem streamTokens_length (table : TruthTable A) (input : List Bool) :
    (streamTokens table input).length = A * input.length := by
  induction input with
  | nil => simp [streamTokens]
  | cons bit input ih =>
    simp only [streamTokens, List.flatMap_cons, List.length_append, rowTokens,
      rowFrom_length, List.length_cons] at *
    rw [ih, Nat.mul_add, Nat.mul_one]
    omega

theorem streamTokens_eq_rows (table : TruthTable A) (input : List Bool) :
    streamTokens table input =
      (List.ofFn fun i : Fin input.length => rowTokens table input[i.val]).flatten := by
  rw [List.ofFn_getElem_eq_map]
  rfl

theorem tokenBits_cons (token : Token) (tokens : List Token) :
    tokenBits (token :: tokens) = token.bits ++ tokenBits tokens := by
  simp [tokenBits, tokenWords, Token.bits]

theorem tokenBits_append (first second : List Token) :
    tokenBits (first ++ second) = tokenBits first ++ tokenBits second := by
  simp [tokenBits, tokenWords]

inductive Label (symbols : Nat)
  | scan
  | emit (bit : Bool) (index : Fin (symbols + 1))
  deriving DecidableEq, Fintype

def statement (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ)
    (table : TruthTable A) : Label A → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool)
  | .scan =>
      .pop (p 0) (fun state head => (state.1, head))
        (.branch (fun state => state.2.isSome)
          (.goto fun state => label (.emit (state.2.getD false) 0))
          (.load (fun state => (state.1, none))
            (Reduction.MachineTransfer.exitAt (p 0) exit)))
  | .emit bit i =>
      if hi : i.val < A then
        pushWord (p 1) (Token.bits (.const (table bit ⟨i.val, hi⟩)))
          (.push (p 2) (fun _ => true)
            (.goto fun _ => label (.emit bit ⟨i.val + 1, by omega⟩)))
      else .load (fun state => (state.1, none)) (.goto fun _ => label .scan)

def Agrees (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool)) : Prop :=
  ∀ l, program (label l) = statement p label exit table l

def EmitAgrees (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool)) : Prop :=
  ∀ bit i, program (label (.emit bit i)) = statement p label exit table (.emit bit i)

theorem scanStep_nil (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) (base : K → List Bool)
    (output count : List Bool) (ambient : σ) (register : Option Bool) :
    TM2.step program ⟨some (label .scan), (ambient, register), tapes p base [] output count⟩ =
      some ⟨exit, (ambient, none), tapes p base [] output count⟩ := by
  change some (TM2.stepAux (program (label .scan)) _ _) = _
  rw [ha .scan]
  cases exit <;> simp [statement, TM2.stepAux, Reduction.MachineTransfer.exitAt, update_input]

theorem scanStep_cons (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) (base : K → List Bool)
    (bit : Bool) (input output count : List Bool) (ambient : σ) (register : Option Bool) :
    TM2.step program
      ⟨some (label .scan), (ambient, register), tapes p base (bit :: input) output count⟩ =
      some ⟨some (label (.emit bit 0)), (ambient, some bit), tapes p base input output count⟩ := by
  change some (TM2.stepAux (program (label .scan)) _ _) = _
  rw [ha .scan]
  simp [statement, TM2.stepAux, update_input]

theorem emitStep (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : EmitAgrees p label exit table program) (base : K → List Bool)
    (bit : Bool) (i : Nat) (hi : i < A) (input output count : List Bool)
    (ambient : σ) (register : Option Bool) :
    TM2.step program
      ⟨some (label (.emit bit ⟨i, by omega⟩)), (ambient, register), tapes p base input output count⟩ =
      some ⟨some (label (.emit bit ⟨i + 1, by omega⟩)), (ambient, register),
        tapes p base input ((Token.bits (.const (tableAt table bit i))).reverse ++ output)
          (true :: count)⟩ := by
  change some (TM2.stepAux (program (label (.emit bit ⟨i, by omega⟩))) _ _) = _
  rw [ha bit ⟨i, by omega⟩]
  simp only [statement, dite_eq_left hi, stepAux_pushWord, TM2.stepAux,
    tapes_output, update_output, tapes_count, update_count, tableAt]

theorem finishRowStep (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : EmitAgrees p label exit table program) (base : K → List Bool)
    (bit : Bool) (input output count : List Bool) (ambient : σ) (register : Option Bool) :
    TM2.step program
      ⟨some (label (.emit bit ⟨A, by omega⟩)), (ambient, register), tapes p base input output count⟩ =
      some ⟨some (label .scan), (ambient, none), tapes p base input output count⟩ := by
  change some (TM2.stepAux (program (label (.emit bit ⟨A, by omega⟩))) _ _) = _
  rw [ha bit ⟨A, by omega⟩]
  simp [statement, TM2.stepAux]

theorem rowTrace (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : EmitAgrees p label exit table program) (base : K → List Bool)
    (bit : Bool) (start remaining : Nat) (hr : start + remaining = A)
    (input output count : List Bool) (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[remaining + 1]
      (some ⟨some (label (.emit bit ⟨start, by omega⟩)), (ambient, register),
        tapes p base input output count⟩) =
      some ⟨some (label .scan), (ambient, none), tapes p base input
        ((tokenBits (rowFrom table bit start remaining)).reverse ++ output)
        (List.replicate remaining true ++ count)⟩ := by
  induction remaining generalizing start output count register with
  | zero =>
    have hs : start = A := by omega
    subst start
    simpa only [Nat.zero_add, Function.iterate_one, MachineComposition.advance_some,
      rowFrom, forTokens, tokenBits, tokenWords, List.flatMap_nil, encodeWords,
      List.reverse_nil, List.replicate_zero, List.nil_append] using
      finishRowStep p label exit table program ha base bit input output count ambient register
  | succ remaining ih =>
    have hs : start < A := by omega
    rw [Function.iterate_succ_apply]
    simp only [MachineComposition.advance_some]
    rw [emitStep p label exit table program ha base bit start hs]
    rw [ih (start + 1) (by omega)]
    rw [rowFrom_succ, tokenBits_cons, List.reverse_append]
    simp only [List.append_assoc, List.replicate_succ', List.singleton_append]

theorem streamTrace (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) (base : K → List Bool)
    (input output count : List Bool) (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[(A + 2) * input.length + 1]
      (some ⟨some (label .scan), (ambient, register), tapes p base input output count⟩) =
      some ⟨exit, (ambient, none), tapes p base []
        ((tokenBits (streamTokens table input)).reverse ++ output)
        (List.replicate (A * input.length) true ++ count)⟩ := by
  induction input generalizing output count register with
  | nil =>
    simpa only [List.length_nil, Nat.mul_zero, Nat.zero_add, Function.iterate_one,
      MachineComposition.advance_some, streamTokens, List.flatMap_nil, tokenBits,
      tokenWords, encodeWords, List.reverse_nil, List.replicate_zero, List.nil_append] using
      scanStep_nil p label exit table program ha base output count ambient register
  | cons bit input ih =>
    have hround :
        (MachineComposition.advance (TM2.step program))^[A + 2]
          (some ⟨some (label .scan), (ambient, register), tapes p base (bit :: input) output count⟩) =
          some ⟨some (label .scan), (ambient, none), tapes p base input
            ((tokenBits (rowTokens table bit)).reverse ++ output)
            (List.replicate A true ++ count)⟩ := by
      change (MachineComposition.advance (TM2.step program))^[(A + 1) + 1] _ = _
      rw [Function.iterate_succ_apply]
      simp only [MachineComposition.advance_some]
      rw [scanStep_cons p label exit table program ha base]
      exact rowTrace p label exit table program (fun b i => ha (.emit b i)) base bit 0 A (by omega)
        input output count ambient (some bit)
    have htime : (A + 2) * (bit :: input).length + 1 =
        ((A + 2) * input.length + 1) + (A + 2) := by
      rw [List.length_cons, Nat.mul_add, Nat.mul_one]
      omega
    rw [htime, Function.iterate_add_apply, hround, ih]
    simp only [streamTokens, List.flatMap_cons, tokenBits_append, List.reverse_append,
      List.append_assoc, List.length_cons, Nat.mul_add, Nat.mul_one]
    rw [List.replicate_add]
    simp only [List.append_assoc]

def streamInTime (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) (base : K → List Bool)
    (input output count : List Bool) (ambient : σ) (register : Option Bool) :
    StateTransition.EvalsToInTime (TM2.step program)
      ⟨some (label .scan), (ambient, register), tapes p base input output count⟩
      (some ⟨exit, (ambient, none), tapes p base []
        ((tokenBits (streamTokens table input)).reverse ++ output)
        (List.replicate (A * input.length) true ++ count)⟩)
      ((A + 2) * input.length + 1) where
  steps := (A + 2) * input.length + 1
  evals_in_steps := streamTrace p label exit table program ha base input output count ambient register
  steps_le_m := Nat.le_refl _

theorem copyAndStreamTrace (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ)
    (table : TruthTable A) (saved scratch : K)
    (hSaved : ∀ j, saved ≠ p j) (hScratch : ∀ j, scratch ≠ p j)
    (hSep : saved ≠ scratch) (copyFirst copySecond : Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program)
    (atFirst : program copyFirst = Reduction.MachineTransfer.loopAt saved scratch
      id false copyFirst (some copySecond))
    (atSecond : program copySecond = MachineCopy.forkLoop scratch saved (p 0)
      false copySecond (some (label .scan)))
    (base : K → List Bool) (input output count : List Bool)
    (hinput : base saved = input) (hEmpty : base scratch = [])
    (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[(A + 4) * input.length + 3]
      (some ⟨some copyFirst, (ambient, register), tapes p base [] output count⟩) =
      some ⟨exit, (ambient, none), tapes p base []
        ((tokenBits (streamTokens table input)).reverse ++ output)
        (List.replicate (A * input.length) true ++ count)⟩ := by
  have hsource : tapes p base [] output count saved = input := by
    rw [tapes_other p base [] output count saved hSaved, hinput]
  have hscratch : tapes p base [] output count scratch = [] := by
    rw [tapes_other p base [] output count scratch hScratch, hEmpty]
  have hc := MachineCopy.copyTrace saved (p 0) scratch (hSaved 0) hSep
    (hScratch 0).symm false copyFirst copySecond (some (label .scan)) program
    atFirst atSecond (tapes p base [] output count) hscratch ambient register
  rw [hsource, tapes_input, List.append_nil, update_input] at hc
  have htime : (A + 4) * input.length + 3 =
      ((A + 2) * input.length + 1) + 2 * (input.length + 1) := by
    simp only [Nat.add_mul, Nat.mul_add, Nat.mul_one]
    omega
  rw [htime, Function.iterate_add_apply, hc]
  exact streamTrace p label exit table program ha base input output count ambient none

def program (table : TruthTable A) :
    Label A → TM2.Stmt (Alphabet (K := Fin 3)) (Label A) (Unit × Option Bool) :=
  statement (Function.Embedding.refl _) (Function.Embedding.refl _) none table

abbrev machine (table : TruthTable A) : FinTM2 where
  K := Fin 3
  k₀ := 0
  k₁ := 1
  Γ _ := Bool
  Λ := Label A
  main := .scan
  σ := Unit × Option Bool
  initialState := ((), none)
  m := program table

def machineInTime (table : TruthTable A) (base : Fin 3 → List Bool)
    (input output count : List Bool) :
    StateTransition.EvalsToInTime (machine table).step
      ⟨some .scan, ((), none), tapes (Function.Embedding.refl _) base input output count⟩
      (some ⟨none, ((), none), tapes (Function.Embedding.refl _) base []
        ((tokenBits (streamTokens table input)).reverse ++ output)
        (List.replicate (A * input.length) true ++ count)⟩)
      ((A + 2) * input.length + 1) :=
  streamInTime (Function.Embedding.refl _) (Function.Embedding.refl _) none table
    (program table) (fun _ => rfl) base input output count () none

open VerifierCircuit WitnessEncoding

local instance alphabetDecidable (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) :=
  fun _ => Classical.decEq _

def symbolTruth (V : NPVerifier) (bit : Bool) :
    (Σ k, Option (V.computation.tm.Γ k)) → Bool
  | ⟨k, a⟩ => if h : k = V.computation.tm.k₀ then by
    subst k
    exact decide (some (V.computation.inputAlphabet.invFun bit) = a)
  else decide ((none : Option (V.computation.tm.Γ k)) = a)

def prefixTruth (V : NPVerifier) : TruthTable (indexing V).symbolCount := fun bit j =>
  symbolTruth V bit ((indexing V).symbols.symm j)

theorem symbolTruth_eq_initialCellTokens (V : NPVerifier) (input : List Bool) (S : Nat)
    (i : Fin S) (bit : Bool) (hi : i.val < (inputPrefix input).length)
    (hbit : (inputPrefix input)[i.val]? = some bit)
    (symbol : Σ k, Option (V.computation.tm.Γ k)) :
    [.const (symbolTruth V bit symbol)] = initialCellTokens V input S symbol.1 i symbol.2 := by
  obtain ⟨k, a⟩ := symbol
  by_cases hk : k = V.computation.tm.k₀
  · subst k
    simp only [symbolTruth, initialCellTokens, dite_true]
    simp only [inputCellTokens, ite_eq_left hi, hbit, Option.map_some]
  · simp [symbolTruth, initialCellTokens, hk]

theorem prefixTruth_eq_initialCellTokens (V : NPVerifier) (input : List Bool) (S : Nat)
    (i : Fin S) (bit : Bool) (hi : i.val < (inputPrefix input).length)
    (hbit : (inputPrefix input)[i.val]? = some bit) (j : Fin (indexing V).symbolCount) :
    [.const (prefixTruth V bit j)] =
      initialCellTokens V input S ((indexing V).symbols.symm j).1 i
        ((indexing V).symbols.symm j).2 :=
  symbolTruth_eq_initialCellTokens V input S i bit hi hbit ((indexing V).symbols.symm j)

theorem prefixRow_eq_initialCellTokens (V : NPVerifier) (input : List Bool) (S : Nat)
    (i : Fin S) (bit : Bool) (hi : i.val < (inputPrefix input).length)
    (hbit : (inputPrefix input)[i.val]? = some bit) :
    rowTokens (prefixTruth V) bit =
      (List.ofFn fun j : Fin (indexing V).symbolCount =>
        initialCellTokens V input S ((indexing V).symbols.symm j).1 i
          ((indexing V).symbols.symm j).2).flatten := by
  rw [rowTokens, rowFrom, forTokens_eq_ofFn]
  apply congrArg List.flatten
  apply congrArg List.ofFn
  funext j
  simp only [Nat.zero_add, tableAt, dite_eq_left j.isLt]
  exact prefixTruth_eq_initialCellTokens V input S i bit hi hbit j

theorem prefixStream_eq_initialCells (V : NPVerifier) (input : List Bool) (S : Nat)
    (hS : (inputPrefix input).length ≤ S) :
    streamTokens (prefixTruth V) (inputPrefix input) =
      (List.ofFn fun i : Fin (inputPrefix input).length =>
        (List.ofFn fun j : Fin (indexing V).symbolCount =>
          initialCellTokens V input S ((indexing V).symbols.symm j).1
            ⟨i.val, Nat.lt_of_lt_of_le i.isLt hS⟩
            ((indexing V).symbols.symm j).2).flatten).flatten := by
  rw [streamTokens_eq_rows]
  apply congrArg List.flatten
  apply congrArg List.ofFn
  funext i
  exact prefixRow_eq_initialCellTokens V input S ⟨i.val, Nat.lt_of_lt_of_le i.isLt hS⟩
    (inputPrefix input)[i.val] i.isLt (List.getElem?_eq_getElem i.isLt)

end BinPackingGames.Foundations.Complexity.CookLevin.InputCellsMachine

namespace BinPackingGames.Foundations.Complexity.CookLevin.InitializationControl

open Turing PostfixModel VerifierCircuit InitializationTemplate
open Reduction.MachineSubstitution

local instance (V : NPVerifier) : DecidableEq V.computation.tm.Λ := Classical.decEq _
local instance (V : NPVerifier) : DecidableEq V.computation.tm.σ := Classical.decEq _
local instance (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) :=
  fun _ => Classical.decEq _

def tokens (V : NPVerifier) : List Token :=
  ((List.finRange (indexing V).labelCount).map fun i =>
    .const (decide (some V.computation.tm.main = (indexing V).labels.symm i))) ++
  ((List.finRange (indexing V).stateCount).map fun i =>
    .const (decide (V.computation.tm.initialState = (indexing V).states.symm i)))

@[simp] theorem tokens_length (V : NPVerifier) :
    (tokens V).length = (indexing V).labelCount + (indexing V).stateCount := by
  simp [tokens]

def cells (V : NPVerifier) (input : List Bool) (S : Nat) : List Token :=
  (List.finRange S).flatMap fun i =>
    (List.finRange (indexing V).symbolCount).flatMap fun j =>
      let symbol := (indexing V).symbols.symm j
      initialCellTokens V input S symbol.1 i symbol.2

theorem configurationTokens_eq (V : NPVerifier) (input : List Bool) :
    (TransitionTemplate.outputOrder (indexing V) (capacity V input.length)).flatMap
      (initTokens V input (capacity V input.length)) =
      forTokens (width V input) (configurationBody V input) := by
  simp only [TransitionTemplate.outputOrder, List.flatMap_def,
    ← List.ofFn_eq_map, List.map_ofFn, Function.comp_def,
    forTokens_eq_ofFn, configurationBody, Fin.isLt, dite_eq_left]
  rfl

private theorem flatten_singletons {α β : Type*} (xs : List α) (f : α → β) :
    (xs.map fun x => [f x]).flatten = xs.map f := by
  induction xs with
  | nil => rfl
  | cons x xs ih => simp [ih]

theorem initializationTokens_eq_blocks (V : NPVerifier) (input : List Bool) :
    initializationTokens V input = tokens V ++ cells V input (capacity V input.length) ++
      validityTokens (V.witnessBound.eval input.length) := by
  rw [initializationTokens, ← configurationTokens_eq, OutputOrder.outputOrder_eq_blocks]
  simp [tokens, cells,
    initTokens, List.flatMap_def, List.map_map, Function.comp_def, List.append_assoc,
    flatten_singletons, List.flatten_flatten]

variable {K Λ σ : Type} [DecidableEq K]

structure Ports (K : Type) where
  reversed : K
  count : K
  distinct : reversed ≠ count

def emitted (p : Ports K) (base : K → List Bool) (ts : List Token) : K → List Bool :=
  Function.update
    (Function.update base p.reversed ((tokenBits ts).reverse ++ base p.reversed))
    p.count (List.replicate ts.length true ++ base p.count)

@[simp] theorem emitted_reversed (p : Ports K) (base : K → List Bool) (ts : List Token) :
    emitted p base ts p.reversed = (tokenBits ts).reverse ++ base p.reversed := by
  simp [emitted, p.distinct]

@[simp] theorem emitted_count (p : Ports K) (base : K → List Bool) (ts : List Token) :
    emitted p base ts p.count = List.replicate ts.length true ++ base p.count := by
  simp [emitted]

theorem emitted_other (p : Ports K) (base : K → List Bool) (ts : List Token)
    (k : K) (hr : k ≠ p.reversed) (hc : k ≠ p.count) : emitted p base ts k = base k := by
  simp [emitted, hr, hc]

def exitStatement (exit : Option Λ) : TM2.Stmt (fun _ : K => Bool) Λ σ :=
  match exit with
  | none => .halt
  | some label => .goto fun _ => label

def literalStatement (p : Ports K) (ts : List Token) (exit : Option Λ) :
    TM2.Stmt (fun _ : K => Bool) Λ σ :=
  pushWord p.reversed (tokenBits ts)
    (pushWord p.count (List.replicate ts.length true) (exitStatement exit))

theorem literalStep (p : Ports K) (ts : List Token) (exit : Option Λ)
    (base : K → List Bool) (state : σ) :
    TM2.stepAux (literalStatement p ts exit) state base =
      ⟨exit, state, emitted p base ts⟩ := by
  rw [literalStatement, stepAux_pushWord, stepAux_pushWord]
  cases exit <;>
    simp [exitStatement, TM2.stepAux, emitted, p.distinct.symm]

theorem literalTrace (p : Ports K) (ts : List Token) (entry : Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (fun _ : K => Bool) Λ σ)
    (code : program entry = literalStatement p ts exit)
    (base : K → List Bool) (state : σ) :
    (MachineComposition.advance (TM2.step program))^[1]
      (some ⟨some entry, state, base⟩) =
      some ⟨exit, state, emitted p base ts⟩ := by
  simp only [Function.iterate_one, MachineComposition.advance_some, TM2.step, code]
  rw [literalStep]

def statement (V : NPVerifier) (p : Ports K) (exit : Option Λ) :
    TM2.Stmt (fun _ : K => Bool) Λ σ := literalStatement p (tokens V) exit

theorem trace (V : NPVerifier) (p : Ports K) (entry : Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (fun _ : K => Bool) Λ σ)
    (code : program entry = statement V p exit)
    (base : K → List Bool) (state : σ) :
    (MachineComposition.advance (TM2.step program))^[1]
      (some ⟨some entry, state, base⟩) =
      some ⟨exit, state, emitted p base (tokens V)⟩ :=
  literalTrace p (tokens V) entry exit program code base state

end BinPackingGames.Foundations.Complexity.CookLevin.InitializationControl

namespace BinPackingGames.Foundations.Complexity.CookLevin.InputCellsCapacity

open Turing PostfixModel InputCellsMachine

variable {K Λ σ : Type} [DecidableEq K] {A : Nat}

abbrev Ports (K : Type) := Fin 4 ↪ K

def corePorts (p : Ports K) : InputCellsMachine.Ports K where
  toFun j := p j.castSucc
  inj' := by
    intro i j h
    exact Fin.ext (congrArg (fun x : Fin 4 => x.val) (p.injective h))

omit [DecidableEq K] in
theorem capacity_distinct (p : Ports K) (j : Fin 3) : p 3 ≠ corePorts p j := by
  intro h
  have hv := congrArg Fin.val (p.injective h)
  change 3 = j.val at hv
  omega

def tapes (p : Ports K) (base : K → List Bool) (remaining : Nat)
    (input output count : List Bool) : K → List Bool :=
  InputCellsMachine.tapes (corePorts p)
    (Function.update base (p 3) (encodeWord remaining)) input output count

@[simp] theorem tapes_input (p : Ports K) (base : K → List Bool) (remaining : Nat)
    (input output count : List Bool) : tapes p base remaining input output count (p 0) = input :=
  InputCellsMachine.tapes_input (corePorts p) _ _ _ _

@[simp] theorem tapes_output (p : Ports K) (base : K → List Bool) (remaining : Nat)
    (input output count : List Bool) : tapes p base remaining input output count (p 1) = output :=
  InputCellsMachine.tapes_output (corePorts p) _ _ _ _

@[simp] theorem tapes_count (p : Ports K) (base : K → List Bool) (remaining : Nat)
    (input output count : List Bool) : tapes p base remaining input output count (p 2) = count :=
  InputCellsMachine.tapes_count (corePorts p) _ _ _ _

@[simp] theorem tapes_capacity (p : Ports K) (base : K → List Bool) (remaining : Nat)
    (input output count : List Bool) :
    tapes p base remaining input output count (p 3) = encodeWord remaining := by
  rw [tapes, InputCellsMachine.tapes_other _ _ _ _ _ _ (capacity_distinct p)]
  simp

theorem tapes_other (p : Ports K) (base : K → List Bool) (remaining : Nat)
    (input output count : List Bool) (k : K) (hk : ∀ j, k ≠ p j) :
    tapes p base remaining input output count k = base k := by
  rw [tapes, InputCellsMachine.tapes_other _ _ _ _ _ _ (fun j => hk j.castSucc)]
  simp [hk]

theorem update_input (p : Ports K) (base : K → List Bool) (remaining : Nat)
    (input output count replacement : List Bool) :
    Function.update (tapes p base remaining input output count) (p 0) replacement =
      tapes p base remaining replacement output count :=
  InputCellsMachine.update_input (corePorts p) _ _ _ _ _

theorem update_capacity (p : Ports K) (base : K → List Bool) (remaining replacement : Nat)
    (input output count : List Bool) :
    Function.update (tapes p base remaining input output count) (p 3) (encodeWord replacement) =
      tapes p base replacement input output count := by
  funext k
  by_cases hk : ∃ j, p j = k
  · obtain ⟨j, rfl⟩ := hk
    fin_cases j <;> simp [p.injective.eq_iff]
  · have hn : ∀ j, k ≠ p j := fun j h => hk ⟨j, h.symm⟩
    simp only [Function.update_of_ne (hn 3),
      tapes_other p base remaining input output count k hn,
      tapes_other p base replacement input output count k hn]

def statement (p : Ports K) (label : InputCellsMachine.Label A ↪ Λ) (exit : Option Λ)
    (table : TruthTable A) :
    InputCellsMachine.Label A → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool)
  | .scan =>
      .pop (p 0) (fun state head => (state.1, head))
        (.branch (fun state => state.2.isSome)
          (.pop (p 3) (fun state _ => state)
            (.goto fun state => label (.emit (state.2.getD false) 0)))
          (.load (fun state => (state.1, none))
            (Reduction.MachineTransfer.exitAt (p 0) exit)))
  | .emit bit i => InputCellsMachine.statement (corePorts p) label exit table (.emit bit i)

def Agrees (p : Ports K) (label : InputCellsMachine.Label A ↪ Λ) (exit : Option Λ)
    (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool)) : Prop :=
  ∀ l, program (label l) = statement p label exit table l

omit [DecidableEq K] in
theorem emitAgrees (p : Ports K) (label : InputCellsMachine.Label A ↪ Λ) (exit : Option Λ)
    (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) :
    InputCellsMachine.EmitAgrees (corePorts p) label exit table program := by
  intro bit i
  exact ha (.emit bit i)

theorem scanStep_nil (p : Ports K) (label : InputCellsMachine.Label A ↪ Λ)
    (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) (base : K → List Bool) (remaining : Nat)
    (output count : List Bool) (ambient : σ) (register : Option Bool) :
    TM2.step program
      ⟨some (label .scan), (ambient, register), tapes p base remaining [] output count⟩ =
      some ⟨exit, (ambient, none), tapes p base remaining [] output count⟩ := by
  change some (TM2.stepAux (program (label .scan)) _ _) = _
  rw [ha .scan]
  cases exit <;> simp [statement, TM2.stepAux, Reduction.MachineTransfer.exitAt, update_input]

theorem scanStep_cons (p : Ports K) (label : InputCellsMachine.Label A ↪ Λ)
    (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) (base : K → List Bool) (remaining : Nat)
    (bit : Bool) (input output count : List Bool) (ambient : σ) (register : Option Bool) :
    TM2.step program
      ⟨some (label .scan), (ambient, register), tapes p base (remaining + 1) (bit :: input) output count⟩ =
      some ⟨some (label (.emit bit 0)), (ambient, some bit),
        tapes p base remaining input output count⟩ := by
  change some (TM2.stepAux (program (label .scan)) _ _) = _
  rw [ha .scan]
  simp [statement, TM2.stepAux, update_input, encodeWord, List.replicate_succ]
  exact update_capacity p base (remaining + 1) remaining input output count

theorem streamTrace_add (p : Ports K) (label : InputCellsMachine.Label A ↪ Λ)
    (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) (base : K → List Bool) (remaining : Nat)
    (input output count : List Bool) (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[(A + 2) * input.length + 1]
      (some ⟨some (label .scan), (ambient, register),
        tapes p base (input.length + remaining) input output count⟩) =
      some ⟨exit, (ambient, none), tapes p base remaining []
        ((tokenBits (streamTokens table input)).reverse ++ output)
        (List.replicate (A * input.length) true ++ count)⟩ := by
  induction input generalizing output count register with
  | nil =>
    simpa only [List.length_nil, Nat.mul_zero, Nat.zero_add, Function.iterate_one,
      MachineComposition.advance_some, streamTokens, List.flatMap_nil, tokenBits,
      tokenWords, encodeWords, List.reverse_nil, List.replicate_zero, List.nil_append] using
      scanStep_nil p label exit table program ha base remaining output count ambient register
  | cons bit input ih =>
    have hround :
        (MachineComposition.advance (TM2.step program))^[A + 2]
          (some ⟨some (label .scan), (ambient, register),
            tapes p base ((bit :: input).length + remaining) (bit :: input) output count⟩) =
          some ⟨some (label .scan), (ambient, none),
            tapes p base (input.length + remaining) input
              ((tokenBits (rowTokens table bit)).reverse ++ output)
              (List.replicate A true ++ count)⟩ := by
      have hn : (bit :: input).length + remaining = (input.length + remaining) + 1 := by
        simp only [List.length_cons]
        omega
      rw [hn]
      change (MachineComposition.advance (TM2.step program))^[(A + 1) + 1] _ = _
      rw [Function.iterate_succ_apply]
      simp only [MachineComposition.advance_some]
      rw [scanStep_cons p label exit table program ha base]
      exact rowTrace (corePorts p) label exit table program
        (emitAgrees p label exit table program ha)
        (Function.update base (p 3) (encodeWord (input.length + remaining))) bit 0 A (by omega)
        input output count ambient (some bit)
    have htime : (A + 2) * (bit :: input).length + 1 =
        ((A + 2) * input.length + 1) + (A + 2) := by
      rw [List.length_cons, Nat.mul_add, Nat.mul_one]
      omega
    rw [htime, Function.iterate_add_apply, hround, ih]
    simp only [streamTokens, List.flatMap_cons, tokenBits_append, List.reverse_append,
      List.append_assoc, List.length_cons, Nat.mul_add, Nat.mul_one]
    rw [List.replicate_add]
    simp only [List.append_assoc]

theorem streamTrace (p : Ports K) (label : InputCellsMachine.Label A ↪ Λ)
    (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) (base : K → List Bool) (S : Nat)
    (input output count : List Bool) (hS : input.length ≤ S)
    (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[(A + 2) * input.length + 1]
      (some ⟨some (label .scan), (ambient, register), tapes p base S input output count⟩) =
      some ⟨exit, (ambient, none), tapes p base (S - input.length) []
        ((tokenBits (streamTokens table input)).reverse ++ output)
        (List.replicate (A * input.length) true ++ count)⟩ := by
  have h := streamTrace_add p label exit table program ha base (S - input.length)
    input output count ambient register
  rw [Nat.add_sub_of_le hS] at h
  exact h

theorem copyAndStreamTrace (p : Ports K) (label : InputCellsMachine.Label A ↪ Λ)
    (exit : Option Λ) (table : TruthTable A) (saved scratch : K)
    (hSaved : ∀ j, saved ≠ p j) (hScratch : ∀ j, scratch ≠ p j)
    (hSep : saved ≠ scratch) (copyFirst copySecond : Λ)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program)
    (atFirst : program copyFirst = Reduction.MachineTransfer.loopAt saved scratch
      id false copyFirst (some copySecond))
    (atSecond : program copySecond = MachineCopy.forkLoop scratch saved (p 0)
      false copySecond (some (label .scan)))
    (base : K → List Bool) (S : Nat) (input output count : List Bool)
    (hS : input.length ≤ S) (hinput : base saved = input) (hEmpty : base scratch = [])
    (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[(A + 4) * input.length + 3]
      (some ⟨some copyFirst, (ambient, register), tapes p base S [] output count⟩) =
      some ⟨exit, (ambient, none), tapes p base (S - input.length) []
        ((tokenBits (streamTokens table input)).reverse ++ output)
        (List.replicate (A * input.length) true ++ count)⟩ := by
  have hsource : tapes p base S [] output count saved = input := by
    rw [tapes_other p base S [] output count saved hSaved, hinput]
  have hscratch : tapes p base S [] output count scratch = [] := by
    rw [tapes_other p base S [] output count scratch hScratch, hEmpty]
  have hc := MachineCopy.copyTrace saved (p 0) scratch (hSaved 0) hSep
    (hScratch 0).symm false copyFirst copySecond (some (label .scan)) program
    atFirst atSecond (tapes p base S [] output count) hscratch ambient register
  rw [hsource, tapes_input, List.append_nil, update_input] at hc
  have htime : (A + 4) * input.length + 3 =
      ((A + 2) * input.length + 1) + 2 * (input.length + 1) := by
    simp only [Nat.add_mul, Nat.mul_add, Nat.mul_one]
    omega
  rw [htime, Function.iterate_add_apply, hc]
  exact streamTrace p label exit table program ha base S input output count hS ambient none

end BinPackingGames.Foundations.Complexity.CookLevin.InputCellsCapacity

namespace BinPackingGames.Foundations.Complexity.CookLevin.CellsPrefixStage

open Turing PostfixModel InputCellsMachine

variable {K Λ σ : Type} [DecidableEq K] {A : Nat}

abbrev Ports (K : Type) := Fin 7 ↪ K

def capacityPorts (p : Ports K) : InputCellsCapacity.Ports K where
  toFun j := p (![4, 2, 3, 5] j)
  inj' := by
    intro i j h
    have hmap : Function.Injective (fun j : Fin 4 => (![4, 2, 3, 5] j : Fin 7)) := by decide
    exact hmap (p.injective h)

omit [DecidableEq K] in
theorem saved_distinct (p : Ports K) (j : Fin 4) : p 0 ≠ capacityPorts p j := by
  change p 0 ≠ p (![4, 2, 3, 5] j)
  fin_cases j <;> simp [p.injective.eq_iff]

omit [DecidableEq K] in
theorem scratch_distinct (p : Ports K) (j : Fin 4) : p 6 ≠ capacityPorts p j := by
  change p 6 ≠ p (![4, 2, 3, 5] j)
  fin_cases j <;> simp [p.injective.eq_iff]

theorem prepared_eq (p : Ports K) (base : K → List Bool) (S : Nat)
    (hwork : base (p 4) = []) :
    InputCellsCapacity.tapes (capacityPorts p) base S [] (base (p 2)) (base (p 3)) =
      Function.update base (p 5) (encodeWord S) := by
  change Function.update (Function.update (Function.update
    (Function.update base (p 5) (encodeWord S)) (p 4) [])
      (p 2) (base (p 2))) (p 3) (base (p 3)) = _
  funext k
  by_cases hk : ∃ j, p j = k
  · obtain ⟨j, rfl⟩ := hk
    fin_cases j <;> simp [p.injective.eq_iff, hwork]
  · have hn : ∀ j, k ≠ p j := fun j h => hk ⟨j, h.symm⟩
    simp [hn]

inductive Label (symbols : Nat)
  | capacityFirst | capacitySecond | prefixFirst | prefixSecond
  | stream (entry : InputCellsMachine.Label symbols)
  deriving DecidableEq, Fintype

def streamLabels (label : Label A ↪ Λ) : InputCellsMachine.Label A ↪ Λ where
  toFun entry := label (.stream entry)
  inj' := by
    intro i j h
    exact Label.stream.inj (label.injective h)

def statement (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ)
    (table : TruthTable A) : Label A → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool)
  | .capacityFirst => Reduction.MachineTransfer.loopAt (p 1) (p 6) id false
      (label .capacityFirst) (some (label .capacitySecond))
  | .capacitySecond => MachineCopy.forkLoop (p 6) (p 1) (p 5) false
      (label .capacitySecond) (some (label .prefixFirst))
  | .prefixFirst => Reduction.MachineTransfer.loopAt (p 0) (p 6) id false
      (label .prefixFirst) (some (label .prefixSecond))
  | .prefixSecond => MachineCopy.forkLoop (p 6) (p 0) (p 4) false
      (label .prefixSecond) (some (label (.stream .scan)))
  | .stream entry => InputCellsCapacity.statement (capacityPorts p) (streamLabels label)
      exit table entry

def Agrees (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ) (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool)) : Prop :=
  ∀ entry, program (label entry) = statement p label exit table entry

omit [DecidableEq K] in
theorem stream_agrees (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ)
    (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) :
    InputCellsCapacity.Agrees (capacityPorts p) (streamLabels label) exit table program := by
  intro entry
  exact ha (.stream entry)

theorem trace (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ)
    (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) (base : K → List Bool)
    (input : List Bool) (S : Nat) (hS : input.length ≤ S)
    (hinput : base (p 0) = input) (hcached : base (p 1) = encodeWord S)
    (hwork : base (p 4) = []) (hcapacity : base (p 5) = []) (hscratch : base (p 6) = [])
    (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[2 * (S + 2) + ((A + 4) * input.length + 3)]
      (some ⟨some (label .capacityFirst), (ambient, register), base⟩) =
      some ⟨exit, (ambient, none), InputCellsCapacity.tapes (capacityPorts p) base
        (S - input.length) []
        ((tokenBits (streamTokens table input)).reverse ++ base (p 2))
        (List.replicate (A * input.length) true ++ base (p 3))⟩ := by
  have hc := MachineCopy.copyTrace (p 1) (p 5) (p 6)
    (p.injective.ne (by decide)) (p.injective.ne (by decide)) (p.injective.ne (by decide))
    false (label .capacityFirst) (label .capacitySecond) (some (label .prefixFirst))
    program (ha .capacityFirst) (ha .capacitySecond) base hscratch ambient register
  rw [hcached, hcapacity, List.append_nil, encodeWord_length] at hc
  have hp := InputCellsCapacity.copyAndStreamTrace (capacityPorts p) (streamLabels label)
    exit table (p 0) (p 6) (saved_distinct p) (scratch_distinct p)
    (p.injective.ne (by decide)) (label .prefixFirst) (label .prefixSecond) program
    (stream_agrees p label exit table program ha) (ha .prefixFirst) (ha .prefixSecond)
    base S input (base (p 2)) (base (p 3)) hS hinput hscratch ambient none
  rw [prepared_eq p base S hwork] at hp
  rw [Nat.add_comm (2 * (S + 2)), Function.iterate_add_apply, hc]
  exact hp

def inTime (p : Ports K) (label : Label A ↪ Λ) (exit : Option Λ)
    (table : TruthTable A)
    (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
    (ha : Agrees p label exit table program) (base : K → List Bool)
    (input : List Bool) (S : Nat) (hS : input.length ≤ S)
    (hinput : base (p 0) = input) (hcached : base (p 1) = encodeWord S)
    (hwork : base (p 4) = []) (hcapacity : base (p 5) = []) (hscratch : base (p 6) = [])
    (ambient : σ) (register : Option Bool) :
    StateTransition.EvalsToInTime (TM2.step program)
      ⟨some (label .capacityFirst), (ambient, register), base⟩
      (some ⟨exit, (ambient, none), InputCellsCapacity.tapes (capacityPorts p) base
        (S - input.length) []
        ((tokenBits (streamTokens table input)).reverse ++ base (p 2))
        (List.replicate (A * input.length) true ++ base (p 3))⟩)
      (2 * (S + 2) + ((A + 4) * input.length + 3)) where
  steps := 2 * (S + 2) + ((A + 4) * input.length + 3)
  evals_in_steps := trace p label exit table program ha base input S hS hinput hcached
    hwork hcapacity hscratch ambient register
  steps_le_m := Nat.le_refl _

end BinPackingGames.Foundations.Complexity.CookLevin.CellsPrefixStage

namespace BinPackingGames.Foundations.Complexity.CookLevin.PaddingCellsMachine

open Turing PostfixModel InitializationTemplate VerifierCircuit WitnessEncoding

variable {K Λ σ : Type} [DecidableEq K]

abbrev Ports (K : Type) := Fin 4 ↪ K

def corePorts (p : Ports K) : OrClosure.Ports K where
  remaining := p 3
  reversed := p 1
  count := p 2
  remaining_ne_reversed := fun h => by have := p.injective h; omega
  remaining_ne_count := fun h => by have := p.injective h; omega
  reversed_ne_count := fun h => by have := p.injective h; omega

def literalPorts (p : Ports K) : InitializationControl.Ports K :=
  ⟨p 1, p 2, (corePorts p).reversed_ne_count⟩

abbrev frame (p : Ports K) (base : K → List Bool)
    (remaining output count : List Bool) : K → List Bool :=
  OrClosure.frame (corePorts p) base remaining output count

@[simp] theorem frame_remaining (p : Ports K) (base : K → List Bool)
    (remaining output count : List Bool) :
    frame p base remaining output count (p 3) = remaining := by
  exact OrClosure.frame_remaining (corePorts p) base remaining output count

@[simp] theorem frame_output (p : Ports K) (base : K → List Bool)
    (remaining output count : List Bool) :
    frame p base remaining output count (p 1) = output := by
  exact OrClosure.frame_reversed (corePorts p) base remaining output count

@[simp] theorem frame_count (p : Ports K) (base : K → List Bool)
    (remaining output count : List Bool) :
    frame p base remaining output count (p 2) = count := by
  exact OrClosure.frame_count (corePorts p) base remaining output count

theorem frame_other (p : Ports K) (base : K → List Bool)
    (remaining output count : List Bool) (k : K)
    (hr : k ≠ p 3) (ho : k ≠ p 1) (hc : k ≠ p 2) :
    frame p base remaining output count k = base k :=
  OrClosure.frame_other (corePorts p) base remaining output count k hr ho hc

@[simp] theorem frame_input (p : Ports K) (base : K → List Bool)
    (remaining output count : List Bool) :
    frame p base remaining output count (p 0) = base (p 0) := by
  apply frame_other <;> intro h <;> have := p.injective h <;> omega

@[simp] theorem update_remaining (p : Ports K) (base : K → List Bool)
    (remaining output count replacement : List Bool) :
    Function.update (frame p base remaining output count) (p 3) replacement =
      frame p base replacement output count :=
  OrClosure.update_remaining (corePorts p) base remaining output count replacement

@[simp] theorem literal_emitted (p : Ports K) (base : K → List Bool)
    (remaining output count : List Bool) (row : List Token) :
    InitializationControl.emitted (literalPorts p)
      (frame p base remaining output count) row =
    frame p base remaining ((tokenBits row).reverse ++ output)
      (List.replicate row.length true ++ count) := by
  simp only [InitializationControl.emitted, literalPorts, frame_output, frame_count]
  exact (OrClosure.update_reversed (corePorts p) base remaining output count
      ((tokenBits row).reverse ++ output)).symm ▸
    OrClosure.update_count (corePorts p) base remaining
      ((tokenBits row).reverse ++ output) count (List.replicate row.length true ++ count)

def repeatedRows (row : List Token) (n : Nat) : List Token :=
  (List.replicate n row).flatten

@[simp] theorem repeatedRows_zero (row : List Token) : repeatedRows row 0 = [] := rfl

@[simp] theorem repeatedRows_succ (row : List Token) (n : Nat) :
    repeatedRows row (n + 1) = row ++ repeatedRows row n := by
  simp [repeatedRows, List.replicate_succ]

@[simp] theorem repeatedRows_length (row : List Token) (n : Nat) :
    (repeatedRows row n).length = n * row.length := by
  induction n with
  | zero => simp
  | succ n ih => simp [ih, Nat.succ_mul, Nat.add_comm]

def statement (p : Ports K) (row : List Token) (again : Λ) (exit : Option Λ) :
    TM2.Stmt (fun _ : K => Bool) Λ (σ × Option Bool) :=
  .pop (p 3) (fun state head => (state.1, head))
    (.branch (fun state => state.2.getD false)
      (.load (fun state => (state.1, none))
        (InitializationControl.literalStatement (literalPorts p) row (some again)))
      (.push (p 3) (fun _ => false)
        (.load (fun state => (state.1, none))
          (InitializationControl.exitStatement exit))))

theorem step_zero (p : Ports K) (row : List Token) (again : Λ) (exit : Option Λ)
    (base : K → List Bool) (suffix output count : List Bool)
    (ambient : σ) (register : Option Bool) :
    TM2.stepAux (statement p row again exit) (ambient, register)
      (frame p base (encodeWord 0 ++ suffix) output count) =
      ⟨exit, (ambient, none), frame p base (encodeWord 0 ++ suffix) output count⟩ := by
  cases exit <;>
    simp [statement, TM2.stepAux, encodeWord, InitializationControl.exitStatement]

theorem step_succ (p : Ports K) (row : List Token) (again : Λ) (exit : Option Λ)
    (base : K → List Bool) (n : Nat) (suffix output count : List Bool)
    (ambient : σ) (register : Option Bool) :
    TM2.stepAux (statement p row again exit) (ambient, register)
      (frame p base (encodeWord (n + 1) ++ suffix) output count) =
      ⟨some again, (ambient, none), frame p base (encodeWord n ++ suffix)
        ((tokenBits row).reverse ++ output) (List.replicate row.length true ++ count)⟩ := by
  simp [statement, TM2.stepAux, encodeWord, List.replicate_succ,
    InitializationControl.literalStep]

theorem trace (p : Ports K) (row : List Token) (again : Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (fun _ : K => Bool) Λ (σ × Option Bool))
    (code : program again = statement p row again exit)
    (base : K → List Bool) (n : Nat) (suffix output count : List Bool)
    (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[n + 1]
      (some ⟨some again, (ambient, register),
        frame p base (encodeWord n ++ suffix) output count⟩) =
      some ⟨exit, (ambient, none), frame p base (encodeWord 0 ++ suffix)
        ((tokenBits (repeatedRows row n)).reverse ++ output)
        (List.replicate (n * row.length) true ++ count)⟩ := by
  induction n generalizing output count register with
  | zero =>
      change some (TM2.stepAux (program again) (ambient, register)
        (frame p base (encodeWord 0 ++ suffix) output count)) = _
      rw [code, step_zero]
      simp [tokenBits, tokenWords, encodeWords]
  | succ n ih =>
      rw [Function.iterate_succ_apply]
      change (MachineComposition.advance (TM2.step program))^[n + 1]
        (some (TM2.stepAux (program again) (ambient, register)
          (frame p base (encodeWord (n + 1) ++ suffix) output count))) = _
      rw [code, step_succ, ih]
      simp only [repeatedRows_succ, OrClosure.tokenBits_append, List.reverse_append,
        List.append_assoc]
      have hc : List.replicate (n * row.length) true ++
          (List.replicate row.length true ++ count) =
          List.replicate ((n + 1) * row.length) true ++ count := by
        rw [← List.append_assoc, List.replicate_append_replicate, Nat.succ_mul]
      rw [hc]

theorem frame_eq_capacityTapes (p : Ports K) (base : K → List Bool)
    (remaining : Nat) (input output count : List Bool) :
    frame p (Function.update base (p 0) input) (encodeWord remaining) output count =
      InputCellsCapacity.tapes p base remaining input output count := by
  funext k
  by_cases hk : ∃ j, p j = k
  · obtain ⟨j, rfl⟩ := hk
    fin_cases j <;> simp
  · have hn : ∀ j, k ≠ p j := fun j h => hk ⟨j, h.symm⟩
    rw [frame_other p _ _ _ _ k (hn 3) (hn 1) (hn 2),
      InputCellsCapacity.tapes_other p base remaining input output count k hn,
      Function.update_of_ne (hn 0)]

theorem capacityTrace (p : Ports K) (row : List Token) (again : Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (fun _ : K => Bool) Λ (σ × Option Bool))
    (code : program again = statement p row again exit)
    (base : K → List Bool) (n : Nat) (input output count : List Bool)
    (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[n + 1]
      (some ⟨some again, (ambient, register),
        InputCellsCapacity.tapes p base n input output count⟩) =
      some ⟨exit, (ambient, none), InputCellsCapacity.tapes p base 0 input
        ((tokenBits (repeatedRows row n)).reverse ++ output)
        (List.replicate (n * row.length) true ++ count)⟩ := by
  simpa only [List.append_nil, frame_eq_capacityTapes] using
    trace p row again exit program code (Function.update base (p 0) input)
      n [] output count ambient register

def inTime (p : Ports K) (row : List Token) (again : Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (fun _ : K => Bool) Λ (σ × Option Bool))
    (code : program again = statement p row again exit)
    (base : K → List Bool) (n : Nat) (suffix output count : List Bool)
    (ambient : σ) (register : Option Bool) :
    StateTransition.EvalsToInTime (TM2.step program)
      ⟨some again, (ambient, register), frame p base (encodeWord n ++ suffix) output count⟩
      (some ⟨exit, (ambient, none), frame p base (encodeWord 0 ++ suffix)
        ((tokenBits (repeatedRows row n)).reverse ++ output)
        (List.replicate (n * row.length) true ++ count)⟩) (n + 1) where
  steps := n + 1
  evals_in_steps := by
    change (MachineComposition.advance (TM2.step program))^[n + 1] _ = _
    exact trace p row again exit program code base n suffix output count ambient register
  steps_le_m := Nat.le_refl _

section FixedVerifier

local instance (V : NPVerifier) : DecidableEq V.computation.tm.Λ := Classical.decEq _
local instance (V : NPVerifier) : DecidableEq V.computation.tm.σ := Classical.decEq _
local instance (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) :=
  fun _ => Classical.decEq _

def blankRow (V : NPVerifier) : List Token :=
  (List.finRange (indexing V).symbolCount).map fun j =>
    let symbol := (indexing V).symbols.symm j
    .const (decide ((none : Option (V.computation.tm.Γ symbol.1)) = symbol.2))

@[simp] theorem blankRow_length (V : NPVerifier) :
    (blankRow V).length = (indexing V).symbolCount := by simp [blankRow]

theorem initialCellTokens_padding (V : NPVerifier) (input : List Bool) (S : Nat)
    (k : V.computation.tm.K) (i : Fin S) (a : Option (V.computation.tm.Γ k))
    (padding : (inputPrefix input).length + V.witnessBound.eval input.length ≤ i.val) :
    initialCellTokens V input S k i a = [.const (decide ((none : Option _) = a))] := by
  have hp : ¬ i.val < (inputPrefix input).length := by omega
  have hq : ¬ i.val - (inputPrefix input).length < V.witnessBound.eval input.length := by omega
  by_cases hk : k = V.computation.tm.k₀
  · subst k
    simp only [initialCellTokens, inputCellTokens, ite_eq_right hp, ite_eq_right hq, dite_eq_ite, ite_self]
  · simp [initialCellTokens, hk]

theorem cellRow_padding (V : NPVerifier) (input : List Bool) (S : Nat) (i : Fin S)
    (padding : (inputPrefix input).length + V.witnessBound.eval input.length ≤ i.val) :
    ((List.finRange (indexing V).symbolCount).flatMap fun j =>
      let symbol := (indexing V).symbols.symm j
      initialCellTokens V input S symbol.1 i symbol.2) = blankRow V := by
  simp only [initialCellTokens_padding V input S _ i _ padding]
  exact List.map_eq_flatMap.symm

def cellsInterval (V : NPVerifier) (input : List Bool) (S start n : Nat)
    (within : start + n ≤ S) : List Token :=
  (List.finRange n).flatMap fun i =>
    (List.finRange (indexing V).symbolCount).flatMap fun j =>
      let symbol := (indexing V).symbols.symm j
      initialCellTokens V input S symbol.1 ⟨start + i.val, by omega⟩ symbol.2

theorem cellsInterval_padding (V : NPVerifier) (input : List Bool) (S start n : Nat)
    (within : start + n ≤ S)
    (padding : (inputPrefix input).length + V.witnessBound.eval input.length ≤ start) :
    cellsInterval V input S start n within = repeatedRows (blankRow V) n := by
  unfold cellsInterval
  have hrow (i : Fin n) :
      ((List.finRange (indexing V).symbolCount).flatMap fun j =>
        let symbol := (indexing V).symbols.symm j
        initialCellTokens V input S symbol.1 ⟨start + i.val, by omega⟩ symbol.2) =
      blankRow V := cellRow_padding V input S _ (by
        change (inputPrefix input).length + V.witnessBound.eval input.length ≤ start + i.val
        omega)
  simp_rw [hrow]
  simp [List.flatMap_def, repeatedRows]

def verifierStatement (V : NPVerifier) (p : Ports K) (again : Λ) (exit : Option Λ) :
    TM2.Stmt (fun _ : K => Bool) Λ (σ × Option Bool) :=
  statement p (blankRow V) again exit

theorem verifierTrace (V : NPVerifier) (p : Ports K) (again : Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (fun _ : K => Bool) Λ (σ × Option Bool))
    (code : program again = verifierStatement V p again exit)
    (base : K → List Bool) (n : Nat) (suffix output count : List Bool)
    (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[n + 1]
      (some ⟨some again, (ambient, register),
        frame p base (encodeWord n ++ suffix) output count⟩) =
      some ⟨exit, (ambient, none), frame p base (encodeWord 0 ++ suffix)
        ((tokenBits (repeatedRows (blankRow V) n)).reverse ++ output)
        (List.replicate (n * (indexing V).symbolCount) true ++ count)⟩ := by
  simpa only [blankRow_length] using
    trace p (blankRow V) again exit program code base n suffix output count ambient register

theorem paddingCellsTrace (V : NPVerifier) (input : List Bool) (S start n : Nat)
    (within : start + n ≤ S)
    (padding : (inputPrefix input).length + V.witnessBound.eval input.length ≤ start)
    (p : Ports K) (again : Λ) (exit : Option Λ)
    (program : Λ → TM2.Stmt (fun _ : K => Bool) Λ (σ × Option Bool))
    (code : program again = verifierStatement V p again exit)
    (base : K → List Bool) (work output count : List Bool)
    (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (TM2.step program))^[n + 1]
      (some ⟨some again, (ambient, register),
        InputCellsCapacity.tapes p base n work output count⟩) =
      some ⟨exit, (ambient, none), InputCellsCapacity.tapes p base 0 work
        ((tokenBits (cellsInterval V input S start n within)).reverse ++ output)
        (List.replicate (n * (indexing V).symbolCount) true ++ count)⟩ := by
  rw [cellsInterval_padding V input S start n within padding]
  simpa only [blankRow_length] using
    capacityTrace p (blankRow V) again exit program code base n work output count ambient register

end FixedVerifier

variable [Fintype K] [Fintype σ]

def machine (p : Ports K) (row : List Token) (ambient : σ) : FinTM2 where
  K := K
  k₀ := p 3
  k₁ := p 1
  Γ := fun _ => Bool
  Λ := Unit
  main := ()
  σ := σ × Option Bool
  initialState := (ambient, none)
  Γk₀Fin := inferInstance
  m _ := statement p row () none

theorem machineTrace (p : Ports K) (row : List Token) (base : K → List Bool)
    (n : Nat) (suffix output count : List Bool) (ambient : σ) (register : Option Bool) :
    (MachineComposition.advance (machine p row ambient).step)^[n + 1]
      (some ⟨some (), (ambient, register),
        frame p base (encodeWord n ++ suffix) output count⟩) =
      some ⟨none, (ambient, none), frame p base (encodeWord 0 ++ suffix)
        ((tokenBits (repeatedRows row n)).reverse ++ output)
        (List.replicate (n * row.length) true ++ count)⟩ :=
  trace p row () none (machine p row ambient).m rfl
    base n suffix output count ambient register

end BinPackingGames.Foundations.Complexity.CookLevin.PaddingCellsMachine

end

end OAI