lean/OAI/Computability/BinPacking/CookLevin/PostfixBounds.lean

import Mathlib.Tactic.DeriveFintype
import Mathlib.Tactic.FinCases
import Mathlib.Tactic.Ring
import OAI.Computability.BinPacking.Computation.MachineInitialHeaders
import OAI.Computability.BinPacking.CookLevin.OutputOrder

namespace OAI

namespace BinPackingGames.Foundations.Complexity.CookLevin.PostfixMachine

open Turing PostfixModel Hastad

inductive Tape
  | input | current | remaining | roots | left | right | reversed | output | scratch
  deriving DecidableEq

protected abbrev Tape.enumList : List Tape := [.input, .current, .remaining, .roots, .left,
  .right, .reversed, .output, .scratch]

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

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

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

abbrev Alphabet (_ : Tape) := Bool
abbrev State := Unit × Option Bool

inductive Label
  | headerStart (slot : Fin 2) | headerLoop (slot : Fin 2)
  | guard | decode
  | readStart (tag : Fin 6) (pass : Fin 2) | readLoop (tag : Fin 6) (pass : Fin 2)
  | emitTag (tag : Fin 6)
  | field (tag : Fin 6) (slot : Fin 3)
  | restore (tag : Fin 6) (slot : Fin 3)
  | closeField (tag : Fin 6) (slot : Fin 3)
  | rootDrain | rootFork | increment | clearLeft | clearRight | finish | finalReverse
  deriving DecidableEq, Fintype

def initialState : State := ((), none)

def headerTape (slot : Fin 2) : Tape := if slot.val = 0 then .current else .remaining

def binary (tag : Fin 6) : Bool := decide (tag.val = 3 ∨ tag.val = 4)

def readSource (tag : Fin 6) : Tape := if tag.val = 5 then .input else .roots

def readDestination (tag : Fin 6) (pass : Fin 2) : Tape :=
  if binary tag && decide (pass.val = 0) then .right else .left

def readNext (tag : Fin 6) (pass : Fin 2) : Label :=
  if binary tag && decide (pass.val = 0) then .readStart tag 1 else .emitTag tag

def prepare (tag : Fin 6) : Label :=
  if tag.val < 2 then .emitTag tag else .readStart tag 0

def gateTag (tag : Fin 6) : Nat := if tag.val = 5 then 4 else tag.val

def fieldSource (tag : Fin 6) (slot : Fin 3) : Tape :=
  if slot.val = 0 then .current
  else if slot.val = 1 ∨ tag.val = 5 then .left else .right

def fieldUnused (tag : Fin 6) (slot : Fin 3) : Bool :=
  decide (slot.val ≠ 0 ∧ (tag.val < 2 ∨ (tag.val = 2 ∧ slot.val = 2)))

def fieldNext (tag : Fin 6) (slot : Fin 3) : Label :=
  if h : slot.val + 1 < 3 then .field tag ⟨slot.val + 1, h⟩ else .rootDrain

def resetGoto (label : Label) : TM2.Stmt Alphabet Label State :=
  .load (fun _ => initialState) (.goto fun _ => label)

def tagDecoder : Nat → Fin 6 → TM2.Stmt Alphabet Label State
  | 0, tag => .pop .input (fun state head => (state.1, head))
      (.branch (fun state => state.2.getD false) (.halt) (resetGoto (prepare tag)))
  | fuel + 1, tag => .pop .input (fun state head => (state.1, head))
      (.branch (fun state => state.2.getD false)
        (tagDecoder fuel ⟨min (tag.val + 1) 5, by omega⟩) (resetGoto (prepare tag)))

def program : Label → TM2.Stmt Alphabet Label State
  | .headerStart slot => SourceMachine.fieldStart (headerTape slot) (.headerLoop slot)
  | .headerLoop slot => SourceMachine.fieldLoop .input (headerTape slot) (.headerLoop slot)
      (some (if slot.val = 0 then .headerStart 1 else .guard))
  | .guard => MachineUnaryCounter.guard .remaining .decode .finish
  | .decode => tagDecoder 5 0
  | .readStart tag pass => SourceMachine.fieldStart (readDestination tag pass) (.readLoop tag pass)
  | .readLoop tag pass => SourceMachine.fieldLoop (readSource tag) (readDestination tag pass)
      (.readLoop tag pass) (some (readNext tag pass))
  | .emitTag tag => Reduction.MachineSubstitution.pushWord .reversed (encodeWord (gateTag tag))
      (.goto fun _ => .field tag 0)
  | .field tag slot =>
      if fieldUnused tag slot then
        .push .reversed (fun _ => false) (.goto fun _ => fieldNext tag slot)
      else MachineInitialHeaders.prefixScan (fieldSource tag slot) .scratch .reversed 1
        (.field tag slot) (.restore tag slot)
  | .restore tag slot => Reduction.MachineTransfer.loopAt .scratch (fieldSource tag slot)
      id false (.restore tag slot) (some (.closeField tag slot))
  | .closeField tag slot => .push .reversed (fun _ => false) (.goto fun _ => fieldNext tag slot)
  | .rootDrain => Reduction.MachineTransfer.loopAt .current .scratch id false
      .rootDrain (some .rootFork)
  | .rootFork => MachineCopy.forkLoop .scratch .current .roots false .rootFork (some .increment)
  | .increment => .push .current (fun _ => true) (.goto fun _ => .clearLeft)
  | .clearLeft => MachineDrain.drain .left .clearLeft (some .clearRight)
  | .clearRight => MachineDrain.drain .right .clearRight (some .guard)
  | .finish => .pop .remaining (fun _ _ => initialState) (.goto fun _ => .finalReverse)
  | .finalReverse => Reduction.MachineTransfer.loopAt .reversed .output id false .finalReverse none

def machine : FinTM2 where
  K := Tape
  k₀ := .input
  k₁ := .output
  Γ := Alphabet
  Λ := Label
  main := .headerStart 0
  σ := State
  initialState := initialState
  m := program

private abbrev advance := MachineComposition.advance (TM2.step program)

def outputTapes (base : Tape → List Bool) (bits : List Bool) : Tape → List Bool :=
  Function.update base .reversed (bits ++ base .reversed)

@[simp] theorem outputTapes_reversed (base : Tape → List Bool) (bits : List Bool) :
    outputTapes base bits .reversed = bits ++ base .reversed := by simp [outputTapes]

theorem outputTapes_other (base : Tape → List Bool) (bits : List Bool) (tape : Tape)
    (h : tape ≠ .reversed) : outputTapes base bits tape = base tape := by
  simp [outputTapes, h]

@[simp] theorem outputTapes_twice (base : Tape → List Bool) (first second : List Bool) :
    outputTapes (outputTapes base first) second = outputTapes base (second ++ first) := by
  funext tape
  by_cases h : tape = .reversed
  · subst tape; simp [List.append_assoc]
  · simp [outputTapes, h]

private theorem trace_trans {α : Type*} (f : α → α) {a b : ℕ} {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 readSource_ne_destination (tag : Fin 6) (pass : Fin 2) :
    readSource tag ≠ readDestination tag pass := by
  unfold readSource readDestination
  split <;> split <;> decide

theorem fieldSource_ne_scratch (tag : Fin 6) (slot : Fin 3) :
    fieldSource tag slot ≠ .scratch := by
  unfold fieldSource
  split <;> first | decide | (split <;> decide)

theorem fieldSource_ne_reversed (tag : Fin 6) (slot : Fin 3) :
    fieldSource tag slot ≠ .reversed := by
  unfold fieldSource
  split <;> first | decide | (split <;> decide)

theorem decodeTrace (tag : Fin 6) (base : Tape → List Bool) (suffix : List Bool)
    (hinput : base .input = encodeWord tag.val ++ suffix) :
    advance^[1] (some ⟨some .decode, initialState, base⟩) =
      some ⟨some (prepare tag), initialState, Function.update base .input suffix⟩ := by
  change some (TM2.stepAux (program .decode) initialState base) = _
  fin_cases tag <;>
    simp [program, tagDecoder, TM2.stepAux, hinput, encodeWord, resetGoto, initialState]

theorem readTrace (tag : Fin 6) (pass : Fin 2) (base : Tape → List Bool)
    (value : Nat) (suffix : List Bool)
    (hinput : base (readSource tag) = encodeWord value ++ suffix) :
    advance^[value + 2] (some ⟨some (.readStart tag pass), initialState, base⟩) =
      some ⟨some (readNext tag pass), initialState,
        SourceMachine.fieldTapes (readSource tag) (readDestination tag pass) base suffix
          (encodeWord value ++ base (readDestination tag pass))⟩ := by
  have h := (SourceMachine.fieldInTime (K := Tape) (Λ := Label) (σ := Unit)
    (readSource tag) (readDestination tag pass)
    (readSource_ne_destination tag pass) (.readStart tag pass) (.readLoop tag pass)
    (some (readNext tag pass)) program rfl rfl base value suffix hinput () none).evals_in_steps
  change advance^[value + 2]
    (some ⟨some (.readStart tag pass), initialState, base⟩) =
    some ⟨some (readNext tag pass), initialState,
      SourceMachine.fieldTapes (readSource tag) (readDestination tag pass) base suffix
        (encodeWord value ++ base (readDestination tag pass))⟩ at h
  exact h

theorem emitTagTrace (tag : Fin 6) (base : Tape → List Bool) :
    advance^[1] (some ⟨some (.emitTag tag), initialState, base⟩) =
      some ⟨some (.field tag 0), initialState,
        outputTapes base (encodeWord (gateTag tag)).reverse⟩ :=
  MachineInitialHeaders.literalTrace .reversed (encodeWord (gateTag tag))
    (.emitTag tag) (some (.field tag 0)) program rfl base () none

def FieldReady (tag : Fin 6) (slot : Fin 3) (base : Tape → List Bool) (value : Nat) : Prop :=
  (fieldUnused tag slot = true → value = 0) ∧
    (fieldUnused tag slot = false → base (fieldSource tag slot) = encodeWord value)

theorem FieldReady.output (tag : Fin 6) (slot : Fin 3) (base : Tape → List Bool)
    (value : Nat) (h : FieldReady tag slot base value) (bits : List Bool) :
    FieldReady tag slot (outputTapes base bits) value := by
  refine ⟨h.1, ?_⟩
  intro used
  rw [outputTapes_other base bits _ (fieldSource_ne_reversed tag slot)]
  exact h.2 used

def fieldSteps (tag : Fin 6) (slot : Fin 3) (value : Nat) : Nat :=
  if fieldUnused tag slot then 1 else 2 * value + 3

theorem fieldTrace (tag : Fin 6) (slot : Fin 3) (base : Tape → List Bool)
    (value : Nat) (ready : FieldReady tag slot base value) (hscratch : base .scratch = []) :
    advance^[fieldSteps tag slot value]
      (some ⟨some (.field tag slot), initialState, base⟩) =
      some ⟨some (fieldNext tag slot), initialState,
        outputTapes base (encodeWord value).reverse⟩ := by
  cases hu : fieldUnused tag slot with
  | true =>
      have hz := ready.1 hu
      subst value
      simp only [fieldSteps, hu, ↓reduceIte]
      change some (TM2.stepAux (program (.field tag slot)) initialState base) = _
      simp only [program, hu, ↓reduceIte, TM2.stepAux, encodeWord, List.replicate_zero,
        List.nil_append, List.reverse_singleton, outputTapes, List.singleton_append]
  | false =>
      have hcopy := (MachineInitialHeaders.prefixInTime (fieldSource tag slot) .scratch .reversed
        (fieldSource_ne_scratch tag slot) (fieldSource_ne_reversed tag slot) (by decide)
        1 (.field tag slot) (.restore tag slot) (some (.closeField tag slot)) program
        (by simp only [program, hu, Bool.false_eq_true, ↓reduceIte]) rfl base value []
        (by simpa using ready.2 hu) hscratch () none).evals_in_steps
      let copied := outputTapes base (List.replicate value true)
      change advance^[2 * value + 2]
        (some ⟨some (.field tag slot), initialState, base⟩) =
        some ⟨some (.closeField tag slot), initialState,
          outputTapes base (List.replicate (1 * value) true)⟩ at hcopy
      simp only [Nat.one_mul] at hcopy
      have hclose : advance^[1]
          (some ⟨some (.closeField tag slot), initialState, copied⟩) =
          some ⟨some (fieldNext tag slot), initialState, outputTapes copied [false]⟩ := by
        change some (TM2.stepAux (program (.closeField tag slot)) initialState copied) = _
        rfl
      have total := trace_trans _ hcopy hclose
      simpa only [fieldSteps, hu, Bool.false_eq_true, ↓reduceIte, copied, outputTapes_twice,
        encodeWord, List.reverse_append, List.reverse_singleton, List.reverse_replicate,
        show 2 * value + 2 + 1 = 2 * value + 3 by omega] using total

theorem rootPushTrace (base : Tape → List Bool) (current : Nat)
    (hcurrent : base .current = encodeWord current) (hscratch : base .scratch = []) :
    advance^[2 * current + 4]
      (some ⟨some .rootDrain, initialState, base⟩) =
      some ⟨some .increment, initialState,
        Function.update base .roots (encodeWord current ++ base .roots)⟩ := by
  have h := MachineCopy.copyTrace Tape.current Tape.roots Tape.scratch
    (by decide) (by decide) (by decide) false .rootDrain .rootFork (some .increment)
    program rfl rfl base hscratch () none
  simpa only [hcurrent, encodeWord_length, advance, initialState,
    show 2 * (current + 1 + 1) = 2 * current + 4 by omega] using h

theorem incrementTrace (base : Tape → List Bool) (current : Nat)
    (hcurrent : base .current = encodeWord current) :
    advance^[1] (some ⟨some .increment, initialState, base⟩) =
      some ⟨some .clearLeft, initialState,
        Function.update base .current (encodeWord (current + 1))⟩ := by
  change some (TM2.stepAux (program .increment) initialState base) = _
  simp only [program, TM2.stepAux, hcurrent, encodeWord, List.replicate_succ,
    List.cons_append]

def recordSteps (tag : Fin 6) (values : Fin 3 → Nat) : Nat :=
  1 + fieldSteps tag 0 (values 0) + fieldSteps tag 1 (values 1) + fieldSteps tag 2 (values 2)

theorem recordTrace (tag : Fin 6) (base : Tape → List Bool) (values : Fin 3 → Nat)
    (ready : ∀ slot, FieldReady tag slot base (values slot)) (hscratch : base .scratch = []) :
    advance^[recordSteps tag values]
      (some ⟨some (.emitTag tag), initialState, base⟩) =
      some ⟨some .rootDrain, initialState,
        outputTapes base (encodeWords [gateTag tag, values 0, values 1, values 2]).reverse⟩ := by
  let first := outputTapes base (encodeWord (gateTag tag)).reverse
  let second := outputTapes first (encodeWord (values 0)).reverse
  let third := outputTapes second (encodeWord (values 1)).reverse
  have readyFirst : ∀ slot, FieldReady tag slot first (values slot) :=
    fun slot => FieldReady.output tag slot base (values slot) (ready slot)
      (encodeWord (gateTag tag)).reverse
  have readySecond : ∀ slot, FieldReady tag slot second (values slot) :=
    fun slot => FieldReady.output tag slot first (values slot) (readyFirst slot)
      (encodeWord (values 0)).reverse
  have readyThird : ∀ slot, FieldReady tag slot third (values slot) :=
    fun slot => FieldReady.output tag slot second (values slot) (readySecond slot)
      (encodeWord (values 1)).reverse
  have ht := emitTagTrace tag base
  have h0 := fieldTrace tag 0 first (values 0) (readyFirst 0)
    (by simpa [first, outputTapes] using hscratch)
  have h1 := fieldTrace tag 1 second (values 1) (readySecond 1)
    (by simpa [second, first, outputTapes] using hscratch)
  have h2 := fieldTrace tag 2 third (values 2) (readyThird 2)
    (by simpa [third, second, first, outputTapes] using hscratch)
  change advance^[fieldSteps tag 0 (values 0)]
    (some ⟨some (.field tag 0), initialState, first⟩) =
    some ⟨some (.field tag 1), initialState, second⟩ at h0
  change advance^[fieldSteps tag 1 (values 1)]
    (some ⟨some (.field tag 1), initialState, second⟩) =
    some ⟨some (.field tag 2), initialState, third⟩ at h1
  change advance^[fieldSteps tag 2 (values 2)]
    (some ⟨some (.field tag 2), initialState, third⟩) =
    some ⟨some .rootDrain, initialState,
      outputTapes third (encodeWord (values 2)).reverse⟩ at h2
  have total := trace_trans _ (trace_trans _ (trace_trans _ ht h0) h1) h2
  simpa only [recordSteps, third, second, first, outputTapes_twice, encodeWords,
    List.append_nil, List.reverse_append, List.append_assoc] using total

def clearTapes (base : Tape → List Bool) : Tape → List Bool :=
  Function.update (Function.update base .left []) .right []

theorem clearTrace (base : Tape → List Bool) :
    advance^[(base .left).length + (base .right).length + 2]
      (some ⟨some .clearLeft, initialState, base⟩) =
      some ⟨some .guard, initialState, clearTapes base⟩ := by
  let first := Function.update base .left []
  have h1 := (MachineDrain.drainInTime Tape.left .clearLeft (some .clearRight)
    program rfl base () none).evals_in_steps
  have h2 := (MachineDrain.drainInTime Tape.right .clearRight (some .guard)
    program rfl first () none).evals_in_steps
  change advance^[(base .left).length + 1]
    (some ⟨some .clearLeft, initialState, base⟩) =
    some ⟨some .clearRight, initialState, first⟩ at h1
  change advance^[(first .right).length + 1]
    (some ⟨some .clearRight, initialState, first⟩) =
    some ⟨some .guard, initialState, clearTapes base⟩ at h2
  have total := trace_trans _ h1 h2
  simpa only [first, Function.update_of_ne (by decide : Tape.right ≠ .left),
    show (base .left).length + 1 + ((base .right).length + 1) =
      (base .left).length + (base .right).length + 2 by omega] using total

def finishTapes (base : Tape → List Bool) (current : Nat) : Tape → List Bool :=
  clearTapes (Function.update
    (Function.update base .roots (encodeWord current ++ base .roots))
    .current (encodeWord (current + 1)))

theorem finishNodeTrace (base : Tape → List Bool) (current : Nat)
    (hcurrent : base .current = encodeWord current) (hscratch : base .scratch = []) :
    advance^[2 * current + (base .left).length + (base .right).length + 7]
      (some ⟨some .rootDrain, initialState, base⟩) =
      some ⟨some .guard, initialState, finishTapes base current⟩ := by
  let pushed := Function.update base .roots (encodeWord current ++ base .roots)
  let incremented := Function.update pushed .current (encodeWord (current + 1))
  have h1 := rootPushTrace base current hcurrent hscratch
  have h2 := incrementTrace pushed current (by simpa [pushed] using hcurrent)
  have h3 := clearTrace incremented
  have total := trace_trans _ (trace_trans _ h1 h2) h3
  simpa only [finishTapes, incremented, pushed,
    Function.update_of_ne (by decide : Tape.left ≠ .current),
    Function.update_of_ne (by decide : Tape.right ≠ .current),
    Function.update_of_ne (by decide : Tape.left ≠ .roots),
    Function.update_of_ne (by decide : Tape.right ≠ .roots),
    show (2 * current + 4) + 1 + ((base .left).length + (base .right).length + 2) =
      2 * current + (base .left).length + (base .right).length + 7 by omega] using total

theorem emitPreparedTrace (tag : Fin 6) (base : Tape → List Bool)
    (current : Nat) (gate : Gate)
    (htag : gateTag tag = (gateRecord current gate).tag.val)
    (ready : ∀ slot, FieldReady tag slot base ((gateRecord current gate).slot slot))
    (hcurrent : base .current = encodeWord current) (hscratch : base .scratch = []) :
    advance^[recordSteps tag (gateRecord current gate).slot +
      (2 * current + (base .left).length + (base .right).length + 7)]
      (some ⟨some (.emitTag tag), initialState, base⟩) =
      some ⟨some .guard, initialState,
        finishTapes (outputTapes base (gateRecord current gate).bits.reverse) current⟩ := by
  have hrecord := recordTrace tag base (gateRecord current gate).slot ready hscratch
  have hwords : [gateTag tag, (gateRecord current gate).slot 0,
      (gateRecord current gate).slot 1, (gateRecord current gate).slot 2] =
      (gateRecord current gate).words := by
    rw [htag]
    rfl
  rw [hwords] at hrecord
  let emitted := outputTapes base (gateRecord current gate).bits.reverse
  have hfinish := finishNodeTrace emitted current
    (by simpa [emitted, outputTapes] using hcurrent)
    (by simpa [emitted, outputTapes] using hscratch)
  have total := trace_trans _ hrecord hfinish
  simpa only [emitted, outputTapes_other base _ .left (by decide),
    outputTapes_other base _ .right (by decide)] using total

def boundaryTapes (base : Tape → List Bool) (current : Nat)
    (roots : List Nat) (input : List Bool) : Tape → List Bool
  | .input => input
  | .current => encodeWord current
  | .roots => encodeWords roots
  | .left | .right | .scratch => []
  | tape => base tape

def preparedTapes (base : Tape → List Bool) (current : Nat)
    (roots : List Nat) (input left right : List Bool) : Tape → List Bool
  | .input => input
  | .current => encodeWord current
  | .roots => encodeWords roots
  | .left => left
  | .right => right
  | .scratch => []
  | tape => base tape

def operandFields : Token → Gate → List Bool × List Bool
  | .const _, _ => ([], [])
  | .input wire, _ => (encodeWord wire, [])
  | .not, .not arg => (encodeWord arg, [])
  | .and, .and left right | .or, .or left right => (encodeWord left, encodeWord right)
  | _, _ => ([], [])

def operandSteps : Token → Gate → Nat
  | .const _, _ => 0
  | .input wire, _ => wire + 2
  | .not, .not arg => arg + 2
  | .and, .and left right | .or, .or left right => left + right + 4
  | _, _ => 0

def tokenSteps (current : Nat) (token : Token) (gate : Gate) : Nat :=
  1 + operandSteps token gate + recordSteps token.tag (gateRecord current gate).slot +
    (2 * current + (operandFields token gate).1.length +
      (operandFields token gate).2.length + 7)

def tokensSteps (current : Nat) (roots : List Nat) : List Token → Nat
  | [] => 0
  | token :: tokens => match token.takeGate roots with
      | none => 0
      | some (gate, rest) =>
          1 + tokenSteps current token gate + tokensSteps (current + 1) (current :: rest) tokens

def argumentBits : Token → List Bool
  | .input wire => encodeWord wire
  | _ => []

theorem token_bits (token : Token) : token.bits = encodeWord token.tag.val ++ argumentBits token := by
  cases token with
  | const value => cases value <;> simp [Token.bits, Token.words, Token.tag, argumentBits, encodeWords]
  | not | and | or | input _ => simp [Token.bits, Token.words, Token.tag, argumentBits, encodeWords]

theorem prepareInputTrace (base : Tape → List Bool) (current wire : Nat)
    (roots : List Nat) (suffix : List Bool) :
    advance^[wire + 2]
      (some ⟨some (.readStart 5 0), initialState,
        boundaryTapes base current roots (encodeWord wire ++ suffix)⟩) =
      some ⟨some (.emitTag 5), initialState,
        preparedTapes base current roots suffix (encodeWord wire) []⟩ := by
  let first := boundaryTapes base current roots (encodeWord wire ++ suffix)
  have h := readTrace 5 0 first wire suffix rfl
  have hout : SourceMachine.fieldTapes (readSource 5) (readDestination 5 0) first suffix
      (encodeWord wire ++ first (readDestination 5 0)) =
      preparedTapes base current roots suffix (encodeWord wire) [] := by
    funext tape
    cases tape <;> simp [SourceMachine.fieldTapes, first, boundaryTapes, preparedTapes,
      readSource, readDestination, binary]
  rw [hout] at h
  exact h

theorem prepareUnaryTrace (base : Tape → List Bool) (current arg : Nat)
    (roots : List Nat) (suffix : List Bool) :
    advance^[arg + 2]
      (some ⟨some (.readStart 2 0), initialState,
        boundaryTapes base current (arg :: roots) suffix⟩) =
      some ⟨some (.emitTag 2), initialState,
        preparedTapes base current roots suffix (encodeWord arg) []⟩ := by
  let first := boundaryTapes base current (arg :: roots) suffix
  have h := readTrace 2 0 first arg (encodeWords roots) rfl
  have hout : SourceMachine.fieldTapes (readSource 2) (readDestination 2 0) first
      (encodeWords roots) (encodeWord arg ++ first (readDestination 2 0)) =
      preparedTapes base current roots suffix (encodeWord arg) [] := by
    funext tape
    cases tape <;> simp [SourceMachine.fieldTapes, first, boundaryTapes, preparedTapes,
      readSource, readDestination, binary]
  rw [hout] at h
  exact h

theorem prepareBinaryTrace (tag : Fin 6) (hb : binary tag = true) (hinput : tag.val ≠ 5)
    (base : Tape → List Bool) (current left right : Nat) (roots : List Nat) (suffix : List Bool) :
    advance^[left + right + 4]
      (some ⟨some (.readStart tag 0), initialState,
        boundaryTapes base current (right :: left :: roots) suffix⟩) =
      some ⟨some (.emitTag tag), initialState,
        preparedTapes base current roots suffix (encodeWord left) (encodeWord right)⟩ := by
  let first := boundaryTapes base current (right :: left :: roots) suffix
  let second := preparedTapes base current (left :: roots) suffix [] (encodeWord right)
  have h1 := readTrace tag 0 first right (encodeWords (left :: roots))
    (by simp [first, readSource, hinput, boundaryTapes, encodeWords])
  have frame1 : SourceMachine.fieldTapes (readSource tag) (readDestination tag 0) first
      (encodeWords (left :: roots)) (encodeWord right ++ first (readDestination tag 0)) = second := by
    funext tape
    cases tape <;> simp [SourceMachine.fieldTapes, first, second, boundaryTapes, preparedTapes,
      readSource, readDestination, hb, hinput]
  rw [frame1] at h1
  have h2 := readTrace tag 1 second left (encodeWords roots)
    (by simp [second, readSource, hinput, preparedTapes, encodeWords])
  have frame2 : SourceMachine.fieldTapes (readSource tag) (readDestination tag 1) second
      (encodeWords roots) (encodeWord left ++ second (readDestination tag 1)) =
      preparedTapes base current roots suffix (encodeWord left) (encodeWord right) := by
    funext tape
    cases tape <;> simp [SourceMachine.fieldTapes, second, preparedTapes,
      readSource, readDestination, hb, hinput]
  rw [frame2] at h2
  simp only [readNext, hb, Fin.val_zero, Fin.val_one, decide_true, Bool.and_true,
    Nat.one_ne_zero, decide_false, Bool.and_false, Bool.false_eq_true, ↓reduceIte] at h1 h2
  have total := trace_trans _ h1 h2
  simpa only [show (right + 2) + (left + 2) = left + right + 4 by omega] using total

theorem prepareTrace (base : Tape → List Bool) (current : Nat) (token : Token)
    (roots rest : List Nat) (gate : Gate) (suffix : List Bool)
    (htake : token.takeGate roots = some (gate, rest)) :
    advance^[operandSteps token gate]
      (some ⟨some (prepare token.tag), initialState,
        boundaryTapes base current roots (argumentBits token ++ suffix)⟩) =
      some ⟨some (.emitTag token.tag), initialState,
        preparedTapes base current rest suffix
          (operandFields token gate).1 (operandFields token gate).2⟩ := by
  cases token with
  | const value =>
      simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
      rcases htake with ⟨rfl, rfl⟩
      cases value <;>
        simp [Token.tag, operandSteps, operandFields, argumentBits, prepare] <;>
        funext tape <;> cases tape <;> rfl
  | input wire =>
      simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
      rcases htake with ⟨rfl, rfl⟩
      simpa [Token.tag, operandSteps, operandFields, argumentBits, prepare] using
        prepareInputTrace base current wire roots suffix
  | not =>
      cases roots with
      | nil => simp [Token.takeGate] at htake
      | cons arg roots =>
          simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
          rcases htake with ⟨rfl, rfl⟩
          simpa [Token.tag, operandSteps, operandFields, argumentBits, prepare] using
            prepareUnaryTrace base current arg roots suffix
  | and =>
      cases roots with
      | nil => simp [Token.takeGate] at htake
      | cons right roots =>
          cases roots with
          | nil => simp [Token.takeGate] at htake
          | cons left roots =>
              simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
              rcases htake with ⟨rfl, rfl⟩
              simpa [Token.tag, operandSteps, operandFields, argumentBits, prepare] using
                prepareBinaryTrace 3 (by decide) (by decide) base current left right roots suffix
  | or =>
      cases roots with
      | nil => simp [Token.takeGate] at htake
      | cons right roots =>
          cases roots with
          | nil => simp [Token.takeGate] at htake
          | cons left roots =>
              simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
              rcases htake with ⟨rfl, rfl⟩
              simpa [Token.tag, operandSteps, operandFields, argumentBits, prepare] using
                prepareBinaryTrace 4 (by decide) (by decide) base current left right roots suffix

theorem preparedReady (base : Tape → List Bool) (current : Nat) (token : Token)
    (roots rest : List Nat) (gate : Gate) (suffix : List Bool)
    (htake : token.takeGate roots = some (gate, rest)) :
    gateTag token.tag = (gateRecord current gate).tag.val ∧
      ∀ slot, FieldReady token.tag slot
        (preparedTapes base current rest suffix
          (operandFields token gate).1 (operandFields token gate).2)
        ((gateRecord current gate).slot slot) := by
  cases token with
  | const value =>
      simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
      rcases htake with ⟨rfl, rfl⟩
      cases value <;> refine ⟨rfl, ?_⟩ <;> intro slot <;> fin_cases slot <;>
        simp [FieldReady, Token.tag, fieldUnused, fieldSource, preparedTapes, operandFields,
          gateRecord, CircuitProducerModel.Record.slot]
  | input wire =>
      simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
      rcases htake with ⟨rfl, rfl⟩
      refine ⟨rfl, ?_⟩
      intro slot
      fin_cases slot <;> simp [FieldReady, Token.tag, fieldUnused, fieldSource, preparedTapes,
        operandFields, gateRecord, CircuitProducerModel.Record.slot]
  | not =>
      cases roots with
      | nil => simp [Token.takeGate] at htake
      | cons arg roots =>
          simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
          rcases htake with ⟨rfl, rfl⟩
          refine ⟨rfl, ?_⟩
          intro slot
          fin_cases slot <;> simp [FieldReady, Token.tag, fieldUnused, fieldSource, preparedTapes,
            operandFields, gateRecord, CircuitProducerModel.Record.slot]
  | and =>
      cases roots with
      | nil => simp [Token.takeGate] at htake
      | cons right roots =>
          cases roots with
          | nil => simp [Token.takeGate] at htake
          | cons left roots =>
              simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
              rcases htake with ⟨rfl, rfl⟩
              refine ⟨rfl, ?_⟩
              intro slot
              fin_cases slot <;> simp [FieldReady, Token.tag, fieldUnused, fieldSource, preparedTapes,
                operandFields, gateRecord, CircuitProducerModel.Record.slot]
  | or =>
      cases roots with
      | nil => simp [Token.takeGate] at htake
      | cons right roots =>
          cases roots with
          | nil => simp [Token.takeGate] at htake
          | cons left roots =>
              simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
              rcases htake with ⟨rfl, rfl⟩
              refine ⟨rfl, ?_⟩
              intro slot
              fin_cases slot <;> simp [FieldReady, Token.tag, fieldUnused, fieldSource, preparedTapes,
                operandFields, gateRecord, CircuitProducerModel.Record.slot]

theorem tokenTrace (base : Tape → List Bool) (current : Nat) (token : Token)
    (roots rest : List Nat) (gate : Gate) (suffix : List Bool)
    (htake : token.takeGate roots = some (gate, rest)) :
    advance^[tokenSteps current token gate]
      (some ⟨some .decode, initialState,
        boundaryTapes base current roots (token.bits ++ suffix)⟩) =
      some ⟨some .guard, initialState,
        boundaryTapes (outputTapes base (gateRecord current gate).bits.reverse)
          (current + 1) (current :: rest) suffix⟩ := by
  let first := boundaryTapes base current roots (token.bits ++ suffix)
  let decoded := boundaryTapes base current roots (argumentBits token ++ suffix)
  let prepared := preparedTapes base current rest suffix
    (operandFields token gate).1 (operandFields token gate).2
  have hd := decodeTrace token.tag first (argumentBits token ++ suffix)
    (by simp only [first, boundaryTapes, token_bits, List.append_assoc])
  have decodedFrame : Function.update first .input (argumentBits token ++ suffix) = decoded := by
    funext tape
    cases tape <;> simp [first, decoded, boundaryTapes]
  rw [decodedFrame] at hd
  have hp := prepareTrace base current token roots rest gate suffix htake
  have ready := preparedReady base current token roots rest gate suffix htake
  have he := emitPreparedTrace token.tag prepared current gate ready.1 ready.2 rfl rfl
  have total := trace_trans _ (trace_trans _ hd hp) he
  have finishedFrame : finishTapes (outputTapes prepared (gateRecord current gate).bits.reverse)
      current = boundaryTapes (outputTapes base (gateRecord current gate).bits.reverse)
        (current + 1) (current :: rest) suffix := by
    funext tape
    cases tape <;> simp [finishTapes, clearTapes, prepared, preparedTapes, boundaryTapes,
      outputTapes, encodeWords]
  rw [finishedFrame] at total
  simpa only [tokenSteps, first, prepared, preparedTapes, Nat.add_assoc] using total

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

theorem boundary_remaining (base : Tape → List Bool) (current : Nat)
    (roots : List Nat) (input : List Bool) (count : Nat) :
    Function.update (boundaryTapes base current roots input) .remaining (encodeWord count) =
      boundaryTapes (Function.update base .remaining (encodeWord count)) current roots input := by
  funext tape
  cases tape <;> simp [boundaryTapes]

theorem guardPositiveTrace (base : Tape → List Bool) (count : Nat)
    (hcount : base .remaining = encodeWord (count + 1)) :
    advance^[1] (some ⟨some .guard, initialState, base⟩) =
      some ⟨some .decode, initialState, Function.update base .remaining (encodeWord count)⟩ := by
  change some (TM2.stepAux (program .guard) initialState base) = _
  simp [program, MachineUnaryCounter.guard, TM2.stepAux, hcount, encodeWord,
    List.replicate_succ, initialState]

theorem tokensTrace (tokens : List Token) (base : Tape → List Bool) (current : Nat)
    (roots : List Nat) (next : Nat) (finalRoots : List Nat) (gates : List Gate)
    (suffix : List Bool)
    (hcompile : compileTokens current roots tokens = some (next, finalRoots, gates))
    (hcount : base .remaining = encodeWord tokens.length) :
    advance^[tokensSteps current roots tokens]
      (some ⟨some .guard, initialState,
        boundaryTapes base current roots (tokenBits tokens ++ suffix)⟩) =
      some ⟨some .guard, initialState,
        boundaryTapes
          (outputTapes (Function.update base .remaining (encodeWord 0))
            (recordsBits (gateRecords current gates)).reverse)
          next finalRoots suffix⟩ := by
  induction tokens generalizing base current roots next finalRoots gates with
  | nil =>
      simp only [compileTokens, Option.some.injEq, Prod.mk.injEq] at hcompile
      rcases hcompile with ⟨rfl, rfl, rfl⟩
      have hsame : Function.update base .remaining (encodeWord 0) = base := by
        change base .remaining = encodeWord 0 at hcount
        rw [← hcount]
        exact Function.update_eq_self _ _
      simp [tokensSteps, tokenBits, tokenWords, gateRecords, recordsBits, recordsWords,
        encodeWords, hsame, outputTapes]
  | cons token tokens ih =>
      cases htake : token.takeGate roots with
      | none => simp [compileTokens, htake] at hcompile
      | some result =>
          rcases result with ⟨gate, rest⟩
          cases htail : compileTokens (current + 1) (current :: rest) tokens with
          | none => simp [compileTokens, htake, htail] at hcompile
          | some result =>
              rcases result with ⟨next', finalRoots', gates'⟩
              simp [compileTokens, htake, htail] at hcompile
              obtain ⟨hnext, hroots, hgates⟩ := hcompile
              subst next
              subst finalRoots
              subst gates
              let decremented := Function.update base .remaining (encodeWord tokens.length)
              let following := outputTapes decremented (gateRecord current gate).bits.reverse
              have hg := guardPositiveTrace
                (boundaryTapes base current roots (tokenBits (token :: tokens) ++ suffix))
                tokens.length (by simpa [boundaryTapes] using hcount)
              rw [boundary_remaining] at hg
              have ht := tokenTrace decremented current token roots rest gate
                (tokenBits tokens ++ suffix) htake
              have hi := ih following (current + 1) (current :: rest)
                next' finalRoots' gates' htail
                (by simp [following, decremented, outputTapes])
              have hg' : advance^[1]
                  (some ⟨some .guard, initialState,
                    boundaryTapes base current roots (tokenBits (token :: tokens) ++ suffix)⟩) =
                  some ⟨some .decode, initialState,
                    boundaryTapes decremented current roots (token.bits ++ (tokenBits tokens ++ suffix))⟩ := by
                simpa only [tokenBits_cons, List.append_assoc] using hg
              have total := trace_trans _ (trace_trans _ hg' ht) hi
              have frame :
                  outputTapes (Function.update following .remaining (encodeWord 0))
                    (recordsBits (gateRecords (current + 1) gates')).reverse =
                  outputTapes (Function.update base .remaining (encodeWord 0))
                    (recordsBits (gateRecords current (gate :: gates'))).reverse := by
                funext tape
                cases tape <;>
                  simp [following, decremented, outputTapes, gateRecords, recordsBits_cons,
                    List.reverse_append, List.append_assoc]
              rw [frame] at total
              simpa only [tokensSteps, htake] using total

def initialTapes (base : Tape → List Bool) (roots : List Nat)
    (input : List Bool) : Tape → List Bool
  | .input => input
  | .roots => encodeWords roots
  | .current | .remaining | .left | .right | .scratch => []
  | tape => base tape

theorem headersTrace (base : Tape → List Bool) (roots : List Nat)
    (start count : Nat) (suffix : List Bool) :
    advance^[start + count + 4]
      (some ⟨some (.headerStart 0), initialState,
        initialTapes base roots (encodeWords [start, count] ++ suffix)⟩) =
      some ⟨some .guard, initialState,
        boundaryTapes (Function.update base .remaining (encodeWord count)) start roots suffix⟩ := by
  let first := initialTapes base roots (encodeWords [start, count] ++ suffix)
  let second := Function.update
    (Function.update first .input (encodeWord count ++ suffix)) .current (encodeWord start)
  have h1 := (SourceMachine.fieldInTime Tape.input Tape.current (by decide)
    (.headerStart 0) (.headerLoop 0) (some (.headerStart 1)) program rfl rfl
    first start (encodeWord count ++ suffix)
    (by simp [first, initialTapes, encodeWords, List.append_assoc]) () none).evals_in_steps
  have frame1 : SourceMachine.fieldTapes Tape.input Tape.current first
      (encodeWord count ++ suffix) (encodeWord start ++ first .current) = second := by
    simp [SourceMachine.fieldTapes, first, initialTapes, second]
  change advance^[start + 2]
    (some ⟨some (.headerStart 0), initialState, first⟩) =
    some ⟨some (.headerStart 1), initialState,
      SourceMachine.fieldTapes Tape.input Tape.current first
        (encodeWord count ++ suffix) (encodeWord start ++ first .current)⟩ at h1
  rw [frame1] at h1
  have h2 := (SourceMachine.fieldInTime Tape.input Tape.remaining (by decide)
    (.headerStart 1) (.headerLoop 1) (some .guard) program rfl rfl
    second count suffix (by simp [second]) () none).evals_in_steps
  have frame2 : SourceMachine.fieldTapes Tape.input Tape.remaining second suffix
      (encodeWord count ++ second .remaining) =
      boundaryTapes (Function.update base .remaining (encodeWord count)) start roots suffix := by
    funext tape
    cases tape <;> simp [SourceMachine.fieldTapes, second, first, initialTapes, boundaryTapes]
  change advance^[count + 2]
    (some ⟨some (.headerStart 1), initialState, second⟩) =
    some ⟨some .guard, initialState,
      SourceMachine.fieldTapes Tape.input Tape.remaining second suffix
        (encodeWord count ++ second .remaining)⟩ at h2
  rw [frame2] at h2
  have total := trace_trans _ h1 h2
  simpa only [show (start + 2) + (count + 2) = start + count + 4 by omega] using total

def reversedTapes (base : Tape → List Bool) (bits : List Bool) : Tape → List Bool :=
  Function.update (Function.update (Function.update base .remaining []) .reversed [])
    .output (bits ++ base .output)

theorem reverseTrace (base : Tape → List Bool) (bits : List Bool)
    (hzero : base .remaining = encodeWord 0) (hbits : base .reversed = bits.reverse) :
    advance^[bits.length + 3] (some ⟨some .guard, initialState, base⟩) =
      some ⟨none, initialState, reversedTapes base bits⟩ := by
  have hguard : advance^[1] (some ⟨some .guard, initialState, base⟩) =
      some ⟨some .finish, initialState, base⟩ := by
    change some (TM2.stepAux (program .guard) initialState base) = _
    simp [program, MachineUnaryCounter.guard, TM2.stepAux, hzero, encodeWord, initialState]
  let cleared := Function.update base .remaining []
  have hclear : advance^[1] (some ⟨some .finish, initialState, base⟩) =
      some ⟨some .finalReverse, initialState, cleared⟩ := by
    change some (TM2.stepAux (program .finish) initialState base) = _
    simp [program, TM2.stepAux, hzero, encodeWord, cleared, initialState]
  have htransfer := (Reduction.MachineTransfer.transferAtInTime
    Tape.reversed Tape.output (by decide) id false .finalReverse none program rfl
    cleared () none).evals_in_steps
  change advance^[(cleared .reversed).length + 1]
    (some ⟨some .finalReverse, initialState, cleared⟩) =
    some ⟨none, initialState,
      Reduction.MachineTransfer.tapesAt .reversed .output cleared []
        ((cleared .reversed).reverse.map id ++ cleared .output)⟩ at htransfer
  have hlength : (cleared .reversed).length = bits.length := by
    simp [cleared, hbits]
  have frame : Reduction.MachineTransfer.tapesAt Tape.reversed Tape.output cleared []
      ((cleared .reversed).reverse.map id ++ cleared .output) = reversedTapes base bits := by
    simp [Reduction.MachineTransfer.tapesAt, cleared, reversedTapes, hbits]
  rw [hlength, frame] at htransfer
  have total := trace_trans _ (trace_trans _ hguard hclear) htransfer
  simpa only [show 1 + 1 + (bits.length + 1) = bits.length + 3 by omega] using total

def finalTapes (base : Tape → List Bool) (next : Nat) (roots : List Nat)
    (suffix output : List Bool) : Tape → List Bool
  | .input => suffix
  | .current => encodeWord next
  | .roots => encodeWords roots
  | .output => output ++ base .output
  | _ => []

theorem compileTrace (tokens : List Token) (base : Tape → List Bool) (start : Nat)
    (roots : List Nat) (next : Nat) (finalRoots : List Nat) (gates : List Gate)
    (suffix : List Bool)
    (hcompile : compileTokens start roots tokens = some (next, finalRoots, gates)) :
    advance^[start + tokens.length + 4 + tokensSteps start roots tokens +
      (base .reversed).length + (recordsBits (gateRecords start gates)).length + 3]
      (some ⟨some (.headerStart 0), initialState,
        initialTapes base roots (inputBits start tokens ++ suffix)⟩) =
      some ⟨none, initialState, finalTapes base next finalRoots suffix
        ((base .reversed).reverse ++ recordsBits (gateRecords start gates))⟩ := by
  let headerBase := Function.update base .remaining (encodeWord tokens.length)
  let finished := boundaryTapes
    (outputTapes (Function.update headerBase .remaining (encodeWord 0))
      (recordsBits (gateRecords start gates)).reverse) next finalRoots suffix
  let emitted := (base .reversed).reverse ++ recordsBits (gateRecords start gates)
  have hh := headersTrace base roots start tokens.length (tokenBits tokens ++ suffix)
  have ht := tokensTrace tokens headerBase start roots next finalRoots gates suffix hcompile
    (by simp [headerBase])
  have hr := reverseTrace finished emitted
    (by simp [finished, boundaryTapes, outputTapes])
    (by simp [finished, emitted, boundaryTapes, outputTapes, headerBase, List.reverse_append])
  have total := trace_trans _ (trace_trans _ hh ht) hr
  have frame : reversedTapes finished emitted = finalTapes base next finalRoots suffix emitted := by
    funext tape
    cases tape <;> simp [reversedTapes, finished, finalTapes, boundaryTapes, outputTapes, headerBase]
  rw [frame] at total
  simpa only [inputBits, List.append_assoc, emitted, List.length_append, List.length_reverse,
    Nat.add_assoc] using total

def compileInTime (tokens : List Token) (base : Tape → List Bool) (start : Nat)
    (roots : List Nat) (next : Nat) (finalRoots : List Nat) (gates : List Gate)
    (suffix : List Bool)
    (hcompile : compileTokens start roots tokens = some (next, finalRoots, gates)) :
    StateTransition.EvalsToInTime (TM2.step program)
      ⟨some (.headerStart 0), initialState, initialTapes base roots (inputBits start tokens ++ suffix)⟩
      (some ⟨none, initialState, finalTapes base next finalRoots suffix
        ((base .reversed).reverse ++ recordsBits (gateRecords start gates))⟩)
      (start + tokens.length + 4 + tokensSteps start roots tokens +
        (base .reversed).length + (recordsBits (gateRecords start gates)).length + 3) where
  steps := start + tokens.length + 4 + tokensSteps start roots tokens +
    (base .reversed).length + (recordsBits (gateRecords start gates)).length + 3
  evals_in_steps := compileTrace tokens base start roots next finalRoots gates suffix hcompile
  steps_le_m := Nat.le_refl _

end BinPackingGames.Foundations.Complexity.CookLevin.PostfixMachine

namespace BinPackingGames.Foundations.Complexity.CookLevin.PostfixBounds

open StatementCircuit CircuitBatch PostfixModel PostfixMachine PostfixAlignment
open CircuitProducerModel

def RootsBounded (R : Nat) (roots : List Nat) : Prop := ∀ r ∈ roots, r ≤ R

def TokenBounded (R : Nat) : Token → Prop
  | .input wire => wire ≤ R
  | _ => True

theorem fieldSteps_le (tag : Fin 6) (slot : Fin 3) (value R : Nat) (h : value ≤ R) :
    fieldSteps tag slot value ≤ 2 * R + 3 := by
  unfold fieldSteps
  split <;> omega

theorem recordSteps_le (tag : Fin 6) (values : Fin 3 → Nat) (R : Nat)
    (h : ∀ slot, values slot ≤ R) : recordSteps tag values ≤ 6 * R + 10 := by
  have h0 := fieldSteps_le tag 0 (values 0) R (h 0)
  have h1 := fieldSteps_le tag 1 (values 1) R (h 1)
  have h2 := fieldSteps_le tag 2 (values 2) R (h 2)
  unfold recordSteps
  omega

theorem gateRecord_slot_le (current R : Nat) (gate : Gate) (hq : current ≤ R)
    (hg : gate.Bounded (R + 1)) (slot : Fin 3) :
    (gateRecord current gate).slot slot ≤ R := by
  cases gate with
  | const b => cases b <;> fin_cases slot <;> simp [gateRecord, Record.slot] <;> omega
  | not a => fin_cases slot <;> simp [gateRecord, Record.slot] <;> simp [Gate.Bounded] at hg <;> omega
  | and a b => fin_cases slot <;> simp [gateRecord, Record.slot] <;> simp [Gate.Bounded] at hg <;> omega
  | or a b => fin_cases slot <;> simp [gateRecord, Record.slot] <;> simp [Gate.Bounded] at hg <;> omega

theorem operandSteps_le (token : Token) (gate : Gate) (R : Nat)
    (ht : TokenBounded R token) (hg : gate.Bounded (R + 1)) :
    operandSteps token gate ≤ 2 * R + 4 := by
  cases token <;> cases gate <;>
    simp_all [operandSteps, TokenBounded, Gate.Bounded] <;> omega

theorem operandFields_length_le (token : Token) (gate : Gate) (R : Nat)
    (ht : TokenBounded R token) (hg : gate.Bounded (R + 1)) :
    (operandFields token gate).1.length + (operandFields token gate).2.length ≤ 2 * R + 2 := by
  cases token <;> cases gate <;>
    simp_all [operandFields, TokenBounded, Gate.Bounded] <;> omega

theorem tokenSteps_le (current R : Nat) (token : Token) (gate : Gate)
    (hq : current ≤ R) (ht : TokenBounded R token) (hg : gate.Bounded (R + 1)) :
    tokenSteps current token gate ≤ 12 * R + 24 := by
  have ho := operandSteps_le token gate R ht hg
  have hf := operandFields_length_le token gate R ht hg
  have hr := recordSteps_le token.tag (gateRecord current gate).slot R
    (gateRecord_slot_le current R gate hq hg)
  unfold tokenSteps
  omega

theorem takeGate_bounds (token : Token) (roots : List Nat) (gate : Gate) (rest : List Nat)
    (R : Nat) (ht : TokenBounded R token) (hr : RootsBounded R roots)
    (htake : token.takeGate roots = some (gate, rest)) :
    gate.Bounded (R + 1) ∧ RootsBounded R rest := by
  cases token with
  | const b =>
    simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
    rcases htake with ⟨rfl, rfl⟩
    exact ⟨trivial, hr⟩
  | input wire =>
    simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
    rcases htake with ⟨rfl, rfl⟩
    exact ⟨⟨by change wire ≤ R at ht; omega, by change wire ≤ R at ht; omega⟩, hr⟩
  | not =>
    cases roots with
    | nil => simp [Token.takeGate] at htake
    | cons a roots =>
      simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
      rcases htake with ⟨rfl, rfl⟩
      have ha := hr a (by simp)
      exact ⟨by change a < R + 1; omega, fun r h => hr r (by simp [h])⟩
  | and =>
    cases roots with
    | nil => simp [Token.takeGate] at htake
    | cons right roots =>
      cases roots with
      | nil => simp [Token.takeGate] at htake
      | cons left roots =>
        simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
        rcases htake with ⟨rfl, rfl⟩
        have hl := hr left (by simp)
        have hr' := hr right (by simp)
        exact ⟨⟨by omega, by omega⟩, fun r h => hr r (by simp [h])⟩
  | or =>
    cases roots with
    | nil => simp [Token.takeGate] at htake
    | cons right roots =>
      cases roots with
      | nil => simp [Token.takeGate] at htake
      | cons left roots =>
        simp only [Token.takeGate, Option.some.injEq, Prod.mk.injEq] at htake
        rcases htake with ⟨rfl, rfl⟩
        have hl := hr left (by simp)
        have hr' := hr right (by simp)
        exact ⟨⟨by omega, by omega⟩, fun r h => hr r (by simp [h])⟩

theorem tokensSteps_le (tokens : List Token) (current : Nat) (roots : List Nat) (R : Nat)
    (hq : current + tokens.length ≤ R) (hr : RootsBounded R roots)
    (ht : ∀ token ∈ tokens, TokenBounded R token) :
    tokensSteps current roots tokens ≤ tokens.length * (12 * R + 25) := by
  induction tokens generalizing current roots with
  | nil => simp [tokensSteps]
  | cons token tokens ih =>
    cases htake : token.takeGate roots with
    | none => simp [tokensSteps, htake]
    | some pair =>
      rcases pair with ⟨gate, rest⟩
      have hc : current ≤ R := by simp only [List.length_cons] at hq; omega
      have hb := takeGate_bounds token roots gate rest R (ht token (by simp)) hr htake
      have hs := tokenSteps_le current R token gate hc (ht token (by simp)) hb.1
      have hroots : RootsBounded R (current :: rest) := by
        intro r h
        rcases List.mem_cons.mp h with rfl | h
        · exact hc
        · exact hb.2 r h
      have hi := ih (current + 1) (current :: rest) (by
        simp only [List.length_cons] at hq
        omega) hroots (fun t h => ht t (by simp [h]))
      simp only [tokensSteps, htake, List.length_cons]
      calc
        _ ≤ (1 + (12 * R + 24)) + tokens.length * (12 * R + 25) :=
          Nat.add_le_add (Nat.add_le_add_left hs 1) hi
        _ = _ := by ring

theorem exprTokens_bounded {ι : Type*} (wire : ι → Nat) (e : Expr ι) (R : Nat)
    (hw : ∀ i, wire i ≤ R) : ∀ token ∈ exprTokens wire e, TokenBounded R token := by
  induction e with
  | input i => simp [exprTokens, TokenBounded, hw]
  | const b => simp [exprTokens, TokenBounded]
  | not e ih =>
    intro token ht
    simp only [exprTokens, List.mem_append, List.mem_singleton] at ht
    rcases ht with ht | rfl
    · exact ih token ht
    · trivial
  | and e f ihe ihf =>
    intro token ht
    simp only [exprTokens, List.mem_append, List.mem_singleton, or_assoc] at ht
    rcases ht with ht | ht | rfl
    · exact ihe token ht
    · exact ihf token ht
    · trivial
  | or e f ihe ihf =>
    intro token ht
    simp only [exprTokens, List.mem_append, List.mem_singleton, or_assoc] at ht
    rcases ht with ht | ht | rfl
    · exact ihe token ht
    · exact ihf token ht
    · trivial

theorem forestTokens_bounded {ι : Type*} (wire : ι → Nat) (es : List (Expr ι)) (R : Nat)
    (hw : ∀ i, wire i ≤ R) : ∀ token ∈ forestTokens wire es, TokenBounded R token := by
  intro token ht
  obtain ⟨e, _, he⟩ := List.mem_flatMap.mp ht
  exact exprTokens_bounded wire e R hw token he

theorem forest_tokensSteps_le {ι : Type*} (wire : ι → Nat) (es : List (Expr ι))
    (start : Nat) (roots : List Nat) (hw : ∀ i, wire i < start)
    (hr : RootsBounded (start + Batch.cost es) roots) :
    tokensSteps start roots (forestTokens wire es) ≤
      Batch.cost es * (12 * (start + Batch.cost es) + 25) := by
  have h := tokensSteps_le (forestTokens wire es) start roots (start + Batch.cost es)
    (by simpa only [forestTokens_length] using Nat.le_refl (start + Batch.cost es)) hr
    (forestTokens_bounded wire es _ (fun i => by have := hw i; omega))
  simpa only [forestTokens_length] using h

theorem forest_recordsBits_length_le {ι : Type*} (wire : ι → Nat) (es : List (Expr ι))
    (start : Nat) (hw : ∀ i, wire i < start) :
    (recordsBits (gateRecords start (Batch.gates wire start es))).length ≤
      4 * Batch.cost es * (start + Batch.cost es + 5) := by
  have h := encodeWords_length_le
    (recordsWords (gateRecords start (Batch.gates wire start es)))
    (start + (Batch.gates wire start es).length + 4)
    (gateRecords_fields_le start _ (Batch.gates_ordered wire start es hw))
  simpa only [recordsBits, recordsWords_length, gateRecords_length, Batch.gates_length,
    Nat.add_assoc] using h

theorem forest_phases_le {ι : Type*} (wire : ι → Nat) (es : List (Expr ι))
    (start : Nat) (roots : List Nat) (hw : ∀ i, wire i < start)
    (hr : RootsBounded (start + Batch.cost es) roots) :
    start + (forestTokens wire es).length + 4 +
        tokensSteps start roots (forestTokens wire es) +
        (recordsBits (gateRecords start (Batch.gates wire start es))).length + 3 ≤
      start + Batch.cost es + 7 + Batch.cost es * (16 * (start + Batch.cost es) + 45) := by
  have ht := forest_tokensSteps_le wire es start roots hw hr
  have hg := forest_recordsBits_length_le wire es start hw
  rw [forestTokens_length]
  calc
    _ ≤ start + Batch.cost es + 4 +
        (Batch.cost es * (12 * (start + Batch.cost es) + 25)) +
        (4 * Batch.cost es * (start + Batch.cost es + 5)) + 3 := by omega
    _ = _ := by ring

theorem forest_header_le_input_length {ι : Type*} (wire : ι → Nat) (es : List (Expr ι))
    (start : Nat) :
    start + Batch.cost es + 2 ≤ (PostfixModel.inputBits start (forestTokens wire es)).length := by
  rw [forest_inputBits, List.length_append]
  simp only [encodeWords, List.length_append, encodeWord_length, List.length_nil]
  omega

theorem forest_phases_le_input_quadratic {ι : Type*} (wire : ι → Nat) (es : List (Expr ι))
    (start : Nat) (roots : List Nat) (hw : ∀ i, wire i < start)
    (hr : RootsBounded (start + Batch.cost es) roots) :
    let m := (PostfixModel.inputBits start (forestTokens wire es)).length
    start + (forestTokens wire es).length + 4 +
        tokensSteps start roots (forestTokens wire es) +
        (recordsBits (gateRecords start (Batch.gates wire start es))).length + 3 ≤
      m + 7 + m * (16 * m + 45) := by
  dsimp only
  have hm := forest_header_le_input_length wire es start
  apply (forest_phases_le wire es start roots hw hr).trans
  apply Nat.add_le_add
  · omega
  · apply Nat.mul_le_mul
    · omega
    · omega

end BinPackingGames.Foundations.Complexity.CookLevin.PostfixBounds

end OAI