lean/OAI/Computability/BinPacking/Machines/GraphPackingJobEdge.lean

import OAI.Computability.BinPacking.Machines.GraphPackingJobCleanup

namespace OAI

noncomputable section

namespace BinPackingGap.GraphPackingProgram

open BinPackingGames.Foundations.Complexity
open FiniteTapeProgram PackingMachineBlocks BinaryRegisterProgram
open GraphPackingRegisters PackingRegisterFrame

variable (fixed : InventoryData) (K : Nat)

def endpointResultValues (right : Bool) (vals : Register fixed K → Nat) (v : Nat) :
    Register fixed K → Nat := by
  classical
  exact Function.update
    (Function.update vals (endpointRegisters fixed K right 0) v)
    (endpointRegisters fixed K right 2) (3 ^ (v + 1))

def endpointResultTapes (right : Bool) (base : Tape fixed K → List Bool)
    (vals : Register fixed K → Nat) (v : Nat) (suffix : List Bool) :
    Tape fixed K → List Bool :=
  registerTapes (slots fixed K) (Function.update base (.inr .endpoints) suffix)
    (endpointResultValues fixed K right vals v)

private theorem endpoint_frame_extra (base : Tape fixed K → List Bool)
    (vals : Register fixed K → Nat) (e : Extra) :
    registerTapes (slots fixed K) base vals (.inr e) = base (.inr e) := by
  apply registerTapes_other
  rintro ⟨i, hi⟩
  cases hi

private theorem endpoint_extra_outside (e : Extra) (i : Register fixed K ⊕ Fin 6) :
    slots fixed K i ≠ Sum.inr e := by
  simp [slots, PackingMachineLayout.registers]

theorem endpoint_exec (right : Bool) (base : Tape fixed K → List Bool)
    (vals : Register fixed K → Nat) (v : Nat) (suffix : List Bool)
    (sourceWord : base (.inr .endpoints) = BinaryEncoding.natBits v ++ suffix)
    (decodeScratch : base (.inr .decodeScratch) = [])
    (powerCounter : base (.inr .powerCounter) = [])
    (initialRegisters : ∀ i : Fin 7,
      vals (endpointRegisters fixed K right i) = PackingEndpointPower.values 0 0 i)
    (state : State) :
    ∃ steps ≤ 2 * v.size + 4 + PackingEndpointPower.timePolynomial.eval v,
      Exec (endpoint fixed K right)
        ⟨state, registerTapes (slots fixed K) base vals⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          endpointResultTapes fixed K right base vals v suffix⟩ := by
  classical
  let start := registerTapes (slots fixed K) base vals
  let afterBase := Function.update base (.inr .endpoints) suffix
  let afterVals := Function.update vals (endpointRegisters fixed K right 0) v
  let decoded := registerTapes (slots fixed K) afterBase afterVals
  have selectedZero : vals (endpointRegisters fixed K right 0) = 0 := by
    simpa [PackingEndpointPower.values] using initialRegisters 0
  have source : start (decoderSlots fixed K right 0) =
      BinaryEncoding.natBits v ++ suffix := by
    change registerTapes (slots fixed K) base vals (.inr .endpoints) = _
    rw [endpoint_frame_extra]
    exact sourceWord
  have scratch : start (decoderSlots fixed K right 1) = [] := by
    change registerTapes (slots fixed K) base vals (.inr .decodeScratch) = []
    rw [endpoint_frame_extra]
    exact decodeScratch
  have destination : start (slots fixed K (.inl (endpointRegisters fixed K right 0))) =
      [] := by
    simp only [start, registerTapes_reg, selectedZero, Nat.zero_bits]
  have decodedFrame :
      PackingFieldDecodeMachine.decodedTapes (decoderSlots fixed K right)
        start v.bits suffix = decoded := by
    change Function.update (Function.update start (.inr .endpoints) suffix)
      (slots fixed K (.inl (endpointRegisters fixed K right 0)))
      (v.bits ++ start (slots fixed K (.inl (endpointRegisters fixed K right 0)))) = _
    rw [destination, List.append_nil]
    change Function.update
      (Function.update (registerTapes (slots fixed K) base vals) (.inr .endpoints) suffix)
      (slots fixed K (.inl (endpointRegisters fixed K right 0))) v.bits = _
    rw [← external_update (slots fixed K) base vals (.inr .endpoints)
      (endpoint_extra_outside fixed K .endpoints) suffix]
    exact registerTapes_update (slots fixed K) afterBase vals
      (endpointRegisters fixed K right 0) v
  have decodedRun := PackingFieldDecodeMachine.decodeNat_exec
    (decoderSlots fixed K right) start () v suffix source scratch
  rw [decodedFrame] at decodedRun
  have first := PackingArithmeticProgram.exec
    (PackingFieldDecodeMachine.code (decoderSlots fixed K right)) start decoded
    (2 * v.size + 2) state decodedRun
  have afterRegisters : ∀ i : Fin 7,
      afterVals (endpointRegisters fixed K right i) = PackingEndpointPower.values v 0 i := by
    intro i
    have hi (a b : Fin 7) : endpointRegisters fixed K right a =
        endpointRegisters fixed K right b ↔ a = b :=
      (endpointRegisters fixed K right).injective.eq_iff
    fin_cases i <;>
      simp [afterVals, hi, initialRegisters, PackingEndpointPower.values]
  have ready : PackingEndpointPower.Ready (endpointSlots fixed K right)
      (.inr .powerCounter) decoded v := by
    constructor
    · intro i
      change registerTapes (slots fixed K) afterBase afterVals
        (slots fixed K (.inl (endpointRegisters fixed K right i))) = _
      rw [registerTapes_reg, afterRegisters]
    · intro j
      change registerTapes (slots fixed K) afterBase afterVals (slots fixed K (.inr j)) = []
      exact registerTapes_scratch (slots fixed K) afterBase afterVals j
    · change registerTapes (slots fixed K) afterBase afterVals (.inr .powerCounter) = []
      rw [endpoint_frame_extra]
      simpa [afterBase] using powerCounter
  obtain ⟨powerSteps, powerBound, second⟩ := PackingEndpointPower.exec
    (endpointSlots fixed K right) (.inr .powerCounter)
    (endpoint_outside fixed K right .powerCounter) decoded v ready
    (.arithmetic (BinaryAddMachine.clean ()))
  have finalFrame : PackingEndpointPower.resultTapes (endpointSlots fixed K right) decoded v =
      endpointResultTapes fixed K right base vals v suffix := by
    change Function.update (registerTapes (slots fixed K) afterBase afterVals)
      (slots fixed K (.inl (endpointRegisters fixed K right 2))) (3 ^ (v + 1)).bits = _
    exact registerTapes_update (slots fixed K) afterBase afterVals
      (endpointRegisters fixed K right 2) (3 ^ (v + 1))
  rw [finalFrame] at second
  have phases := PhaseRuns.cons first (PhaseRuns.single second)
  refine ⟨(1 + (2 * v.size + 2)) + powerSteps + 1, by omega, ?_⟩
  simpa only [endpoint] using phases.toExec

def endpointTimePolynomial : Polynomial Nat :=
  PackingEndpointPower.timePolynomial + Polynomial.X + Polynomial.C 3

theorem endpoint_exec_polynomial (right : Bool) (base : Tape fixed K → List Bool)
    (vals : Register fixed K → Nat) (v : Nat) (suffix : List Bool)
    (sourceWord : base (.inr .endpoints) = BinaryEncoding.natBits v ++ suffix)
    (decodeScratch : base (.inr .decodeScratch) = [])
    (powerCounter : base (.inr .powerCounter) = [])
    (initialRegisters : ∀ i : Fin 7,
      vals (endpointRegisters fixed K right i) = PackingEndpointPower.values 0 0 i)
    (state : State) :
    ∃ steps ≤ endpointTimePolynomial.eval (v + (BinaryEncoding.natBits v).length),
      Exec (endpoint fixed K right)
        ⟨state, registerTapes (slots fixed K) base vals⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          endpointResultTapes fixed K right base vals v suffix⟩ := by
  obtain ⟨steps, bound, run⟩ := endpoint_exec fixed K right base vals v suffix
    sourceWord decodeScratch powerCounter initialRegisters state
  refine ⟨steps, bound.trans ?_, run⟩
  have monotone := MachineComposition.natPolynomial_eval_mono
    PackingEndpointPower.timePolynomial
    (Nat.le_add_right v (BinaryEncoding.natBits v).length)
  have fieldLength := BinaryEncoding.natBits_length v
  simp only [endpointTimePolynomial, Polynomial.eval_add, Polynomial.eval_X,
    Polynomial.eval_C]
  omega

theorem endpoint_layout_exec (right : Bool) (base : Tape fixed K → List Bool)
    (input : PackingItemExpression.Variable → Nat) (other : Other fixed K → Nat)
    (v : Nat) (suffix : List Bool)
    (sourceWord : base (.inr .endpoints) = BinaryEncoding.natBits v ++ suffix)
    (decodeScratch : base (.inr .decodeScratch) = [])
    (powerCounter : base (.inr .powerCounter) = [])
    (initialRegisters : ∀ i : Fin 7,
      PackingMachineLayout.values (Numerator fixed) PackingItemExpression.denominator input other
        (endpointRegisters fixed K right i) = PackingEndpointPower.values 0 0 i)
    (state : State) :
    ∃ steps ≤ endpointTimePolynomial.eval (v + (BinaryEncoding.natBits v).length),
      Exec (endpoint fixed K right)
        ⟨state, PackingMachineLayout.tapes (Numerator fixed)
          PackingItemExpression.denominator base input other⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          PackingMachineLayout.tapes (Numerator fixed) PackingItemExpression.denominator
            (Function.update base (.inr .endpoints) suffix) input
            (Function.update (Function.update other
              (.inr (if right then Work.rightEndpoint else Work.leftEndpoint)) v)
              (.inr (if right then Work.rightPower else Work.leftPower)) (3 ^ (v + 1)))⟩ := by
  classical
  have updates : endpointResultValues fixed K right
      (PackingMachineLayout.values (Numerator fixed) PackingItemExpression.denominator input other) v =
      PackingMachineLayout.values (Numerator fixed) PackingItemExpression.denominator input
        (Function.update (Function.update other
          (.inr (if right then Work.rightEndpoint else Work.leftEndpoint)) v)
          (.inr (if right then Work.rightPower else Work.leftPower)) (3 ^ (v + 1))) := by
    simp only [endpointResultValues, PackingMachineLayout.values_update_other]
    rfl
  obtain ⟨steps, bound, run⟩ := endpoint_exec_polynomial fixed K right base
    (PackingMachineLayout.values (Numerator fixed) PackingItemExpression.denominator input other)
    v suffix sourceWord decodeScratch powerCounter initialRegisters state
  refine ⟨steps, bound, ?_⟩
  unfold endpointResultTapes at run
  rw [updates] at run
  exact run

end BinPackingGap.GraphPackingProgram

namespace BinPackingGap.GraphPackingJobs

section

open FiniteTapeProgram PackingMachineBlocks BinaryRegisterProgram
open GraphPackingRegisters GraphPackingPreparation PackingItemExpression
open GraphPackingProgram (PhaseRuns)
open PackingMachineLayout (tapes values)
open PackingItemBlockMachine (outputTapes)
open PackingCountedProgram (counterTapes guardState)
open BinPackingGames.Foundations.Complexity

variable (fixed : InventoryData) (K : Nat)

def repeatPhases : List (GraphPackingProgram.Program fixed K) :=
  [GraphPackingProgram.setItem fixed K .repetitionOne 1,
    GraphPackingProgram.tally fixed K (.output .repetitions) .repetitionCounter,
    PackingJobLoop.code (Numerator fixed) denominator
      (PackingInventoryDescriptors.jobDescriptors fixed)
      .labelPower .repetitionOne (by decide)
      (.inr Work.leftPower) (.inr Work.rightPower)
      (GraphPackingProgram.otherSetup fixed K .one) (.inr Work.temporary)
      (by simp [GraphPackingProgram.otherSetup]) .reverseOutput .repetitionCounter]

def repeatSetPolynomial : Polynomial Nat :=
  PackingLayoutCommands.setInputTime (Other := Other fixed K)
    (Numerator fixed) denominator .repetitionOne 1

def repeatLoopPolynomial : Polynomial Nat :=
  PackingJobLoop.timePolynomial (Numerator fixed) denominator
    (PackingInventoryDescriptors.jobDescriptors fixed) .labelPower
    (.inr Work.leftPower : Other fixed K) (.inr Work.rightPower)

def repeatWidthPolynomial : Polynomial Nat :=
  repeatSetPolynomial fixed K + 40 * (Polynomial.X + 1) ^ 3 + 1 +
    (repeatLoopPolynomial fixed K).comp (3 * Polynomial.X + 2)

def repeatTimePolynomial : Polynomial Nat :=
  (repeatWidthPolynomial fixed K).comp (GraphPackingWidths.polynomial fixed K)

theorem repeatTimePolynomial_eval (x : GraphReductionInput) :
    (repeatTimePolynomial fixed K).eval (graphBits x).length =
      (repeatSetPolynomial fixed K).eval (GraphPackingWidths.width fixed K x) +
      40 * (GraphPackingWidths.width fixed K x + 1) ^ 3 + 1 +
      (repeatLoopPolynomial fixed K).eval (3 * GraphPackingWidths.width fixed K x + 2) := by
  simp [repeatTimePolynomial, repeatWidthPolynomial, GraphPackingWidths.width]

private theorem repeat_tally_bound (n width : Nat) (hn : n ≤ width) :
    BinaryToTallyMachine.runtimeBound n ≤ 40 * (width + 1) ^ 3 := by
  have hs : n.size ≤ width := (nat_size_le_self n).trans hn
  calc
    BinaryToTallyMachine.runtimeBound n = 40 * (n + 1) * (n.size + 1) ^ 2 := rfl
    _ ≤ 40 * (width + 1) * (width + 1) ^ 2 :=
      Nat.mul_le_mul (Nat.mul_le_mul_left 40 (Nat.add_le_add_right hn 1))
        (Nat.pow_le_pow_left (Nat.add_le_add_right hs 1) 2)
    _ = 40 * (width + 1) ^ 3 := by ring

theorem repeat_exec (x : GraphReductionInput) (edge : x.graph.Edge)
    (base : Tape fixed K → List Bool) (state : State)
    (counterEmpty : base (.inr .repetitionCounter) = []) :
    ∃ steps ≤ (repeatTimePolynomial fixed K).eval (graphBits x).length,
      PhaseRuns (repeatPhases fixed K)
        ⟨state, tapes (Numerator fixed) denominator base (inputs fixed K x edge.val)
          (loadedOther fixed K x (x.graph.left edge).val (x.graph.right edge).val)⟩ steps
        ⟨guardState none, tapes (Numerator fixed) denominator
          (outputTapes (.inr .reverseOutput) base (edgeWord fixed K x edge))
          (repeatFinalInputs fixed K x edge)
          (loadedOther fixed K x (x.graph.left edge).val (x.graph.right edge).val)⟩ := by
  let width := GraphPackingWidths.width fixed K x
  let count := GraphPackingPreparation.repetitions fixed K x
  let other := loadedOther fixed K x (x.graph.left edge).val (x.graph.right edge).val
  let input := repeatInputs fixed K x edge.val
  let vals := values (Numerator fixed) denominator input other
  have inputWidth : ∀ a, (input a).size ≤ width :=
    repeatInputs_width fixed K x edge.val (Nat.le_of_lt edge.isLt)
  have otherWidth : ∀ r, (other r).size ≤ width :=
    loadedOther_width fixed K x _ _ (x.graph.left edge).isLt (x.graph.right edge).isLt
  have initialWidth : ∀ a, (inputs fixed K x edge.val a).size ≤ width :=
    inputs_width fixed K x edge.val (Nat.le_of_lt edge.isLt)
  obtain ⟨setSteps, setBound, setRun⟩ := PackingLayoutCommands.setInput_exec
    (Numerator fixed) denominator .repetitionOne 1 base (inputs fixed K x edge.val)
    other state width initialWidth otherWidth
  have sourceValue : vals (countRegister fixed K (.output .repetitions)) = count :=
    loaded_repetitions fixed K x _ _
  have counterZero : vals (work fixed K .counter) = 0 :=
    loaded_helper_zero fixed K x _ _ .counter (Or.inl rfl)
  have oneZero : vals (work fixed K .one) = 0 :=
    loaded_helper_zero fixed K x _ _ .one (Or.inr (Or.inl rfl))
  have temporaryZero : vals (work fixed K .temporary) = 0 :=
    loaded_helper_zero fixed K x _ _ .temporary (Or.inr (Or.inr (Or.inl rfl)))
  obtain ⟨tallySteps, tallyBound, tallyRun⟩ := GraphPackingTapeBlocks.tally_exec
    fixed K (.output .repetitions) .repetitionCounter base vals
    (.arithmetic (BinaryAddMachine.clean ())) counterZero oneZero temporaryZero
  rw [sourceValue] at tallyBound
  have tallyFrame : registerTapes (slots fixed K)
      (Function.update base (.inr .repetitionCounter)
        (List.replicate count true ++ base (.inr .repetitionCounter))) vals =
      counterTapes (.inr .repetitionCounter)
        (tapes (Numerator fixed) denominator base input other) count := by
    rw [counterEmpty, List.append_nil]
    exact RegisterFrameEmission.external_update (slots fixed K) base vals
      (.inr .repetitionCounter) (GraphPackingTapeBlocks.slots_outside fixed K .repetitionCounter)
      (List.replicate count true)
  rw [sourceValue, tallyFrame] at tallyRun
  have hone : other (GraphPackingProgram.otherSetup fixed K .one) = 1 :=
    loaded_one fixed K x _ _
  have htemp : other (.inr .temporary) = 0 := temporaryZero
  obtain ⟨loopSteps, loopBound, loopRun⟩ := PackingJobLoop.exec_polynomial
    (Numerator fixed) denominator (PackingInventoryDescriptors.jobDescriptors fixed)
    .labelPower .repetitionOne (by decide)
    (.inr Work.leftPower) (.inr Work.rightPower)
    (GraphPackingProgram.otherSetup fixed K .one) (.inr Work.temporary)
    (by simp [GraphPackingProgram.otherSetup]) .reverseOutput .repetitionCounter (by decide)
    base input other hone htemp count width width inputWidth otherWidth
    (.arithmetic (BinaryAddMachine.clean ()))
  have streamEq := repeatStream_eq fixed K x edge
  have inputEq := repeatIteration_eq fixed K x edge
  change PackingJobLoop.stream (Numerator fixed) denominator
      (PackingInventoryDescriptors.jobDescriptors fixed) input .labelPower .repetitionOne
      (other (.inr Work.leftPower)) (other (.inr Work.rightPower)) count =
    edgeWord fixed K x edge at streamEq
  change PackingJobLoop.iterationInput input .labelPower .repetitionOne
      (other (.inr Work.rightPower)) count = repeatFinalInputs fixed K x edge at inputEq
  rw [streamEq, inputEq] at loopRun
  have finalCounter : (tapes (Numerator fixed) denominator
      (outputTapes (.inr Extra.reverseOutput) base (edgeWord fixed K x edge))
      (repeatFinalInputs fixed K x edge) other) (.inr .repetitionCounter) = [] := by
    simp [outputTapes, counterEmpty]
  have cleared : counterTapes (.inr Extra.repetitionCounter)
      (tapes (Numerator fixed) denominator
        (outputTapes (.inr .reverseOutput) base (edgeWord fixed K x edge))
        (repeatFinalInputs fixed K x edge) other) 0 =
      tapes (Numerator fixed) denominator
        (outputTapes (.inr .reverseOutput) base (edgeWord fixed K x edge))
        (repeatFinalInputs fixed K x edge) other := by
    simp only [counterTapes, List.replicate_zero]
    rw [← finalCounter, Function.update_eq_self]
  rw [cleared] at loopRun
  have phases : PhaseRuns (repeatPhases fixed K)
      ⟨state, tapes (Numerator fixed) denominator base (inputs fixed K x edge.val) other⟩
      (setSteps + (tallySteps + loopSteps))
      ⟨guardState none, tapes (Numerator fixed) denominator
        (outputTapes (.inr .reverseOutput) base (edgeWord fixed K x edge))
        (repeatFinalInputs fixed K x edge) other⟩ :=
    .cons setRun (.cons tallyRun (PhaseRuns.single loopRun))
  refine ⟨setSteps + (tallySteps + loopSteps), ?_, phases⟩
  have hc : count ≤ width := Nat.le_trans (Nat.le_succ count)
    (GraphPackingWidths.repetitions_width fixed K x)
  have tallyUpper := repeat_tally_bound count width hc
  have aggregate : PackingJobLoop.aggregateWidth width width count ≤ 3 * width + 2 := by
    unfold PackingJobLoop.aggregateWidth
    omega
  have loopUpper := MachineComposition.natPolynomial_eval_mono
    (repeatLoopPolynomial fixed K) aggregate
  change loopSteps ≤ (repeatLoopPolynomial fixed K).eval
    (PackingJobLoop.aggregateWidth width width count) at loopBound
  change setSteps ≤ (repeatSetPolynomial fixed K).eval width at setBound
  rw [repeatTimePolynomial_eval]
  change setSteps + (tallySteps + loopSteps) ≤
    (repeatSetPolynomial fixed K).eval width + 40 * (width + 1) ^ 3 + 1 +
      (repeatLoopPolynomial fixed K).eval (3 * width + 2)
  omega

end

section

open FiniteTapeProgram PackingMachineBlocks BinaryRegisterProgram
open GraphPackingRegisters GraphPackingPreparation PackingItemExpression
open GraphPackingProgram (PhaseRuns)
open PackingMachineLayout (tapes values)
open BinPackingGames.Foundations.Complexity

variable (fixed : InventoryData) (K : Nat)

def prefixPhases : List (GraphPackingProgram.Program fixed K) :=
  [.atom (.pop (.inr .endpoints) (fun state _ => state) .done),
    GraphPackingProgram.endpoint fixed K false,
    GraphPackingProgram.endpoint fixed K true]

def prefixTimePolynomial : Polynomial Nat :=
  1 + 2 * GraphPackingProgram.endpointTimePolynomial.comp (4 * (Polynomial.X + 1))

theorem prefixTimePolynomial_eval (s : Nat) :
    prefixTimePolynomial.eval s =
      1 + 2 * GraphPackingProgram.endpointTimePolynomial.eval (4 * (s + 1)) := by
  simp [prefixTimePolynomial]

private theorem prepared_endpoint_registers (x : GraphReductionInput)
    (input : Variable → Nat) (right : Bool) :
    ∀ i : Fin 7, values (Numerator fixed) denominator input (preparedOther fixed K x)
      (endpointRegisters fixed K right i) = PackingEndpointPower.values 0 0 i := by
  intro i
  cases right <;> fin_cases i <;> rfl

private theorem right_after_left_registers (x : GraphReductionInput)
    (input : Variable → Nat) (left : Nat) :
    ∀ i : Fin 7, values (Numerator fixed) denominator input
      (loadEndpoint fixed K (preparedOther fixed K x) false left)
      (endpointRegisters fixed K true i) = PackingEndpointPower.values 0 0 i := by
  intro i
  fin_cases i <;> rfl

private theorem endpoint_measure_le (x : GraphReductionInput) (v : x.graph.Vertex) :
    v.val + (BinaryEncoding.natBits v.val).length ≤ 4 * ((graphBits x).length + 1) := by
  have hv : v.val ≤ (graphBits x).length :=
    (Nat.le_of_lt v.isLt).trans (graph_vertexCount_le_bits x)
  have hs : v.val.size ≤ v.val := nat_size_le_self v.val
  rw [BinaryEncoding.natBits_length]
  omega

theorem prefix_exec (x : GraphReductionInput) (edge : x.graph.Edge)
    (base : Tape fixed K → List Bool) (input : Variable → Nat)
    (suffix : List Bool) (state : State)
    (sourceWord : base (.inr .endpoints) = true ::
      (BinaryEncoding.natBits (x.graph.left edge).val ++
        (BinaryEncoding.natBits (x.graph.right edge).val ++ suffix)))
    (decodeScratch : base (.inr .decodeScratch) = [])
    (powerCounter : base (.inr .powerCounter) = []) :
    ∃ steps ≤ prefixTimePolynomial.eval (graphBits x).length,
      PhaseRuns (prefixPhases fixed K)
        ⟨state, tapes (Numerator fixed) denominator base input (preparedOther fixed K x)⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator (Function.update base (.inr .endpoints) suffix)
            input (loadedOther fixed K x (x.graph.left edge).val (x.graph.right edge).val)⟩ := by
  let remainder := BinaryEncoding.natBits (x.graph.left edge).val ++
    (BinaryEncoding.natBits (x.graph.right edge).val ++ suffix)
  let afterMarker := Function.update base (.inr Extra.endpoints) remainder
  let afterLeft := Function.update base (.inr Extra.endpoints)
    (BinaryEncoding.natBits (x.graph.right edge).val ++ suffix)
  let leftOther := loadEndpoint fixed K (preparedOther fixed K x) false (x.graph.left edge).val
  have markerFrame : Function.update
      (tapes (Numerator fixed) denominator base input (preparedOther fixed K x))
      (.inr Extra.endpoints) remainder =
      tapes (Numerator fixed) denominator afterMarker input (preparedOther fixed K x) := by
    exact (RegisterFrameEmission.external_update (slots fixed K) base
      (values (Numerator fixed) denominator input (preparedOther fixed K x))
      (.inr Extra.endpoints)
      (by intro q; simp [slots, PackingMachineLayout.registers]) remainder).symm
  have markerRun : Exec
      (.atom (.pop (.inr Extra.endpoints) (fun state _ => state) .done))
      ⟨state, tapes (Numerator fixed) denominator base input (preparedOther fixed K x)⟩ 1
      ⟨state, tapes (Numerator fixed) denominator afterMarker input (preparedOther fixed K x)⟩ := by
    have actual := Exec.atom
      (Action.pop (.inr Extra.endpoints) (fun state _ => state) .done)
      ⟨state, tapes (Numerator fixed) denominator base input (preparedOther fixed K x)⟩
    simp only [Action.eval, PackingMachineLayout.tapes_extra, sourceWord,
      List.tail_cons] at actual
    change Exec _ _ 1 ⟨state, Function.update
      (tapes (Numerator fixed) denominator base input (preparedOther fixed K x))
      (.inr Extra.endpoints) remainder⟩ at actual
    rw [markerFrame] at actual
    exact actual
  have leftSource : afterMarker (.inr .endpoints) =
      BinaryEncoding.natBits (x.graph.left edge).val ++
        (BinaryEncoding.natBits (x.graph.right edge).val ++ suffix) := by simp [afterMarker, remainder]
  have leftScratch : afterMarker (.inr .decodeScratch) = [] := by
    simpa [afterMarker] using decodeScratch
  have leftCounter : afterMarker (.inr .powerCounter) = [] := by
    simpa [afterMarker] using powerCounter
  obtain ⟨leftSteps, leftBound, leftRun⟩ := GraphPackingProgram.endpoint_layout_exec fixed K
    false afterMarker input (preparedOther fixed K x) (x.graph.left edge).val
    (BinaryEncoding.natBits (x.graph.right edge).val ++ suffix)
    leftSource leftScratch leftCounter (prepared_endpoint_registers fixed K x input false) state
  have leftRun' : Exec (GraphPackingProgram.endpoint fixed K false)
      ⟨state, tapes (Numerator fixed) denominator afterMarker input (preparedOther fixed K x)⟩
      leftSteps ⟨.arithmetic (BinaryAddMachine.clean ()),
        tapes (Numerator fixed) denominator afterLeft input leftOther⟩ := by
    simpa [afterMarker, afterLeft, leftOther, loadEndpoint, endpointWork, powerWork,
      Function.update_idem] using leftRun
  have rightSource : afterLeft (.inr .endpoints) =
      BinaryEncoding.natBits (x.graph.right edge).val ++ suffix := by simp [afterLeft]
  have rightScratch : afterLeft (.inr .decodeScratch) = [] := by
    simpa [afterLeft] using decodeScratch
  have rightCounter : afterLeft (.inr .powerCounter) = [] := by
    simpa [afterLeft] using powerCounter
  obtain ⟨rightSteps, rightBound, rightRun⟩ := GraphPackingProgram.endpoint_layout_exec fixed K
    true afterLeft input leftOther (x.graph.right edge).val suffix rightSource rightScratch
    rightCounter (right_after_left_registers fixed K x input (x.graph.left edge).val)
    (.arithmetic (BinaryAddMachine.clean ()))
  have rightRun' : Exec (GraphPackingProgram.endpoint fixed K true)
      ⟨.arithmetic (BinaryAddMachine.clean ()),
        tapes (Numerator fixed) denominator afterLeft input leftOther⟩ rightSteps
      ⟨.arithmetic (BinaryAddMachine.clean ()),
        tapes (Numerator fixed) denominator (Function.update base (.inr .endpoints) suffix)
          input (loadedOther fixed K x (x.graph.left edge).val (x.graph.right edge).val)⟩ := by
    simpa [afterLeft, loadedOther, leftOther, loadEndpoint, endpointWork, powerWork,
      Function.update_idem] using rightRun
  have phases : PhaseRuns (prefixPhases fixed K)
      ⟨state, tapes (Numerator fixed) denominator base input (preparedOther fixed K x)⟩
      (1 + (leftSteps + rightSteps))
      ⟨.arithmetic (BinaryAddMachine.clean ()),
        tapes (Numerator fixed) denominator (Function.update base (.inr .endpoints) suffix)
          input (loadedOther fixed K x (x.graph.left edge).val (x.graph.right edge).val)⟩ :=
    .cons markerRun (.cons leftRun' (PhaseRuns.single rightRun'))
  refine ⟨1 + (leftSteps + rightSteps), ?_, phases⟩
  have leftUpper := MachineComposition.natPolynomial_eval_mono
    GraphPackingProgram.endpointTimePolynomial (endpoint_measure_le x (x.graph.left edge))
  have rightUpper := MachineComposition.natPolynomial_eval_mono
    GraphPackingProgram.endpointTimePolynomial (endpoint_measure_le x (x.graph.right edge))
  rw [prefixTimePolynomial_eval]
  omega

end

open FiniteTapeProgram PackingMachineBlocks GraphPackingRegisters
open GraphPackingPreparation PackingItemExpression
open GraphPackingProgram (PhaseRuns)
open PackingMachineLayout (tapes)
open PackingItemBlockMachine (outputTapes)

variable (fixed : InventoryData) (K : Nat)

def resultBase (base : Tape fixed K → List Bool) (suffix word : List Bool) :
    Tape fixed K → List Bool :=
  outputTapes (.inr .reverseOutput) (Function.update base (.inr .endpoints) suffix) word

@[simp] theorem resultBase_endpoints (base : Tape fixed K → List Bool)
    (suffix word : List Bool) : resultBase fixed K base suffix word (.inr .endpoints) = suffix := by
  simp [resultBase, outputTapes]

@[simp] theorem resultBase_other (base : Tape fixed K → List Bool)
    (suffix word : List Bool) (e : Extra) (hne : e ≠ .endpoints) (hno : e ≠ .reverseOutput) :
    resultBase fixed K base suffix word (.inr e) = base (.inr e) := by
  simp [resultBase, outputTapes, hne, hno]

theorem resultBase_append (base : Tape fixed K → List Bool)
    (firstSuffix finalSuffix firstWord secondWord : List Bool) :
    resultBase fixed K (resultBase fixed K base firstSuffix firstWord) finalSuffix secondWord =
      resultBase fixed K base finalSuffix (firstWord ++ secondWord) := by
  funext tape
  by_cases ho : tape = .inr Extra.reverseOutput
  · subst tape
    simp [resultBase, outputTapes, List.reverse_append, List.append_assoc]
  · by_cases he : tape = .inr Extra.endpoints
    · subst tape
      simp [resultBase, outputTapes]
    · simp [resultBase, outputTapes, ho, he]

theorem resultBase_counter (base : Tape fixed K → List Bool)
    (suffix word : List Bool) (count : Nat) :
    resultBase fixed K (PackingCountedProgram.counterTapes (.inr .edgeCounter) base count)
        suffix word =
      PackingCountedProgram.counterTapes (.inr .edgeCounter)
        (resultBase fixed K base suffix word) count := by
  funext tape
  by_cases hc : tape = .inr Extra.edgeCounter
  · subst tape
    simp [resultBase, outputTapes, PackingCountedProgram.counterTapes]
  · by_cases ho : tape = .inr Extra.reverseOutput
    · subst tape
      simp [resultBase, outputTapes, PackingCountedProgram.counterTapes]
    · by_cases he : tape = .inr Extra.endpoints
      · subst tape
        simp [resultBase, outputTapes, PackingCountedProgram.counterTapes]
      · simp [resultBase, outputTapes, PackingCountedProgram.counterTapes, hc, ho, he]

theorem resultBase_nil (base : Tape fixed K → List Bool)
    (empty : base (.inr .endpoints) = [false]) :
    resultBase fixed K base [false] [] = base := by
  simp only [resultBase, PackingChunkMachine.outputTapes_nil]
  rw [← empty, Function.update_eq_self]

def edgeTimePolynomial : Polynomial Nat :=
  prefixTimePolynomial + repeatTimePolynomial fixed K + cleanupTimePolynomial fixed K + 1

theorem edge_exec (x : GraphReductionInput) (e : x.graph.Edge)
    (base : Tape fixed K → List Bool) (state : State) (suffix : List Bool)
    (sourceWord : base (.inr .endpoints) = true ::
      (BinaryEncoding.natBits (x.graph.left e).val ++
        (BinaryEncoding.natBits (x.graph.right e).val ++ suffix)))
    (decodeEmpty : base (.inr .decodeScratch) = [])
    (powerEmpty : base (.inr .powerCounter) = [])
    (repeatEmpty : base (.inr .repetitionCounter) = []) :
    ∃ steps ≤ (edgeTimePolynomial fixed K).eval (graphBits x).length,
      Exec (GraphPackingProgram.edgeBody fixed K)
        ⟨state, tapes (Numerator fixed) denominator base (inputs fixed K x e.val)
          (preparedOther fixed K x)⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator
            (resultBase fixed K base suffix (edgeWord fixed K x e))
            (inputs fixed K x (e.val + 1)) (preparedOther fixed K x)⟩ := by
  let decodedBase := Function.update base (.inr Extra.endpoints) suffix
  obtain ⟨n₁, b₁, r₁⟩ := prefix_exec fixed K x e base (inputs fixed K x e.val)
    suffix state sourceWord decodeEmpty powerEmpty
  have decodedRepeatEmpty : decodedBase (.inr .repetitionCounter) = [] := by
    simpa [decodedBase] using repeatEmpty
  obtain ⟨n₂, b₂, r₂⟩ := repeat_exec fixed K x e decodedBase
    (.arithmetic (BinaryAddMachine.clean ())) decodedRepeatEmpty
  obtain ⟨n₃, b₃, r₃⟩ := cleanup_exec fixed K x e
    (outputTapes (.inr .reverseOutput) decodedBase (edgeWord fixed K x e))
    (PackingCountedProgram.guardState none)
  have runs := (r₁.append r₂).append r₃
  refine ⟨(n₁ + n₂) + n₃ + 1, ?_, ?_⟩
  · simp only [edgeTimePolynomial, Polynomial.eval_add, Polynomial.eval_one]
    omega
  · simpa only [GraphPackingProgram.edgeBody, prefixPhases, repeatPhases, cleanupPhases,
      List.cons_append, List.nil_append, decodedBase, resultBase, repeatFinalInputs]
      using runs.toExec

end BinPackingGap.GraphPackingJobs

end

end OAI