import Mathlib.Data.List.FinRange
import OAI.Computability.BinPacking.Machines.GraphPackingJobEdge
import OAI.Computability.BinPacking.Machines.GraphPackingStockStreams

namespace OAI

noncomputable section

namespace BinPackingGap.GraphPackingPoolExec

open NatExpressionCompiler BinaryRegisterProgram FiniteTapeProgram PackingMachineBlocks
open PackingMachineLayout PackingItemExpression PackingInventoryDescriptors
open PackingItemBlockMachine (outputTapes)
open PackingCountedProgram (counterTapes)

section Layout

variable {δ α β ε : Type} [DecidableEq δ] [DecidableEq α]
variable [DecidableEq β] [DecidableEq ε]

theorem layout_external_update (num : δ → Expr α) (den : Expr α)
    (base : Tape num den β ε → List Bool) (input : α → Nat) (other : β → Nat)
    (external : ε) (word : List Bool) :
    tapes num den (Function.update base (.inr external) word) input other =
      Function.update (tapes num den base input other) (.inr external) word := by
  apply RegisterFrameEmission.external_update
  intro i
  simp [registers]

theorem layout_output (num : δ → Expr α) (den : Expr α)
    (base : Tape num den β ε → List Bool) (input : α → Nat) (other : β → Nat)
    (output : ε) (word : List Bool) :
    outputTapes (.inr output) (tapes num den base input other) word =
      tapes num den (outputTapes (.inr output) base word) input other := by
  unfold outputTapes
  rw [tapes_extra, layout_external_update]

theorem layout_counter (num : δ → Expr α) (den : Expr α)
    (base : Tape num den β ε → List Bool) (input : α → Nat) (other : β → Nat)
    (counter : ε) (n : Nat) :
    counterTapes (.inr counter) (tapes num den base input other) n =
      tapes num den (counterTapes (.inr counter) base n) input other := by
  exact (layout_external_update num den base input other counter
    (List.replicate n true)).symm

end Layout

open GraphPackingRegisters

variable (fixed : InventoryData) (K : Nat)

def poolWord (stock : PackingSetupExpression.Output) (descriptor : ItemDescriptor fixed)
    (input : Variable → Nat) (other : Other fixed K → Nat) : List Bool :=
  PackingConstantPool.repeatRecords
    (PackingChunkMachine.records (Numerator fixed) denominator (fun _ => input) [descriptor])
    (other (GraphPackingProgram.otherSetup fixed K stock))

def poolBudget (stock : PackingSetupExpression.Output) (descriptor : ItemDescriptor fixed)
    (other : Other fixed K → Nat) (width : Nat) : Nat :=
  let n := other (GraphPackingProgram.otherSetup fixed K stock)
  BinaryToTallyMachine.runtimeBound n +
    n * ((PackingChunkMachine.timePolynomial (Numerator fixed) denominator [descriptor]).eval width + 2) + 3

theorem pool_exec (stock : PackingSetupExpression.Output) (descriptor : ItemDescriptor fixed)
    (base : GraphPackingRegisters.Tape fixed K → List Bool)
    (input : Variable → Nat) (other : Other fixed K → Nat) (state : State) (width : Nat)
    (counterZero : other (.inr .counter) = 0)
    (oneZero : other (.inr .one) = 0)
    (temporaryZero : other (.inr .temporary) = 0)
    (poolEmpty : base (.inr .poolCounter) = [])
    (hwidth : ∀ a, (input a).size ≤ width) :
    ∃ steps ≤ poolBudget fixed K stock descriptor other width,
      Exec (GraphPackingProgram.pool fixed K stock descriptor)
        ⟨state, tapes (Numerator fixed) denominator base input other⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator
            (outputTapes (.inr .reverseOutput) base
              (poolWord fixed K stock descriptor input other)) input other⟩ := by
  let vals := PackingMachineLayout.values (Numerator fixed) denominator input other
  let n := other (GraphPackingProgram.otherSetup fixed K stock)
  let filledBase := counterTapes (.inr Extra.poolCounter) base n
  let filled := tapes (Numerator fixed) denominator filledBase input other
  have sourceValue : vals (countRegister fixed K (.output stock)) = n := rfl
  have workCounter : vals (work fixed K .counter) = 0 := counterZero
  have workOne : vals (work fixed K .one) = 0 := oneZero
  have workTemporary : vals (work fixed K .temporary) = 0 := temporaryZero
  obtain ⟨tallySteps, tallyBound, tallyRun⟩ := GraphPackingTapeBlocks.tally_exec fixed K
    (.output stock) .poolCounter base vals state workCounter workOne workTemporary
  simp only [sourceValue] at tallyBound
  have tallyRun' : Exec (GraphPackingProgram.tally fixed K (.output stock) .poolCounter)
      ⟨state, tapes (Numerator fixed) denominator base input other⟩ tallySteps
      ⟨.arithmetic (BinaryAddMachine.clean ()), filled⟩ := by
    simp only [sourceValue, poolEmpty, List.append_nil] at tallyRun
    simpa only [filled, filledBase, counterTapes, PackingMachineLayout.tapes,
      GraphPackingRegisters.slots, vals] using tallyRun
  have counterWord : filled (.inr .poolCounter) = List.replicate n true := by
    simp [filled, filledBase, counterTapes]
  have shape : ∀ d ∈ [descriptor],
      registerTapes (itemSlots (Numerator fixed) denominator d) filled
        (PairExpressionCompiler.initial (Numerator fixed d) denominator input) = filled := by
    intro d _
    exact item_shape (Numerator fixed) denominator filledBase input other d
  obtain ⟨poolSteps, poolBound, poolRun⟩ := PackingConstantPool.exec_from_tapes
    (Numerator fixed) denominator (itemSlots (Numerator fixed) denominator)
    (.inr Extra.reverseOutput) (.inr Extra.poolCounter)
    (by
      intro h
      have impossible : Extra.poolCounter = Extra.reverseOutput := Sum.inr.inj h
      cases impossible)
    (fun d i => itemSlots_outside (Other := Other fixed K)
      (Numerator fixed) denominator d Extra.reverseOutput i)
    (fun d i => itemSlots_outside (Other := Other fixed K)
      (Numerator fixed) denominator d Extra.poolCounter i)
    [descriptor] filled (fun _ => input) (.arithmetic (BinaryAddMachine.clean ())) width n
    counterWord shape (by intro _ _ a; exact hwidth a)
  have clearCounter : counterTapes (.inr Extra.poolCounter) filledBase 0 = base := by
    simp only [filledBase, counterTapes, List.replicate_zero, Function.update_idem]
    rw [← poolEmpty, Function.update_eq_self]
  have finalFrame : outputTapes (.inr Extra.reverseOutput)
      (counterTapes (.inr Extra.poolCounter) filled 0)
      (PackingConstantPool.repeatRecords
        (PackingChunkMachine.records (Numerator fixed) denominator (fun _ => input) [descriptor]) n) =
      tapes (Numerator fixed) denominator
        (outputTapes (.inr .reverseOutput) base
          (poolWord fixed K stock descriptor input other)) input other := by
    change outputTapes (.inr Extra.reverseOutput)
      (counterTapes (.inr Extra.poolCounter)
        (tapes (Numerator fixed) denominator filledBase input other) 0) _ = _
    rw [layout_counter, clearCounter, layout_output]
    rfl
  rw [finalFrame] at poolRun
  have phases : GraphPackingProgram.PhaseRuns
      [GraphPackingProgram.tally fixed K (.output stock) .poolCounter,
        PackingConstantPool.code (Numerator fixed) denominator
          (itemSlots (Numerator fixed) denominator)
          (.inr .reverseOutput) (.inr .poolCounter) [descriptor]]
      ⟨state, tapes (Numerator fixed) denominator base input other⟩
      (tallySteps + poolSteps)
      ⟨.arithmetic (BinaryAddMachine.clean ()),
        tapes (Numerator fixed) denominator
          (outputTapes (.inr .reverseOutput) base
            (poolWord fixed K stock descriptor input other)) input other⟩ :=
    .cons tallyRun' (GraphPackingProgram.PhaseRuns.single poolRun)
  refine ⟨tallySteps + poolSteps + 1, ?_, ?_⟩
  · change tallySteps + poolSteps + 1 ≤ BinaryToTallyMachine.runtimeBound n +
      n * ((PackingChunkMachine.timePolynomial (Numerator fixed) denominator [descriptor]).eval width + 2) + 3
    omega
  · simpa only [GraphPackingProgram.pool] using phases.toExec

end BinPackingGap.GraphPackingPoolExec

namespace BinPackingGap.GraphPackingGlobalLoop

open FiniteTapeProgram PackingMachineBlocks GraphPackingRegisters
open PackingMachineLayout GraphPackingProgram GraphPackingPoolExec
open PackingItemExpression (Variable denominator)
open PackingItemBlockMachine (outputTapes)
open PackingCountedProgram (counterTapes guardState)

variable (fixed : InventoryData) (K : Nat)

def radix (other : Other fixed K → Nat) : Nat :=
  other (otherSetup fixed K .base)

def edgeInput (input : Variable → Nat) (other : Other fixed K → Nat) (edge : Nat) :
    Variable → Nat := Function.update input .edgePower (radix fixed K other ^ edge)

@[simp] theorem edgeInput_power (input : Variable → Nat) (other : Other fixed K → Nat)
    (edge : Nat) : edgeInput fixed K input other edge .edgePower = radix fixed K other ^ edge := by
  simp [edgeInput]

theorem edgeInput_update (input : Variable → Nat) (other : Other fixed K → Nat) (edge : Nat) :
    Function.update (edgeInput fixed K input other edge) .edgePower
      (radix fixed K other * edgeInput fixed K input other edge .edgePower) =
      edgeInput fixed K input other (edge + 1) := by
  rw [edgeInput_power]
  simp only [edgeInput, Function.update_idem, Nat.pow_succ, Nat.mul_comm]

def aggregateWidth (other : Other fixed K → Nat) (inputWidth start count : Nat) : Nat :=
  inputWidth + (start + count) * (radix fixed K other).size + 1

theorem edgeInput_size_le (input : Variable → Nat) (other : Other fixed K → Nat)
    (inputWidth start count edge : Nat) (initial : ∀ a, (input a).size ≤ inputWidth)
    (he : edge ≤ start + count) :
    ∀ a, (edgeInput fixed K input other edge a).size ≤
      aggregateWidth fixed K other inputWidth start count := by
  intro a
  by_cases h : a = .edgePower
  · subst a
    rw [edgeInput_power]
    have hp := nat_size_pow_le (radix fixed K other) edge
    have hm := Nat.mul_le_mul_right (radix fixed K other).size he
    unfold aggregateWidth
    omega
  · have hi := initial a
    simp only [edgeInput, Function.update_of_ne h]
    unfold aggregateWidth
    omega

def edgeWord (input : Variable → Nat) (other : Other fixed K → Nat) : List Bool :=
  poolWord fixed K .edgeStock (.w, .globalEdge true) input other ++
  poolWord fixed K .edgeStock (.w, .globalEdge false) input other

def bodyBudget (other : Other fixed K → Nat) (width : Nat) : Nat :=
  poolBudget fixed K .edgeStock (.w, .globalEdge true) other width +
  poolBudget fixed K .edgeStock (.w, .globalEdge false) other width +
  64 * ((radix fixed K other).size + width + 1) ^ 2 + 1

theorem body_exec (base : GraphPackingRegisters.Tape fixed K → List Bool) (input : Variable → Nat)
    (other : Other fixed K → Nat) (state : State) (width : Nat)
    (counterZero : other (.inr .counter) = 0)
    (oneZero : other (.inr .one) = 0)
    (temporaryZero : other (.inr .temporary) = 0)
    (poolEmpty : base (.inr .poolCounter) = [])
    (hi : ∀ a, (input a).size ≤ width) :
    ∃ steps ≤ bodyBudget fixed K other width,
      Exec (globalEdgeBody fixed K)
        ⟨state, tapes (Numerator fixed) denominator base input other⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator
            (outputTapes (.inr .reverseOutput) base (edgeWord fixed K input other))
            (Function.update input .edgePower (radix fixed K other * input .edgePower)) other⟩ := by
  let first := poolWord fixed K .edgeStock (.w, .globalEdge true) input other
  let second := poolWord fixed K .edgeStock (.w, .globalEdge false) input other
  let middle := outputTapes (.inr .reverseOutput) base first
  obtain ⟨n₁, b₁, r₁⟩ := pool_exec fixed K .edgeStock (.w, .globalEdge true)
    base input other state width counterZero oneZero temporaryZero poolEmpty hi
  have emptyMiddle : middle (.inr .poolCounter) = [] := by
    simpa [middle, outputTapes] using poolEmpty
  obtain ⟨n₂, b₂, r₂⟩ := pool_exec fixed K .edgeStock (.w, .globalEdge false)
    middle input other (.arithmetic (BinaryAddMachine.clean ())) width
    counterZero oneZero temporaryZero emptyMiddle hi
  obtain ⟨n₃, b₃, r₃⟩ := PackingVertexUpdate.general_exec
    (Numerator fixed) denominator .edgePower (otherSetup fixed K .base)
    (.inr Work.temporary) (by simp [otherSetup]) .multiply
    (outputTapes (.inr .reverseOutput) middle second) input other temporaryZero
    (.arithmetic (BinaryAddMachine.clean ()))
  have operationMultiply (a b : Nat) :
      PackingRegisterUpdate.operation .multiply a b = a * b := rfl
  have runs := PhaseRuns.cons r₁ (PhaseRuns.cons r₂ (PhaseRuns.single r₃))
  refine ⟨n₁ + (n₂ + n₃) + 1, ?_, ?_⟩
  · have square := Nat.pow_le_pow_left
      (Nat.add_le_add_right (Nat.add_le_add_left (hi .edgePower) (radix fixed K other).size) 1) 2
    have ub := b₃.trans (Nat.mul_le_mul_left 64 square)
    unfold bodyBudget
    omega
  · simpa only [globalEdgeBody, incrementEdge, operationMultiply,
      radix, middle, first, second, edgeWord, PackingChunkMachine.outputTapes_append]
      using runs.toExec

def stream (input : Variable → Nat) (other : Other fixed K → Nat) (start : Nat) :
    Nat → List Bool
  | 0 => []
  | count + 1 => edgeWord fixed K (edgeInput fixed K input other start) other ++
      stream input other (start + 1) count

private theorem layout_counter (base : GraphPackingRegisters.Tape fixed K → List Bool) (input : Variable → Nat)
    (other : Other fixed K → Nat) (count : Nat) :
    tapes (Numerator fixed) denominator (counterTapes (.inr .edgeCounter) base count) input other =
      counterTapes (.inr .edgeCounter) (tapes (Numerator fixed) denominator base input other) count := by
  exact layout_external_update (Numerator fixed) denominator base input other .edgeCounter (List.replicate count true)

private theorem exec_bounded (base : GraphPackingRegisters.Tape fixed K → List Bool) (input : Variable → Nat)
    (other : Other fixed K → Nat) (state : State) (start count width : Nat)
    (counterZero : other (.inr .counter) = 0)
    (oneZero : other (.inr .one) = 0)
    (temporaryZero : other (.inr .temporary) = 0)
    (poolEmpty : base (.inr .poolCounter) = [])
    (hi : ∀ edge, start ≤ edge → edge < start + count →
      ∀ a, (edgeInput fixed K input other edge a).size ≤ width) :
    ∃ steps ≤ count * (bodyBudget fixed K other width + 1) + 1,
      Exec (PackingCountedProgram.loop (.inr .edgeCounter) (globalEdgeBody fixed K))
        ⟨state, counterTapes (.inr .edgeCounter)
          (tapes (Numerator fixed) denominator base (edgeInput fixed K input other start) other) count⟩ steps
        ⟨guardState none, counterTapes (.inr .edgeCounter)
          (tapes (Numerator fixed) denominator
            (outputTapes (.inr .reverseOutput) base (stream fixed K input other start count))
            (edgeInput fixed K input other (start + count)) other) 0⟩ := by
  induction count generalizing base start state with
  | zero =>
      refine ⟨1, by simp, ?_⟩
      have stop : PackingCountedProgram.more ((PackingCountedProgram.guard (.inr .edgeCounter)).eval
          ⟨state, counterTapes (.inr .edgeCounter)
            (tapes (Numerator fixed) denominator base (edgeInput fixed K input other start) other) 0⟩).state = false := by
        rw [PackingCountedProgram.guard_zero]
        rfl
      simpa only [PackingCountedProgram.loop, PackingCountedProgram.guard_zero,
        stream, PackingChunkMachine.outputTapes_nil, Nat.add_zero] using
        (Exec.loop_false (a := globalEdgeBody fixed K) stop)
  | succ count ih =>
      let word := edgeWord fixed K (edgeInput fixed K input other start) other
      have poolEmpty' : counterTapes (.inr .edgeCounter) base count (.inr .poolCounter) = [] := by
        simpa [counterTapes] using poolEmpty
      obtain ⟨bodySteps, bodyBound, bodyRun⟩ := body_exec fixed K
        (counterTapes (.inr .edgeCounter) base count) (edgeInput fixed K input other start)
        other (guardState (some true)) width counterZero oneZero temporaryZero poolEmpty'
        (hi start (by omega) (by omega))
      rw [edgeInput_update, layout_counter,
        PackingConstantPool.output_counter_comm _ _ (by simp), layout_counter] at bodyRun
      have poolEmpty'' : outputTapes (.inr .reverseOutput) base word (.inr .poolCounter) = [] := by
        simpa [outputTapes] using poolEmpty
      obtain ⟨tailSteps, tailBound, tailRun⟩ := ih
        (base := outputTapes (.inr .reverseOutput) base word)
        (state := .arithmetic (BinaryAddMachine.clean ())) (start := start + 1)
        poolEmpty'' (fun edge lower upper => hi edge (by omega) (by omega))
      refine ⟨bodySteps + tailSteps + 1, ?_, ?_⟩
      · rw [Nat.succ_mul]
        omega
      · have more : PackingCountedProgram.more
            ((PackingCountedProgram.guard (.inr .edgeCounter)).eval
              ⟨state, counterTapes (.inr .edgeCounter)
                (tapes (Numerator fixed) denominator base (edgeInput fixed K input other start) other)
                (count + 1)⟩).state = true := by
          rw [PackingCountedProgram.guard_succ]
          rfl
        have bodyRun' : Exec (globalEdgeBody fixed K)
            ((PackingCountedProgram.guard (.inr .edgeCounter)).eval
              ⟨state, counterTapes (.inr .edgeCounter)
                (tapes (Numerator fixed) denominator base (edgeInput fixed K input other start) other)
                (count + 1)⟩) bodySteps
            ⟨.arithmetic (BinaryAddMachine.clean ()), counterTapes (.inr .edgeCounter)
              (tapes (Numerator fixed) denominator (outputTapes (.inr .reverseOutput) base word)
                (edgeInput fixed K input other (start + 1)) other) count⟩ := by
          rw [PackingCountedProgram.guard_succ]
          exact bodyRun
        have combined := Exec.loop_true more bodyRun' tailRun
        simpa only [PackingCountedProgram.loop, word, stream,
          PackingChunkMachine.outputTapes_append, Nat.add_assoc, Nat.add_comm 1 count] using combined

theorem exec (base : GraphPackingRegisters.Tape fixed K → List Bool) (input : Variable → Nat)
    (other : Other fixed K → Nat) (state : State) (start count inputWidth : Nat)
    (counterZero : other (.inr .counter) = 0)
    (oneZero : other (.inr .one) = 0)
    (temporaryZero : other (.inr .temporary) = 0)
    (poolEmpty : base (.inr .poolCounter) = [])
    (hi : ∀ a, (input a).size ≤ inputWidth) :
    ∃ steps ≤ count * (bodyBudget fixed K other
        (aggregateWidth fixed K other inputWidth start count) + 1) + 1,
      Exec (PackingCountedProgram.loop (.inr .edgeCounter) (globalEdgeBody fixed K))
        ⟨state, counterTapes (.inr .edgeCounter)
          (tapes (Numerator fixed) denominator base (edgeInput fixed K input other start) other) count⟩ steps
        ⟨guardState none, counterTapes (.inr .edgeCounter)
          (tapes (Numerator fixed) denominator
            (outputTapes (.inr .reverseOutput) base (stream fixed K input other start count))
            (edgeInput fixed K input other (start + count)) other) 0⟩ := by
  exact exec_bounded fixed K base input other state start count _ counterZero oneZero temporaryZero
    poolEmpty (fun edge _ upper => edgeInput_size_le fixed K input other inputWidth start count
      edge hi (Nat.le_of_lt upper))

end BinPackingGap.GraphPackingGlobalLoop

namespace BinPackingGap.GraphPackingGlobalPhases

open FiniteTapeProgram PackingMachineBlocks GraphPackingRegisters
open PackingMachineLayout GraphPackingProgram GraphPackingPoolExec
open PackingItemExpression (Variable denominator)
open PackingItemBlockMachine (outputTapes)
open PackingCountedProgram (counterTapes guardState)

variable (fixed : InventoryData) (K : Nat)

abbrev Pool := PackingSetupExpression.Output × PackingInventoryDescriptors.ItemDescriptor fixed

def poolListWord (pools : List (Pool fixed)) (input : Variable → Nat)
    (other : Other fixed K → Nat) : List Bool :=
  pools.flatMap (fun pool => poolWord fixed K pool.1 pool.2 input other)

def poolListBudget (pools : List (Pool fixed)) (other : Other fixed K → Nat)
    (width : Nat) : Nat :=
  (pools.map (fun pool => poolBudget fixed K pool.1 pool.2 other width)).sum

theorem pool_runs (pools : List (Pool fixed)) (base : GraphPackingRegisters.Tape fixed K → List Bool)
    (input : Variable → Nat) (other : Other fixed K → Nat) (width : Nat)
    (counterZero : other (.inr .counter) = 0)
    (oneZero : other (.inr .one) = 0)
    (temporaryZero : other (.inr .temporary) = 0)
    (poolEmpty : base (.inr .poolCounter) = [])
    (hi : ∀ a, (input a).size ≤ width) :
    ∃ steps ≤ poolListBudget fixed K pools other width,
      PhaseRuns (pools.map (fun p => GraphPackingProgram.pool fixed K p.1 p.2))
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator base input other⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator
            (outputTapes (.inr .reverseOutput) base (poolListWord fixed K pools input other))
            input other⟩ := by
  induction pools generalizing base with
  | nil =>
      refine ⟨0, by simp [poolListBudget], ?_⟩
      simpa only [List.map_nil, poolListWord, List.flatMap_nil,
        PackingChunkMachine.outputTapes_nil] using
        (PhaseRuns.nil ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator base input other⟩)
  | cons p rest ih =>
      let word := poolWord fixed K p.1 p.2 input other
      let middle := outputTapes (.inr .reverseOutput) base word
      obtain ⟨headSteps, headBound, headRun⟩ := pool_exec fixed K p.1 p.2 base input other
        (.arithmetic (BinaryAddMachine.clean ())) width counterZero oneZero temporaryZero poolEmpty hi
      have poolEmpty' : middle (.inr .poolCounter) = [] := by
        simpa [middle, outputTapes] using poolEmpty
      obtain ⟨tailSteps, tailBound, tailRun⟩ := ih middle poolEmpty'
      refine ⟨headSteps + tailSteps, ?_, ?_⟩
      · simpa only [poolListBudget, List.map_cons, List.sum_cons] using
          Nat.add_le_add headBound tailBound
      · simpa only [List.map_cons, poolListWord, List.flatMap_cons, middle, word,
          PackingChunkMachine.outputTapes_append] using PhaseRuns.cons headRun tailRun

def unitPools : List (Pool fixed) :=
  [(.upOne, (.up, .globalUnit true)), (.upZero, (.up, .globalUnit false)),
   (.umOne, (.um, .globalUnit true)), (.umZero, (.um, .globalUnit false))]

def flagPools : List (Pool fixed) :=
  [(.treeFlags, (.ft, .zero)), (.jobFlags, (.fm, .zero)), (.jobFlags, (.fg, .zero))]

private theorem update_width (input : Variable → Nat) (width : Nat)
    (hi : ∀ a, (input a).size ≤ width) (destination : Variable) (constant : Nat)
    (hc : constant.size ≤ width) :
    ∀ a, (Function.update input destination constant a).size ≤ width := by
  intro a
  by_cases h : a = destination
  · subst a
    simpa only [Function.update_self] using hc
  · simpa only [Function.update_of_ne h] using hi a

def flagInput (input : Variable → Nat) : Variable → Nat := Function.update input .edgePower 1

def flagsBudget (other : Other fixed K → Nat) (width : Nat) : Nat :=
  (PackingLayoutCommands.setInputTime (Other := Other fixed K)
    (Numerator fixed) denominator .edgePower 1).eval (width + 1) +
  poolListBudget fixed K (flagPools fixed) other (width + 1) + 1

theorem flags_exec (base : GraphPackingRegisters.Tape fixed K → List Bool) (input : Variable → Nat)
    (other : Other fixed K → Nat) (state : State) (width : Nat)
    (counterZero : other (.inr .counter) = 0)
    (oneZero : other (.inr .one) = 0)
    (temporaryZero : other (.inr .temporary) = 0)
    (poolEmpty : base (.inr .poolCounter) = [])
    (hi : ∀ a, (input a).size ≤ width) (ho : ∀ a, (other a).size ≤ width) :
    ∃ steps ≤ flagsBudget fixed K other width,
      Exec (GraphPackingProgram.flags fixed K)
        ⟨state, tapes (Numerator fixed) denominator base input other⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator
            (outputTapes (.inr .reverseOutput) base
              (poolListWord fixed K (flagPools fixed) (flagInput input) other))
            (flagInput input) other⟩ := by
  have hi' : ∀ a, (input a).size ≤ width + 1 := fun a => (hi a).trans (Nat.le_succ _)
  have ho' : ∀ a, (other a).size ≤ width + 1 := fun a => (ho a).trans (Nat.le_succ _)
  obtain ⟨resetSteps, resetBound, resetRun⟩ := PackingLayoutCommands.setInput_exec
    (Numerator fixed) denominator .edgePower 1 base input other state (width + 1) hi' ho'
  have afterWidth : ∀ a, (flagInput input a).size ≤ width + 1 :=
    update_width input (width + 1) hi' .edgePower 1 (by simp [Nat.size_one])
  obtain ⟨poolSteps, poolBound, poolRun⟩ := pool_runs fixed K (flagPools fixed)
    base (flagInput input) other (width + 1) counterZero oneZero temporaryZero poolEmpty afterWidth
  refine ⟨resetSteps + poolSteps + 1, ?_, ?_⟩
  · unfold flagsBudget
    omega
  · simpa only [GraphPackingProgram.flags, GraphPackingProgram.setItem, flagPools,
      List.map_cons, List.map_nil, flagInput] using (PhaseRuns.cons resetRun poolRun).toExec

def unitInput (input : Variable → Nat) : Variable → Nat :=
  Function.update (Function.update (Function.update input .labelPower 0) .repetitionOne 0) .edgePower 1

def globalCount (other : Other fixed K → Nat) : Nat :=
  other (.inl (PackingSetupMachine.input (parameters fixed K) .m))

def globalsWord (input : Variable → Nat) (other : Other fixed K → Nat) : List Bool :=
  poolListWord fixed K (unitPools fixed) (unitInput input) other ++
  GraphPackingGlobalLoop.stream fixed K (unitInput input) other 0 (globalCount fixed K other)

def globalsInput (input : Variable → Nat) (other : Other fixed K → Nat) : Variable → Nat :=
  GraphPackingGlobalLoop.edgeInput fixed K (unitInput input) other (globalCount fixed K other)

def resetBudget (width : Nat) : Nat :=
  (PackingLayoutCommands.setInputTime (Other := Other fixed K)
    (Numerator fixed) denominator .labelPower 0).eval (width + 1) +
  (PackingLayoutCommands.setInputTime (Other := Other fixed K)
    (Numerator fixed) denominator .repetitionOne 0).eval (width + 1) +
  (PackingLayoutCommands.setInputTime (Other := Other fixed K)
    (Numerator fixed) denominator .edgePower 1).eval (width + 1)

def globalsBudget (other : Other fixed K → Nat) (width : Nat) : Nat :=
  resetBudget fixed K width + poolListBudget fixed K (unitPools fixed) other (width + 1) +
  BinaryToTallyMachine.runtimeBound (globalCount fixed K other) +
  globalCount fixed K other * (GraphPackingGlobalLoop.bodyBudget fixed K other
    (GraphPackingGlobalLoop.aggregateWidth fixed K other (width + 1) 0
      (globalCount fixed K other)) + 1) + 3

theorem globals_exec (base : GraphPackingRegisters.Tape fixed K → List Bool) (input : Variable → Nat)
    (other : Other fixed K → Nat) (state : State) (width : Nat)
    (counterZero : other (.inr .counter) = 0)
    (oneZero : other (.inr .one) = 0)
    (temporaryZero : other (.inr .temporary) = 0)
    (poolEmpty : base (.inr .poolCounter) = [])
    (edgeEmpty : base (.inr .edgeCounter) = [])
    (hi : ∀ a, (input a).size ≤ width) (ho : ∀ a, (other a).size ≤ width) :
    ∃ steps ≤ globalsBudget fixed K other width,
      Exec (GraphPackingProgram.globals fixed K)
        ⟨state, tapes (Numerator fixed) denominator base input other⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator
            (outputTapes (.inr .reverseOutput) base (globalsWord fixed K input other))
            (globalsInput fixed K input other) other⟩ := by
  let input₁ := Function.update input .labelPower 0
  let input₂ := Function.update input₁ .repetitionOne 0
  let finalInput := unitInput input
  have hi' : ∀ a, (input a).size ≤ width + 1 := fun a => (hi a).trans (Nat.le_succ _)
  have ho' : ∀ a, (other a).size ≤ width + 1 := fun a => (ho a).trans (Nat.le_succ _)
  have hi₁ : ∀ a, (input₁ a).size ≤ width + 1 := update_width input _ hi' .labelPower 0 (by simp)
  have hi₂ : ∀ a, (input₂ a).size ≤ width + 1 := update_width input₁ _ hi₁ .repetitionOne 0 (by simp)
  have hi₃ : ∀ a, (finalInput a).size ≤ width + 1 :=
    update_width input₂ _ hi₂ .edgePower 1 (by simp [Nat.size_one])
  obtain ⟨n₁, b₁, r₁⟩ := PackingLayoutCommands.setInput_exec
    (Numerator fixed) denominator .labelPower 0 base input other state (width + 1) hi' ho'
  obtain ⟨n₂, b₂, r₂⟩ := PackingLayoutCommands.setInput_exec
    (Numerator fixed) denominator .repetitionOne 0 base input₁ other
    (.arithmetic (BinaryAddMachine.clean ())) (width + 1) hi₁ ho'
  obtain ⟨n₃, b₃, r₃⟩ := PackingLayoutCommands.setInput_exec
    (Numerator fixed) denominator .edgePower 1 base input₂ other
    (.arithmetic (BinaryAddMachine.clean ())) (width + 1) hi₂ ho'
  let unitWord := poolListWord fixed K (unitPools fixed) finalInput other
  let middle := outputTapes (.inr .reverseOutput) base unitWord
  obtain ⟨np, bp, rp⟩ := pool_runs fixed K (unitPools fixed) base finalInput other (width + 1)
    counterZero oneZero temporaryZero poolEmpty hi₃
  let vals := values (Numerator fixed) denominator finalInput other
  obtain ⟨nt, bt, rt⟩ := GraphPackingTapeBlocks.tally_exec fixed K (.input .m) .edgeCounter
    middle vals (.arithmetic (BinaryAddMachine.clean ())) counterZero oneZero temporaryZero
  have middleEdge : middle (.inr .edgeCounter) = [] := by
    simpa [middle, outputTapes] using edgeEmpty
  have middlePool : middle (.inr .poolCounter) = [] := by
    simpa [middle, outputTapes] using poolEmpty
  have atZero : GraphPackingGlobalLoop.edgeInput fixed K finalInput other 0 = finalInput := by
    unfold GraphPackingGlobalLoop.edgeInput
    simp only [Nat.pow_zero]
    change Function.update (Function.update input₂ .edgePower 1) .edgePower 1 = _
    rw [Function.update_idem]
    rfl
  have countValue : vals (countRegister fixed K (.input .m)) = globalCount fixed K other := rfl
  have rt' : Exec (tally fixed K (.input .m) .edgeCounter)
      ⟨.arithmetic (BinaryAddMachine.clean ()), tapes (Numerator fixed) denominator middle finalInput other⟩ nt
      ⟨.arithmetic (BinaryAddMachine.clean ()), counterTapes (.inr .edgeCounter)
        (tapes (Numerator fixed) denominator middle finalInput other) (globalCount fixed K other)⟩ := by
    rw [GraphPackingPoolExec.layout_counter]
    simp only [countValue, middleEdge, List.append_nil] at rt
    simpa only [PackingMachineLayout.tapes, GraphPackingRegisters.slots, vals,
      counterTapes] using rt
  obtain ⟨nl, bl, rl⟩ := GraphPackingGlobalLoop.exec fixed K middle finalInput other
    (.arithmetic (BinaryAddMachine.clean ())) 0 (globalCount fixed K other) (width + 1)
    counterZero oneZero temporaryZero middlePool hi₃
  rw [atZero] at rl
  have finalCounter : counterTapes (.inr .edgeCounter)
      (tapes (Numerator fixed) denominator
        (outputTapes (.inr .reverseOutput) middle
          (GraphPackingGlobalLoop.stream fixed K finalInput other 0 (globalCount fixed K other)))
        (globalsInput fixed K input other) other) 0 =
      tapes (Numerator fixed) denominator
        (outputTapes (.inr .reverseOutput) base (globalsWord fixed K input other))
        (globalsInput fixed K input other) other := by
    have words : outputTapes (.inr .reverseOutput) middle
        (GraphPackingGlobalLoop.stream fixed K finalInput other 0 (globalCount fixed K other)) =
        outputTapes (.inr .reverseOutput) base (globalsWord fixed K input other) := by
      dsimp only [middle, unitWord, globalsWord, finalInput]
      rw [PackingChunkMachine.outputTapes_append]
    rw [words]
    unfold counterTapes
    rw [List.replicate_zero, Function.update_eq_self_iff]
    simp [outputTapes, edgeEmpty]
  have atCount : GraphPackingGlobalLoop.edgeInput fixed K finalInput other
      (globalCount fixed K other) = globalsInput fixed K input other := rfl
  have rl' : Exec (PackingCountedProgram.loop (.inr .edgeCounter) (globalEdgeBody fixed K))
      ⟨.arithmetic (BinaryAddMachine.clean ()), counterTapes (.inr .edgeCounter)
        (tapes (Numerator fixed) denominator middle finalInput other) (globalCount fixed K other)⟩ nl
      ⟨.arithmetic (BinaryAddMachine.clean ()),
        tapes (Numerator fixed) denominator
          (outputTapes (.inr .reverseOutput) base (globalsWord fixed K input other))
          (globalsInput fixed K input other) other⟩ := by
    rw [Nat.zero_add, atCount, finalCounter] at rl
    simpa only [guardState, BinaryAddMachine.clean, BinaryAddMachine.state] using rl
  have runs := PhaseRuns.cons r₁ (PhaseRuns.cons r₂ (PhaseRuns.cons r₃
    (rp.append (PhaseRuns.cons rt' (PhaseRuns.single rl')))))
  refine ⟨n₁ + (n₂ + (n₃ + (np + (nt + nl)))) + 1, ?_, ?_⟩
  · rw [countValue] at bt
    unfold globalsBudget resetBudget
    omega
  · simpa only [GraphPackingProgram.globals, GraphPackingProgram.setItem, unitPools,
      List.map_cons, List.map_nil, List.cons_append, List.nil_append]
      using runs.toExec

end BinPackingGap.GraphPackingGlobalPhases

namespace BinPackingGap.GraphPackingGlobalLoop

open GraphPackingRegisters
open PackingItemExpression (Variable)

theorem stream_eq_finRange (fixed : InventoryData) (K : Nat)
    (input : Variable → Nat) (other : Other fixed K → Nat) (start count : Nat) :
    stream fixed K input other start count =
      (List.finRange count).flatMap (fun j =>
        edgeWord fixed K (edgeInput fixed K input other (start + j.val)) other) := by
  induction count generalizing start with
  | zero => simp [stream]
  | succ count ih =>
      rw [stream, ih, List.finRange_succ, List.flatMap_cons, List.flatMap_map]
      simp only [Fin.val_zero, Fin.val_succ, Nat.add_zero]
      congr 1
      apply congrArg (fun f => (List.finRange count).flatMap f)
      funext j
      have index : start + 1 + j.val = start + (j.val + 1) := by omega
      rw [index]

end BinPackingGap.GraphPackingGlobalLoop

namespace BinPackingGap.GraphPackingJobs

open FiniteTapeProgram PackingMachineBlocks GraphPackingRegisters
open GraphPackingPreparation PackingItemExpression
open PackingMachineLayout (tapes)
open PackingItemBlockMachine (outputTapes)
open PackingCountedProgram (counterTapes guardState)
open GraphPackingPoolExec (layout_counter)

variable (fixed : InventoryData) (K : Nat)

theorem loop_exec_list (x : GraphReductionInput) (es : List x.graph.Edge)
    (base : Tape fixed K → List Bool) (start : Nat) (state : State)
    (indices : es.map Fin.val = List.range' start es.length)
    (sourceWord : base (.inr .endpoints) = edgeFields x es)
    (decodeEmpty : base (.inr .decodeScratch) = [])
    (powerEmpty : base (.inr .powerCounter) = [])
    (repeatEmpty : base (.inr .repetitionCounter) = []) :
    ∃ steps ≤ es.length * ((edgeTimePolynomial fixed K).eval (graphBits x).length + 1) + 1,
      Exec (PackingCountedProgram.loop (.inr .edgeCounter) (GraphPackingProgram.edgeBody fixed K))
        ⟨state, counterTapes (.inr .edgeCounter)
          (tapes (Numerator fixed) denominator base (inputs fixed K x start)
            (preparedOther fixed K x)) es.length⟩ steps
        ⟨guardState none, counterTapes (.inr .edgeCounter)
          (tapes (Numerator fixed) denominator
            (resultBase fixed K base [false] (edgeWords fixed K x es))
            (inputs fixed K x (start + es.length)) (preparedOther fixed K x)) 0⟩ := by
  induction es generalizing base start state with
  | nil =>
      have endpointNil : base (.inr .endpoints) = [false] := by
        simpa [edgeFields, BinaryEncoding.listBits] using sourceWord
      refine ⟨1, by simp, ?_⟩
      have stop : PackingCountedProgram.more
          ((PackingCountedProgram.guard (.inr .edgeCounter)).eval
            ⟨state, counterTapes (.inr .edgeCounter)
              (tapes (Numerator fixed) denominator base (inputs fixed K x start)
                (preparedOther fixed K x)) 0⟩).state = false := by
        rw [PackingCountedProgram.guard_zero]
        rfl
      simpa only [PackingCountedProgram.loop, PackingCountedProgram.guard_zero,
        edgeWords, List.flatMap_nil, List.length_nil, Nat.add_zero,
        resultBase_nil fixed K base endpointNil] using
        (Exec.loop_false (a := GraphPackingProgram.edgeBody fixed K) stop)
  | cons e es ih =>
      obtain ⟨headIndex, tailIndices⟩ := contiguous_cons e es start indices
      let currentBase := counterTapes (.inr Extra.edgeCounter) base es.length
      let middleBase := resultBase fixed K base (edgeFields x es) (edgeWord fixed K x e)
      have currentWord : currentBase (.inr .endpoints) = true ::
          (BinaryEncoding.natBits (x.graph.left e).val ++
            (BinaryEncoding.natBits (x.graph.right e).val ++ edgeFields x es)) := by
        simpa [currentBase, counterTapes, edgeFields, BinaryEncoding.listBits,
          List.append_assoc] using sourceWord
      have currentDecode : currentBase (.inr .decodeScratch) = [] := by
        simpa [currentBase, counterTapes] using decodeEmpty
      have currentPower : currentBase (.inr .powerCounter) = [] := by
        simpa [currentBase, counterTapes] using powerEmpty
      have currentRepeat : currentBase (.inr .repetitionCounter) = [] := by
        simpa [currentBase, counterTapes] using repeatEmpty
      obtain ⟨bodySteps, bodyBound, bodyRun⟩ := edge_exec fixed K x e currentBase
        (guardState (some true)) (edgeFields x es) currentWord currentDecode
        currentPower currentRepeat
      have bodyRun' : Exec (GraphPackingProgram.edgeBody fixed K)
          ⟨guardState (some true), counterTapes (.inr .edgeCounter)
            (tapes (Numerator fixed) denominator base (inputs fixed K x start)
              (preparedOther fixed K x)) es.length⟩ bodySteps
          ⟨.arithmetic (BinaryAddMachine.clean ()), counterTapes (.inr .edgeCounter)
            (tapes (Numerator fixed) denominator middleBase (inputs fixed K x (start + 1))
              (preparedOther fixed K x)) es.length⟩ := by
        simpa only [currentBase, middleBase, headIndex, resultBase_counter,
          ← layout_counter] using bodyRun
      have middleWord : middleBase (.inr .endpoints) = edgeFields x es := by
        simp [middleBase]
      have middleDecode : middleBase (.inr .decodeScratch) = [] := by
        simpa [middleBase] using decodeEmpty
      have middlePower : middleBase (.inr .powerCounter) = [] := by
        simpa [middleBase] using powerEmpty
      have middleRepeat : middleBase (.inr .repetitionCounter) = [] := by
        simpa [middleBase] using repeatEmpty
      obtain ⟨tailSteps, tailBound, tailRun⟩ := ih middleBase (start + 1)
        (.arithmetic (BinaryAddMachine.clean ())) tailIndices middleWord
        middleDecode middlePower middleRepeat
      refine ⟨bodySteps + tailSteps + 1, ?_, ?_⟩
      · simp only [List.length_cons, Nat.succ_mul]
        omega
      · have more : PackingCountedProgram.more
            ((PackingCountedProgram.guard (.inr .edgeCounter)).eval
              ⟨state, counterTapes (.inr .edgeCounter)
                (tapes (Numerator fixed) denominator base (inputs fixed K x start)
                  (preparedOther fixed K x)) (es.length + 1)⟩).state = true := by
          rw [PackingCountedProgram.guard_succ]
          rfl
        have bodyAfterGuard : Exec (GraphPackingProgram.edgeBody fixed K)
            ((PackingCountedProgram.guard (.inr .edgeCounter)).eval
              ⟨state, counterTapes (.inr .edgeCounter)
                (tapes (Numerator fixed) denominator base (inputs fixed K x start)
                  (preparedOther fixed K x)) (es.length + 1)⟩) bodySteps
            ⟨.arithmetic (BinaryAddMachine.clean ()), counterTapes (.inr .edgeCounter)
              (tapes (Numerator fixed) denominator middleBase (inputs fixed K x (start + 1))
                (preparedOther fixed K x)) es.length⟩ := by
          rw [PackingCountedProgram.guard_succ]
          exact bodyRun'
        have combined := Exec.loop_true more bodyAfterGuard tailRun
        simpa only [PackingCountedProgram.loop, middleBase, resultBase_append,
          edgeWords, List.flatMap_cons, List.length_cons, Nat.add_assoc, Nat.add_comm 1 es.length]
          using combined

def loopTimePolynomial : Polynomial Nat :=
  Polynomial.X * (edgeTimePolynomial fixed K + 1) + 1

theorem loop_exec (x : GraphReductionInput) (base : Tape fixed K → List Bool)
    (state : State)
    (sourceWord : base (.inr .endpoints) = GraphFieldMachine.fieldBits .endpoints x)
    (decodeEmpty : base (.inr .decodeScratch) = [])
    (powerEmpty : base (.inr .powerCounter) = [])
    (repeatEmpty : base (.inr .repetitionCounter) = []) :
    ∃ steps ≤ (loopTimePolynomial fixed K).eval (graphBits x).length,
      Exec (PackingCountedProgram.loop (.inr .edgeCounter) (GraphPackingProgram.edgeBody fixed K))
        ⟨state, counterTapes (.inr .edgeCounter)
          (tapes (Numerator fixed) denominator base (inputs fixed K x 0)
            (preparedOther fixed K x)) x.graph.edges.length⟩ steps
        ⟨guardState none, counterTapes (.inr .edgeCounter)
          (tapes (Numerator fixed) denominator
            (resultBase fixed K base [false]
              (PackingDescriptorExpression.rawRecords
                (PackingInventoryDescriptors.jobStream (inventory fixed K x))))
            (inputs fixed K x x.graph.edges.length) (preparedOther fixed K x)) 0⟩ := by
  obtain ⟨steps, bound, run⟩ := loop_exec_list fixed K x
    (List.finRange x.graph.edges.length) base 0 state
    (by simpa only [List.length_finRange] using contiguous_finRange x.graph.edges.length)
    (by simpa only [edgeFields_finRange] using sourceWord) decodeEmpty powerEmpty repeatEmpty
  refine ⟨steps, ?_, ?_⟩
  · have hm := graph_edgeCount_le_bits x
    have upper := Nat.mul_le_mul_right
      ((edgeTimePolynomial fixed K).eval (graphBits x).length + 1) hm
    simp only [List.length_finRange] at bound
    simp only [loopTimePolynomial, Polynomial.eval_add, Polynomial.eval_mul,
      Polynomial.eval_X, Polynomial.eval_one]
    omega
  · simpa only [List.length_finRange, Nat.zero_add, edgeWords_finRange] using run

end BinPackingGap.GraphPackingJobs

namespace BinPackingGap.GraphPackingPoolRuntime

open BinPackingGames.Foundations.Complexity
open GraphPackingRegisters GraphPackingGlobalPhases PackingInventoryDescriptors
open PackingItemExpression (denominator)

def tallyPolynomial (N : Polynomial Nat) : Polynomial Nat :=
  Polynomial.C 40 * (N + 1) ^ 3

@[simp] theorem tallyPolynomial_eval (N : Polynomial Nat) (s : Nat) :
    (tallyPolynomial N).eval s = 40 * (N.eval s + 1) ^ 3 := by
  simp only [tallyPolynomial, Polynomial.eval_mul, Polynomial.eval_C,
    Polynomial.eval_pow, Polynomial.eval_add, Polynomial.eval_one]

theorem tally_le (n s : Nat) (N : Polynomial Nat) (hn : n ≤ N.eval s) :
    BinaryToTallyMachine.runtimeBound n ≤ (tallyPolynomial N).eval s := by
  have hsize : n.size ≤ N.eval s := (nat_size_le_self n).trans hn
  rw [tallyPolynomial_eval]
  unfold BinaryToTallyMachine.runtimeBound
  calc
    40 * (n + 1) * (n.size + 1) ^ 2 ≤
        40 * (N.eval s + 1) * (N.eval s + 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 hsize 1) 2)
    _ = 40 * (N.eval s + 1) ^ 3 := by ring

def poolPolynomial (fixed : InventoryData) (descriptor : ItemDescriptor fixed)
    (N W : Polynomial Nat) : Polynomial Nat :=
  tallyPolynomial N + N *
    ((PackingChunkMachine.timePolynomial (Numerator fixed) denominator [descriptor]).comp W +
      Polynomial.C 2) + Polynomial.C 3

@[simp] theorem poolPolynomial_eval (fixed : InventoryData) (descriptor : ItemDescriptor fixed)
    (N W : Polynomial Nat) (s : Nat) :
    (poolPolynomial fixed descriptor N W).eval s =
      (tallyPolynomial N).eval s + N.eval s *
        ((PackingChunkMachine.timePolynomial (Numerator fixed) denominator [descriptor]).eval
          (W.eval s) + 2) + 3 := by
  simp only [poolPolynomial, Polynomial.eval_add, Polynomial.eval_mul,
    Polynomial.eval_comp, Polynomial.eval_C]

theorem poolBudget_le (fixed : InventoryData) (K : Nat)
    (stock : PackingSetupExpression.Output) (descriptor : ItemDescriptor fixed)
    (other : Other fixed K → Nat) (width : Nat) (N W : Polynomial Nat) (s : Nat)
    (hcount : other (GraphPackingProgram.otherSetup fixed K stock) ≤ N.eval s)
    (hwidth : width ≤ W.eval s) :
    GraphPackingPoolExec.poolBudget fixed K stock descriptor other width ≤
      (poolPolynomial fixed descriptor N W).eval s := by
  have ht := tally_le (other (GraphPackingProgram.otherSetup fixed K stock)) s N hcount
  have hb := MachineComposition.natPolynomial_eval_mono
    (PackingChunkMachine.timePolynomial (Numerator fixed) denominator [descriptor]) hwidth
  have hm := Nat.mul_le_mul hcount (Nat.add_le_add_right hb 2)
  rw [poolPolynomial_eval]
  dsimp only [GraphPackingPoolExec.poolBudget]
  exact Nat.add_le_add_right (Nat.add_le_add ht hm) 3

def poolListPolynomial (fixed : InventoryData) (pools : List (Pool fixed))
    (N W : Polynomial Nat) : Polynomial Nat :=
  (pools.map (fun pool => poolPolynomial fixed pool.2 N W)).sum

@[simp] theorem poolListPolynomial_eval (fixed : InventoryData) (pools : List (Pool fixed))
    (N W : Polynomial Nat) (s : Nat) :
    (poolListPolynomial fixed pools N W).eval s =
      (pools.map (fun pool => (poolPolynomial fixed pool.2 N W).eval s)).sum := by
  simp only [poolListPolynomial, Polynomial.eval_listSum, List.map_map, Function.comp_def]

theorem poolListBudget_le (fixed : InventoryData) (K : Nat) (pools : List (Pool fixed))
    (other : Other fixed K → Nat) (width : Nat) (N W : Polynomial Nat) (s : Nat)
    (hcounts : ∀ pool ∈ pools,
      other (GraphPackingProgram.otherSetup fixed K pool.1) ≤ N.eval s)
    (hwidth : width ≤ W.eval s) :
    poolListBudget fixed K pools other width ≤
      (poolListPolynomial fixed pools N W).eval s := by
  revert hcounts
  induction pools with
  | nil =>
      intro _
      simp [poolListBudget, poolListPolynomial]
  | cons pool pools ih =>
      intro hcounts
      have headBound := poolBudget_le fixed K pool.1 pool.2 other width N W s
        (hcounts pool (by simp)) hwidth
      have tailBound := ih (fun p hp => hcounts p (by simp [hp]))
      simpa only [poolListBudget, poolListPolynomial, List.map_cons, List.sum_cons,
        Polynomial.eval_add] using Nat.add_le_add headBound tailBound

end BinPackingGap.GraphPackingPoolRuntime

namespace BinPackingGap.GraphPackingGlobalSemantics

open GraphPackingRegisters GraphPackingPreparation
open PackingDescriptorExpression PackingInventoryDescriptors GraphPackingStockStreams
open GraphPackingPoolExec GraphPackingGlobalPhases
open PackingItemExpression (Variable denominator)

variable (fixed : InventoryData) (K : Nat)

def inventory (x : GraphReductionInput) : InventoryData :=
  instantiate fixed x.graph (GraphPackingPreparation.repetitions fixed K x) x.k

def globalOutput {G : GraphInput} : GlobalSpecies G → PackingSetupExpression.Output
  | .up true => .upOne
  | .up false => .upZero
  | .um true => .umOne
  | .um false => .umZero
  | .edge _ _ => .edgeStock

def flagOutput : FlagSpecies → PackingSetupExpression.Output
  | .tree => .treeFlags
  | .main | .edge => .jobFlags

theorem prepared_output (x : GraphReductionInput) (o : PackingSetupExpression.Output) :
    preparedOther fixed K x (GraphPackingProgram.otherSetup fixed K o) =
      PackingSetupExpression.inventoryOutput (inventory fixed K x) o := by
  change PackingSetupExpression.outputValues (parameters fixed K)
    x.graph.n x.graph.edges.length x.k o = _
  exact congrFun (PackingSetupExpression.outputValues_eq_inventory (parameters fixed K)
    (inventory fixed K x) rfl rfl rfl rfl) o

theorem prepared_globalStock (x : GraphReductionInput) (species : GlobalSpecies x.graph) :
    preparedOther fixed K x (GraphPackingProgram.otherSetup fixed K (globalOutput species)) =
      (inventory fixed K x).globalStock species := by
  rw [prepared_output]
  cases species with
  | up one => cases one <;> rfl
  | um one => cases one <;> rfl
  | edge edge permit => rfl

theorem prepared_flagStock (x : GraphReductionInput) (species : FlagSpecies) :
    preparedOther fixed K x (GraphPackingProgram.otherSetup fixed K (flagOutput species)) =
      (inventory fixed K x).flagStock species := by
  rw [prepared_output]
  cases species <;> rfl

theorem prepared_radix (x : GraphReductionInput) :
    GraphPackingGlobalLoop.radix fixed K (preparedOther fixed K x) =
      (inventory fixed K x).R + 1 := rfl

theorem prepared_globalCount (x : GraphReductionInput) :
    globalCount fixed K (preparedOther fixed K x) = x.graph.edges.length := rfl

theorem unitInput_values (x : GraphReductionInput) (label : Option x.graph.Vertex)
    (edge rep : Nat) :
    unitInput (values (inventory fixed K x) label edge rep) =
      values (inventory fixed K x) none 0 0 := by
  funext vinput
  cases vinput <;> simp [unitInput, values, NaturalPackingNumerator.labelPower]

theorem edgeInput_values (x : GraphReductionInput) (label : Option x.graph.Vertex)
    (oldEdge rep edge : Nat) :
    GraphPackingGlobalLoop.edgeInput fixed K
      (values (inventory fixed K x) label oldEdge rep) (preparedOther fixed K x) edge =
      values (inventory fixed K x) label edge rep := by
  funext vinput
  cases vinput <;>
    simp [GraphPackingGlobalLoop.edgeInput, prepared_radix, values]

theorem flagInput_values (x : GraphReductionInput) (edge : Nat) :
    flagInput (values (inventory fixed K x) none edge 0) =
      values (inventory fixed K x) none 0 0 := by
  funext vinput
  cases vinput <;> simp [flagInput, values]

theorem poolWord_global (x : GraphReductionInput) (species : GlobalSpecies x.graph) :
    poolWord fixed K (globalOutput species) (globalDescriptor (inventory fixed K x) species)
      (values (inventory fixed K x) none (globalEdgeIndex (inventory fixed K x) species) 0)
      (preparedOther fixed K x) =
      rawRecords (globalPoolStream (inventory fixed K x) species) := by
  unfold poolWord
  rw [prepared_globalStock]
  have hnum : numerator (inventory fixed K x) = numerator fixed := by
    funext descriptor
    exact numerator_instantiate fixed x.graph
      (GraphPackingPreparation.repetitions fixed K x) x.k descriptor
  have records := globalPool_chunk_records (inventory fixed K x) species
  rw [hnum] at records
  simpa only [Numerator, inventory, instantiate] using records

theorem poolWord_flag (x : GraphReductionInput) (species : FlagSpecies) :
    poolWord fixed K (flagOutput species) (flagDescriptor (inventory fixed K x) species)
      (values (inventory fixed K x) none 0 0) (preparedOther fixed K x) =
      rawRecords (flagPoolStream (inventory fixed K x) species) := by
  unfold poolWord
  rw [prepared_flagStock]
  have hnum : numerator (inventory fixed K x) = numerator fixed := by
    funext descriptor
    exact numerator_instantiate fixed x.graph
      (GraphPackingPreparation.repetitions fixed K x) x.k descriptor
  have records := flagPool_chunk_records (inventory fixed K x) species
  rw [hnum] at records
  simpa only [Numerator, inventory, instantiate] using records

theorem unitPools_word (x : GraphReductionInput) :
    poolListWord fixed K (unitPools fixed) (values (inventory fixed K x) none 0 0)
      (preparedOther fixed K x) =
      rawRecords (globalPoolStream (inventory fixed K x) (.up true) ++
        globalPoolStream (inventory fixed K x) (.up false) ++
        globalPoolStream (inventory fixed K x) (.um true) ++
        globalPoolStream (inventory fixed K x) (.um false)) := by
  have upOne := poolWord_global fixed K x (.up true)
  have upZero := poolWord_global fixed K x (.up false)
  have umOne := poolWord_global fixed K x (.um true)
  have umZero := poolWord_global fixed K x (.um false)
  dsimp only [globalOutput, globalDescriptor, globalEdgeIndex] at upOne upZero umOne umZero
  have words := congrArg₂ (fun a b : List Bool => a ++ b) upOne
    (congrArg₂ (fun a b : List Bool => a ++ b) upZero
      (congrArg₂ (fun a b : List Bool => a ++ b) umOne umZero))
  simpa only [poolListWord, unitPools, List.flatMap_cons, List.flatMap_nil, List.append_nil,
    rawRecords, List.flatMap_append, List.append_assoc, inventory, instantiate] using words

theorem edgeWord_values (x : GraphReductionInput) (edge : x.graph.Edge) :
    GraphPackingGlobalLoop.edgeWord fixed K
      (values (inventory fixed K x) none edge.val 0) (preparedOther fixed K x) =
      rawRecords (globalPoolStream (inventory fixed K x) (.edge edge true) ++
        globalPoolStream (inventory fixed K x) (.edge edge false)) := by
  have yes := poolWord_global fixed K x (.edge edge true)
  have no := poolWord_global fixed K x (.edge edge false)
  dsimp only [globalOutput, globalDescriptor, globalEdgeIndex] at yes no
  simpa only [GraphPackingGlobalLoop.edgeWord, rawRecords, List.flatMap_append,
    inventory, instantiate] using
    congrArg₂ (fun a b : List Bool => a ++ b) yes no

theorem flagPools_word (x : GraphReductionInput) :
    poolListWord fixed K (flagPools fixed) (values (inventory fixed K x) none 0 0)
      (preparedOther fixed K x) = rawRecords (flagStream (inventory fixed K x)) := by
  have tree := poolWord_flag fixed K x .tree
  have main := poolWord_flag fixed K x .main
  have edge := poolWord_flag fixed K x .edge
  dsimp only [flagOutput, flagDescriptor] at tree main edge
  have words := congrArg₂ (fun a b : List Bool => a ++ b) tree
    (congrArg₂ (fun a b : List Bool => a ++ b) main edge)
  simpa only [poolListWord, flagPools, List.flatMap_cons, List.flatMap_nil, List.append_nil,
    flagStream, rawRecords, List.flatMap_append, List.append_assoc, inventory, instantiate] using words

theorem globalsWord_eq (x : GraphReductionInput) :
    globalsWord fixed K (values (inventory fixed K x) none x.graph.edges.length 0)
      (preparedOther fixed K x) = rawRecords (globalStream (inventory fixed K x)) := by
  have unitValues := unitInput_values fixed K x none x.graph.edges.length 0
  have unitWords := unitPools_word fixed K x
  have edgeValues := edgeInput_values fixed K x none 0 0
  have edgeWords := edgeWord_values fixed K x
  dsimp only [inventory, instantiate] at unitValues unitWords edgeValues edgeWords ⊢
  unfold globalsWord
  rw [unitValues, unitWords, prepared_globalCount fixed K x,
    GraphPackingGlobalLoop.stream_eq_finRange]
  simp_rw [Nat.zero_add, edgeValues, edgeWords]
  simp only [globalStream, rawRecords, List.flatMap_append, List.flatMap_assoc,
    List.append_assoc]

theorem globalsInput_eq (x : GraphReductionInput) :
    globalsInput fixed K (values (inventory fixed K x) none x.graph.edges.length 0)
      (preparedOther fixed K x) =
      values (inventory fixed K x) none x.graph.edges.length 0 := by
  have unitValues := unitInput_values fixed K x none x.graph.edges.length 0
  have edgeValues := edgeInput_values fixed K x none 0 0 x.graph.edges.length
  dsimp only [inventory, instantiate] at unitValues edgeValues ⊢
  unfold globalsInput
  rw [unitValues, prepared_globalCount fixed K x]
  exact edgeValues

theorem flagInput_eq (x : GraphReductionInput) :
    flagInput (values (inventory fixed K x) none x.graph.edges.length 0) =
      values (inventory fixed K x) none 0 0 :=
  flagInput_values fixed K x x.graph.edges.length

theorem flagsWord_eq (x : GraphReductionInput) :
    poolListWord fixed K (flagPools fixed)
      (flagInput (values (inventory fixed K x) none x.graph.edges.length 0))
      (preparedOther fixed K x) = rawRecords (flagStream (inventory fixed K x)) := by
  rw [flagInput_eq, flagPools_word]

end BinPackingGap.GraphPackingGlobalSemantics

namespace BinPackingGap.GraphPackingGlobalRuntime

open GraphPackingRegisters GraphPackingPreparation GraphPackingGlobalPhases
open GraphPackingPoolRuntime
open PackingItemExpression (denominator)
open BinPackingGames.Foundations.Complexity

variable (fixed : InventoryData) (K : Nat)

def adjustedWidthPolynomial : Polynomial Nat :=
  GraphPackingStockBounds.widthPolynomial fixed K + 1

def edgeWidthPolynomial : Polynomial Nat :=
  adjustedWidthPolynomial fixed K +
    Polynomial.X * GraphPackingStockBounds.widthPolynomial fixed K + 1

def resetPolynomial : Polynomial Nat :=
  (PackingLayoutCommands.setInputTime (Other := Other fixed K)
    (Numerator fixed) denominator .labelPower 0).comp (adjustedWidthPolynomial fixed K) +
  (PackingLayoutCommands.setInputTime (Other := Other fixed K)
    (Numerator fixed) denominator .repetitionOne 0).comp (adjustedWidthPolynomial fixed K) +
  (PackingLayoutCommands.setInputTime (Other := Other fixed K)
    (Numerator fixed) denominator .edgePower 1).comp (adjustedWidthPolynomial fixed K)

def edgeBodyPolynomial : Polynomial Nat :=
  poolPolynomial fixed (.w, .globalEdge true)
    (GraphPackingStockBounds.stockPolynomial fixed K) (edgeWidthPolynomial fixed K) +
  poolPolynomial fixed (.w, .globalEdge false)
    (GraphPackingStockBounds.stockPolynomial fixed K) (edgeWidthPolynomial fixed K) +
  Polynomial.C 64 * (GraphPackingStockBounds.widthPolynomial fixed K +
    edgeWidthPolynomial fixed K + 1) ^ 2 + 1

def flagsPolynomial : Polynomial Nat :=
  (PackingLayoutCommands.setInputTime (Other := Other fixed K)
    (Numerator fixed) denominator .edgePower 1).comp (adjustedWidthPolynomial fixed K) +
  poolListPolynomial fixed (flagPools fixed)
    (GraphPackingStockBounds.stockPolynomial fixed K) (adjustedWidthPolynomial fixed K) + 1

def globalsPolynomial : Polynomial Nat :=
  resetPolynomial fixed K +
  poolListPolynomial fixed (unitPools fixed)
    (GraphPackingStockBounds.stockPolynomial fixed K) (adjustedWidthPolynomial fixed K) +
  tallyPolynomial Polynomial.X + Polynomial.X * (edgeBodyPolynomial fixed K + 1) + 3

private theorem width_le (x : GraphReductionInput) :
    GraphPackingWidths.width fixed K x ≤
      (GraphPackingStockBounds.widthPolynomial fixed K).eval (graphBits x).length := by
  rw [GraphPackingStockBounds.widthPolynomial_eval]
  exact GraphPackingStockBounds.preparationWidth_le fixed K x

private theorem adjustedWidth_le (x : GraphReductionInput) :
    GraphPackingWidths.width fixed K x + 1 ≤
      (adjustedWidthPolynomial fixed K).eval (graphBits x).length := by
  simpa only [adjustedWidthPolynomial, Polynomial.eval_add, Polynomial.eval_one] using
    Nat.add_le_add_right (width_le fixed K x) 1

private theorem radixWidth_le (x : GraphReductionInput) :
    (GraphPackingGlobalLoop.radix fixed K (preparedOther fixed K x)).size ≤
      (GraphPackingStockBounds.widthPolynomial fixed K).eval (graphBits x).length :=
  GraphPackingStockBounds.preparedOther_size_le_polynomial fixed K x
    (GraphPackingProgram.otherSetup fixed K .base)

private theorem stockCount_le (x : GraphReductionInput) (stock : PackingSetupExpression.Output)
    (selected : stock ∈ [.upOne, .upZero, .umOne, .umZero, .edgeStock, .treeFlags, .jobFlags]) :
    preparedOther fixed K x (GraphPackingProgram.otherSetup fixed K stock) ≤
      (GraphPackingStockBounds.stockPolynomial fixed K).eval (graphBits x).length := by
  rw [GraphPackingGlobalSemantics.prepared_output]
  simp only [List.mem_cons, List.not_mem_nil, or_false] at selected
  rcases selected with rfl | rfl | rfl | rfl | rfl | rfl | rfl
  · exact GraphPackingStockBounds.globalStock_le_polynomial fixed K x (.up true)
  · exact GraphPackingStockBounds.globalStock_le_polynomial fixed K x (.up false)
  · exact GraphPackingStockBounds.globalStock_le_polynomial fixed K x (.um true)
  · exact GraphPackingStockBounds.globalStock_le_polynomial fixed K x (.um false)
  · have hm : 0 < x.graph.edges.length := by
      cases h : x.graph.edges with
      | nil => exact False.elim (x.nonempty h)
      | cons e rest => simp
    exact GraphPackingStockBounds.globalStock_le_polynomial fixed K x (.edge ⟨0, hm⟩ true)
  · exact GraphPackingStockBounds.flagStock_le_polynomial fixed K x .tree
  · exact GraphPackingStockBounds.flagStock_le_polynomial fixed K x .main

private theorem unitCounts_le (x : GraphReductionInput) :
    ∀ pool ∈ unitPools fixed,
      preparedOther fixed K x (GraphPackingProgram.otherSetup fixed K pool.1) ≤
        (GraphPackingStockBounds.stockPolynomial fixed K).eval (graphBits x).length := by
  intro pool hp
  simp only [unitPools, List.mem_cons, List.not_mem_nil, or_false] at hp
  rcases hp with rfl | rfl | rfl | rfl <;>
    exact stockCount_le fixed K x _ (by simp)

private theorem flagCounts_le (x : GraphReductionInput) :
    ∀ pool ∈ flagPools fixed,
      preparedOther fixed K x (GraphPackingProgram.otherSetup fixed K pool.1) ≤
        (GraphPackingStockBounds.stockPolynomial fixed K).eval (graphBits x).length := by
  intro pool hp
  simp only [flagPools, List.mem_cons, List.not_mem_nil, or_false] at hp
  rcases hp with rfl | rfl | rfl <;>
    exact stockCount_le fixed K x _ (by simp)

theorem aggregateWidth_le (x : GraphReductionInput) :
    GraphPackingGlobalLoop.aggregateWidth fixed K (preparedOther fixed K x)
      (GraphPackingWidths.width fixed K x + 1) 0
      (globalCount fixed K (preparedOther fixed K x)) ≤
      (edgeWidthPolynomial fixed K).eval (graphBits x).length := by
  have hw := adjustedWidth_le fixed K x
  have hm := Nat.mul_le_mul (graph_edgeCount_le_bits x) (radixWidth_le fixed K x)
  rw [GraphPackingGlobalLoop.aggregateWidth, GraphPackingGlobalSemantics.prepared_globalCount]
  simp only [Nat.zero_add, edgeWidthPolynomial, Polynomial.eval_add, Polynomial.eval_mul,
    Polynomial.eval_X, Polynomial.eval_one]
  omega

private theorem resetBudget_le (x : GraphReductionInput) :
    resetBudget fixed K (GraphPackingWidths.width fixed K x) ≤
      (resetPolynomial fixed K).eval (graphBits x).length := by
  have h₁ := MachineComposition.natPolynomial_eval_mono
    (PackingLayoutCommands.setInputTime (Other := Other fixed K)
      (Numerator fixed) denominator .labelPower 0) (adjustedWidth_le fixed K x)
  have h₂ := MachineComposition.natPolynomial_eval_mono
    (PackingLayoutCommands.setInputTime (Other := Other fixed K)
      (Numerator fixed) denominator .repetitionOne 0) (adjustedWidth_le fixed K x)
  have h₃ := MachineComposition.natPolynomial_eval_mono
    (PackingLayoutCommands.setInputTime (Other := Other fixed K)
      (Numerator fixed) denominator .edgePower 1) (adjustedWidth_le fixed K x)
  simpa only [resetBudget, resetPolynomial, Polynomial.eval_add, Polynomial.eval_comp] using
    Nat.add_le_add (Nat.add_le_add h₁ h₂) h₃

private theorem bodyBudget_le (x : GraphReductionInput) (width : Nat)
    (hw : width ≤ (edgeWidthPolynomial fixed K).eval (graphBits x).length) :
    GraphPackingGlobalLoop.bodyBudget fixed K (preparedOther fixed K x) width ≤
      (edgeBodyPolynomial fixed K).eval (graphBits x).length := by
  have hc := stockCount_le fixed K x .edgeStock (by simp)
  have h₁ := poolBudget_le fixed K .edgeStock (.w, .globalEdge true)
    (preparedOther fixed K x) width (GraphPackingStockBounds.stockPolynomial fixed K)
    (edgeWidthPolynomial fixed K) (graphBits x).length hc hw
  have h₂ := poolBudget_le fixed K .edgeStock (.w, .globalEdge false)
    (preparedOther fixed K x) width (GraphPackingStockBounds.stockPolynomial fixed K)
    (edgeWidthPolynomial fixed K) (graphBits x).length hc hw
  have hsquare := Nat.pow_le_pow_left
    (Nat.add_le_add_right (Nat.add_le_add (radixWidth_le fixed K x) hw) 1) 2
  have hmul := Nat.mul_le_mul_left 64 hsquare
  simp only [GraphPackingGlobalLoop.bodyBudget, edgeBodyPolynomial, Polynomial.eval_add,
    Polynomial.eval_mul, Polynomial.eval_C, Polynomial.eval_pow, Polynomial.eval_one]
  omega

theorem flagsBudget_le (x : GraphReductionInput) :
    flagsBudget fixed K (preparedOther fixed K x) (GraphPackingWidths.width fixed K x) ≤
      (flagsPolynomial fixed K).eval (graphBits x).length := by
  have hr := MachineComposition.natPolynomial_eval_mono
    (PackingLayoutCommands.setInputTime (Other := Other fixed K)
      (Numerator fixed) denominator .edgePower 1) (adjustedWidth_le fixed K x)
  have hp := poolListBudget_le fixed K (flagPools fixed) (preparedOther fixed K x)
    (GraphPackingWidths.width fixed K x + 1) (GraphPackingStockBounds.stockPolynomial fixed K)
    (adjustedWidthPolynomial fixed K) (graphBits x).length
    (flagCounts_le fixed K x) (adjustedWidth_le fixed K x)
  simpa only [flagsBudget, flagsPolynomial, Polynomial.eval_add, Polynomial.eval_comp,
    Polynomial.eval_one] using Nat.add_le_add_right (Nat.add_le_add hr hp) 1

theorem globalsBudget_le (x : GraphReductionInput) :
    globalsBudget fixed K (preparedOther fixed K x) (GraphPackingWidths.width fixed K x) ≤
      (globalsPolynomial fixed K).eval (graphBits x).length := by
  have hr := resetBudget_le fixed K x
  have hp := poolListBudget_le fixed K (unitPools fixed) (preparedOther fixed K x)
    (GraphPackingWidths.width fixed K x + 1) (GraphPackingStockBounds.stockPolynomial fixed K)
    (adjustedWidthPolynomial fixed K) (graphBits x).length
    (unitCounts_le fixed K x) (adjustedWidth_le fixed K x)
  have hc : globalCount fixed K (preparedOther fixed K x) ≤ (graphBits x).length := by
    rw [GraphPackingGlobalSemantics.prepared_globalCount]
    exact graph_edgeCount_le_bits x
  have ht := tally_le (globalCount fixed K (preparedOther fixed K x))
    (graphBits x).length Polynomial.X (by simpa only [Polynomial.eval_X] using hc)
  have hb := bodyBudget_le fixed K x _ (aggregateWidth_le fixed K x)
  have hl := Nat.mul_le_mul hc (Nat.add_le_add_right hb 1)
  simp only [globalsBudget, globalsPolynomial, Polynomial.eval_add, Polynomial.eval_mul,
    Polynomial.eval_X, Polynomial.eval_one, Polynomial.eval_ofNat]
  omega

end BinPackingGap.GraphPackingGlobalRuntime

namespace BinPackingGap.GraphPackingGlobalExecution

open FiniteTapeProgram PackingMachineBlocks GraphPackingRegisters GraphPackingPreparation
open PackingItemExpression (denominator)
open PackingMachineLayout
open PackingItemBlockMachine (outputTapes)

variable (fixed : InventoryData) (K : Nat)

theorem globals_exec (x : GraphReductionInput)
    (base : GraphPackingRegisters.Tape fixed K → List Bool) (state : State)
    (poolEmpty : base (.inr .poolCounter) = [])
    (edgeEmpty : base (.inr .edgeCounter) = []) :
    ∃ steps ≤ (GraphPackingGlobalRuntime.globalsPolynomial fixed K).eval (graphBits x).length,
      Exec (GraphPackingProgram.globals fixed K)
        ⟨state, tapes (Numerator fixed) denominator base
          (GraphPackingJobs.inputs fixed K x x.graph.edges.length) (preparedOther fixed K x)⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator
            (outputTapes (.inr .reverseOutput) base
              (PackingDescriptorExpression.rawRecords
                (PackingInventoryDescriptors.globalStream (GraphPackingJobs.inventory fixed K x))))
            (GraphPackingJobs.inputs fixed K x x.graph.edges.length) (preparedOther fixed K x)⟩ := by
  have counterZero : preparedOther fixed K x (.inr .counter) = 0 := rfl
  have oneZero : preparedOther fixed K x (.inr .one) = 0 := rfl
  have temporaryZero : preparedOther fixed K x (.inr .temporary) = 0 := rfl
  obtain ⟨steps, bound, run⟩ := GraphPackingGlobalPhases.globals_exec fixed K base
    (PackingDescriptorExpression.values (GraphPackingGlobalSemantics.inventory fixed K x)
      none x.graph.edges.length 0) (preparedOther fixed K x) state
    (GraphPackingWidths.width fixed K x) counterZero oneZero temporaryZero poolEmpty edgeEmpty
    (GraphPackingStockBounds.values_width fixed K x x.graph.edges.length le_rfl)
    (GraphPackingWidths.preparedOther_width fixed K x)
  refine ⟨steps, bound.trans (GraphPackingGlobalRuntime.globalsBudget_le fixed K x), ?_⟩
  rw [GraphPackingGlobalSemantics.globalsWord_eq,
    GraphPackingGlobalSemantics.globalsInput_eq] at run
  simpa only [GraphPackingJobs.inputs_eq_values, GraphPackingJobs.inventory,
    GraphPackingGlobalSemantics.inventory, PackingDescriptorExpression.instantiate] using run

theorem flags_exec (x : GraphReductionInput)
    (base : GraphPackingRegisters.Tape fixed K → List Bool) (state : State)
    (poolEmpty : base (.inr .poolCounter) = []) :
    ∃ steps ≤ (GraphPackingGlobalRuntime.flagsPolynomial fixed K).eval (graphBits x).length,
      Exec (GraphPackingProgram.flags fixed K)
        ⟨state, tapes (Numerator fixed) denominator base
          (GraphPackingJobs.inputs fixed K x x.graph.edges.length) (preparedOther fixed K x)⟩ steps
        ⟨.arithmetic (BinaryAddMachine.clean ()),
          tapes (Numerator fixed) denominator
            (outputTapes (.inr .reverseOutput) base
              (PackingDescriptorExpression.rawRecords
                (PackingInventoryDescriptors.flagStream (GraphPackingJobs.inventory fixed K x))))
            (GraphPackingJobs.inputs fixed K x 0) (preparedOther fixed K x)⟩ := by
  have counterZero : preparedOther fixed K x (.inr .counter) = 0 := rfl
  have oneZero : preparedOther fixed K x (.inr .one) = 0 := rfl
  have temporaryZero : preparedOther fixed K x (.inr .temporary) = 0 := rfl
  obtain ⟨steps, bound, run⟩ := GraphPackingGlobalPhases.flags_exec fixed K base
    (PackingDescriptorExpression.values (GraphPackingGlobalSemantics.inventory fixed K x)
      none x.graph.edges.length 0) (preparedOther fixed K x) state
    (GraphPackingWidths.width fixed K x) counterZero oneZero temporaryZero poolEmpty
    (GraphPackingStockBounds.values_width fixed K x x.graph.edges.length le_rfl)
    (GraphPackingWidths.preparedOther_width fixed K x)
  refine ⟨steps, bound.trans (GraphPackingGlobalRuntime.flagsBudget_le fixed K x), ?_⟩
  rw [GraphPackingGlobalSemantics.flagsWord_eq, GraphPackingGlobalSemantics.flagInput_eq] at run
  simpa only [GraphPackingJobs.inputs_eq_values, GraphPackingJobs.inventory,
    GraphPackingGlobalSemantics.inventory, PackingDescriptorExpression.instantiate] using run

end BinPackingGap.GraphPackingGlobalExecution

end

end OAI