| import OAI.Computability.BinPacking.CookLevin.PaddingCellsMachine |
| import OAI.Computability.BinPacking.CookLevin.PayloadPresenceMachine |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.PayloadCellsMachine |
|
|
| open Turing MachineComposition PostfixModel InitializationTemplate |
| open ClashMachine (State clean emitted) |
| open PayloadPresenceMachine (Ports Ready) |
|
|
| variable {K Λ σ : Type} [DecidableEq K] |
|
|
| abbrev Alphabet (_ : K) := Bool |
|
|
| private theorem chain {A : Type*} {f : A → A} {x y z : A} {n m : Nat} |
| (first : f^[n] x = y) (second : f^[m] y = z) : f^[n + m] x = z := by |
| rw [Nat.add_comm n m, Function.iterate_add_apply, first, second] |
|
|
| structure SymbolSpec where |
| isInput : Bool |
| trueValue : Bool |
| falseValue : Bool |
| absentValue : Bool |
| deriving DecidableEq, Fintype |
|
|
| def payloadTokens (address : Nat) (yes no : Bool) : List Token := |
| [.input address, .const yes, .and, .input address, .not, .const no, .and, .or] |
|
|
| def symbolTokens (spec : SymbolSpec) (q i : Nat) : List Token := |
| if spec.isInput then |
| muxTokens (presenceTokens q i) (payloadTokens (q + 1 + i) spec.trueValue spec.falseValue) |
| [.const spec.absentValue] |
| else [.const spec.absentValue] |
|
|
| namespace Payload |
|
|
| def inputMap : Fin 4 ↪ Fin 9 := ⟨![3, 5, 7, 8], by decide⟩ |
|
|
| inductive Label where |
| | seed | scanQ | restoreQ | scanI | restoreI |
| | inputTrue (l : ClashMachine.Input.Label) |
| | middle |
| | inputFalse (l : ClashMachine.Input.Label) |
| | suffix | drain |
| deriving DecidableEq, Fintype |
|
|
| def statement (slots : Ports K) (labels : Label → Λ) (exit : Option Λ) (yes no : Bool) : |
| Label → TM2.Stmt (Alphabet (K := K)) Λ (State σ) |
| | .seed => MachineUnaryAffineAt.seed (slots 3) 1 (labels .scanQ) |
| | .scanQ => MachineUnaryAffineAt.scan (slots 0) (slots 5) (slots 3) 1 |
| (labels .scanQ) (labels .restoreQ) |
| | .restoreQ => Reduction.MachineTransfer.loopAt (slots 5) (slots 0) id false |
| (labels .restoreQ) (some (labels .scanI)) |
| | .scanI => MachineUnaryAffineAt.scan (slots 1) (slots 5) (slots 3) 1 |
| (labels .scanI) (labels .restoreI) |
| | .restoreI => Reduction.MachineTransfer.loopAt (slots 5) (slots 1) id false |
| (labels .restoreI) (some (labels (.inputTrue .tag))) |
| | .inputTrue l => ClashMachine.Input.statement (inputMap.trans slots) |
| (fun l => labels (.inputTrue l)) (some (labels .middle)) l |
| | .middle => ClashMachine.literal (slots 7) (slots 8) [.const yes, .and] |
| (.goto fun _ => labels (.inputFalse .tag)) |
| | .inputFalse l => ClashMachine.Input.statement (inputMap.trans slots) |
| (fun l => labels (.inputFalse l)) (some (labels .suffix)) l |
| | .suffix => ClashMachine.literal (slots 7) (slots 8) [.not, .const no, .and, .or] |
| (.goto fun _ => labels .drain) |
| | .drain => MachineDrain.drain (slots 3) (labels .drain) exit |
|
|
| def addressSteps (q i : Nat) := (2 * (q + 1) + 1) + 2 * (i + 1) |
|
|
| theorem addressTrace (slots : Ports K) (labels : Label → Λ) (exit : Option Λ) (yes no : Bool) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (atLabels : ∀ l, program (labels l) = statement slots labels exit yes no l) |
| (base : K → List Bool) (q i : Nat) (ready : Ready slots base q i) (ambient : σ) : |
| (advance (TM2.step program))^[addressSteps q i] |
| (some ⟨some (labels .seed), clean ambient, base⟩) = |
| some ⟨some (labels (.inputTrue .tag)), clean ambient, |
| Function.update base (slots 3) (encodeWord (q + 1 + i))⟩ := by |
| have e₃ := ready.empty 3 (by decide) (by decide) (by decide) (by decide) |
| have e₅ := ready.empty 5 (by decide) (by decide) (by decide) (by decide) |
| have hq := MachineUnaryAffineAt.seededAffineTrace (slots 0) (slots 5) (slots 3) |
| (slots.injective.ne (by decide)) (slots.injective.ne (by decide)) |
| (slots.injective.ne (by decide)) 1 1 (labels .seed) (labels .scanQ) (labels .restoreQ) |
| (some (labels .scanI)) program (atLabels .seed) (atLabels .scanQ) (atLabels .restoreQ) |
| base q [] (by simpa using ready.boundWord) e₅ (ambient, false) none |
| simp only [Nat.one_mul, e₃, List.append_nil] at hq |
| let addressed := Function.update base (slots 3) (encodeWord (q + 1)) |
| have hi := MachineUnaryAffineAt.affineTrace (slots 1) (slots 5) (slots 3) |
| (slots.injective.ne (by decide)) (slots.injective.ne (by decide)) |
| (slots.injective.ne (by decide)) 1 (labels .scanI) (labels .restoreI) |
| (some (labels (.inputTrue .tag))) program (atLabels .scanI) (atLabels .restoreI) |
| addressed i (q + 1) [] [] (ambient, false) none |
| have hframe (n : Nat) : MachineUnaryAffineAt.tapes (slots 1) (slots 5) (slots 3) |
| addressed (encodeWord i ++ []) [] (encodeWord n ++ []) = |
| Function.update base (slots 3) (encodeWord n) := by |
| simp only [MachineUnaryAffineAt.tapes, MachineCopy.forkTapes, List.append_nil] |
| apply ClashMachine.Full.ext_slots slots |
| · intro j |
| fin_cases j <;> simp [addressed, slots.injective.eq_iff, ready.indexWord, e₅] |
| · intro k hk |
| simp [addressed, hk] |
| rw [hframe, hframe] at hi |
| rw [show 1 * i + (q + 1) = q + 1 + i by omega] at hi |
| exact chain hq hi |
| |
| def steps (q i : Nat) : Nat := addressSteps q i + ClashMachine.Input.steps (q + 1 + i) + 1 + |
| ClashMachine.Input.steps (q + 1 + i) + 1 + (q + 1 + i + 2) |
|
|
| theorem trace (slots : Ports K) (labels : Label → Λ) (exit : Option Λ) (yes no : Bool) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (atLabels : ∀ l, program (labels l) = statement slots labels exit yes no l) |
| (base : K → List Bool) (q i : Nat) (ready : Ready slots base q i) (ambient : σ) : |
| (advance (TM2.step program))^[steps q i] |
| (some ⟨some (labels .seed), clean ambient, base⟩) = |
| some ⟨exit, clean ambient, |
| emitted (slots 7) (slots 8) base (payloadTokens (q + 1 + i) yes no)⟩ := by |
| have e₃ := ready.empty 3 (by decide) (by decide) (by decide) (by decide) |
| have e₅ := ready.empty 5 (by decide) (by decide) (by decide) (by decide) |
| let address := q + 1 + i |
| let b₀ := Function.update base (slots 3) (encodeWord address) |
| have ha := addressTrace slots labels exit yes no program atLabels base q i ready ambient |
| have ht := ClashMachine.Input.trace (inputMap.trans slots) (fun l => labels (.inputTrue l)) |
| (some (labels .middle)) program (fun _ => atLabels _) b₀ address |
| (by simp [b₀, inputMap]) (by simpa [b₀, inputMap, slots.injective.eq_iff] using e₅) ambient |
| let b₁ := emitted (slots 7) (slots 8) b₀ [.input address] |
| have hm : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .middle), clean ambient, b₁⟩) = |
| some ⟨some (labels (.inputFalse .tag)), clean ambient, |
| emitted (slots 7) (slots 8) b₁ [.const yes, .and]⟩ := by |
| change some (TM2.stepAux (program (labels .middle)) _ _) = _ |
| rw [atLabels, statement, ClashMachine.stepAux_literal (slots 7) (slots 8) |
| (slots.injective.ne (by decide : (7 : Fin 9) ≠ 8))] |
| rfl |
| let b₂ := emitted (slots 7) (slots 8) b₁ [.const yes, .and] |
| have hf := ClashMachine.Input.trace (inputMap.trans slots) (fun l => labels (.inputFalse l)) |
| (some (labels .suffix)) program (fun _ => atLabels _) b₂ address |
| (by simp [b₂, b₁, b₀, inputMap, emitted, slots.injective.eq_iff]) |
| (by simpa [b₂, b₁, b₀, inputMap, emitted, slots.injective.eq_iff] using e₅) ambient |
| let b₃ := emitted (slots 7) (slots 8) b₂ [.input address] |
| have hs : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .suffix), clean ambient, b₃⟩) = |
| some ⟨some (labels .drain), clean ambient, |
| emitted (slots 7) (slots 8) b₃ [.not, .const no, .and, .or]⟩ := by |
| change some (TM2.stepAux (program (labels .suffix)) _ _) = _ |
| rw [atLabels, statement, ClashMachine.stepAux_literal (slots 7) (slots 8) |
| (slots.injective.ne (by decide : (7 : Fin 9) ≠ 8))] |
| rfl |
| let b₄ := emitted (slots 7) (slots 8) b₃ [.not, .const no, .and, .or] |
| have hword : b₄ (slots 3) = encodeWord address := by |
| simp [b₄, b₃, b₂, b₁, b₀, emitted, slots.injective.eq_iff] |
| have hd := MachineDrain.drainTrace (slots 3) (labels .drain) exit program (atLabels .drain) |
| b₄ (encodeWord address) (ambient, false) none |
| rw [← hword, Function.update_eq_self] at hd |
| rw [hword, encodeWord_length] at hd |
| have hfinish : Function.update b₄ (slots 3) [] = |
| emitted (slots 7) (slots 8) base (payloadTokens address yes no) := by |
| have hb : b₄ = emitted (slots 7) (slots 8) b₀ (payloadTokens address yes no) := by |
| simp only [b₄, b₃, b₂, b₁, ClashMachine.emitted_append (slots 7) (slots 8) |
| (slots.injective.ne (by decide : (7 : Fin 9) ≠ 8))] |
| rfl |
| rw [hb] |
| apply ClashMachine.Full.ext_slots slots |
| · intro j |
| fin_cases j <;> simp [b₀, emitted, slots.injective.eq_iff, e₃] |
| · intro k hk |
| simp [b₀, emitted, hk] |
| rw [hfinish] at hd |
| exact chain (chain (chain (chain (chain ha ht) hm) hf) hs) hd |
| |
| theorem steps_le (q i : Nat) (hi : i < q) : steps q i ≤ 40 * (q + 2) := by |
| unfold steps addressSteps ClashMachine.Input.steps |
| omega |
|
|
| end Payload |
|
|
| namespace Symbol |
|
|
| inductive Label where |
| | start |
| | first (l : PayloadPresenceMachine.Label) |
| | payload (l : Payload.Label) |
| | conjunction |
| | second (l : PayloadPresenceMachine.Label) |
| | suffix |
| deriving DecidableEq, Fintype |
|
|
| def firstLabels : PayloadPresenceMachine.Label ↪ Label := ⟨.first, fun _ _ h => by cases h; rfl⟩ |
| def secondLabels : PayloadPresenceMachine.Label ↪ Label := ⟨.second, fun _ _ h => by cases h; rfl⟩ |
| |
| def statement (slots : Ports K) (labels : Label ↪ Λ) (exit : Option Λ) (spec : SymbolSpec) : |
| Label → TM2.Stmt (Alphabet (K := K)) Λ (State σ) |
| | .start => if spec.isInput then .goto fun _ => labels (.first .initialize) |
| else ClashMachine.literal (slots 7) (slots 8) [.const spec.absentValue] |
| (Reduction.MachineTransfer.exitAt (slots 7) exit) |
| | .first l => PayloadPresenceMachine.statement slots (firstLabels.trans labels) |
| (some (labels (.payload .seed))) l |
| | .payload l => Payload.statement slots (fun l => labels (.payload l)) |
| (some (labels .conjunction)) spec.trueValue spec.falseValue l |
| | .conjunction => ClashMachine.literal (slots 7) (slots 8) [.and] |
| (.goto fun _ => labels (.second .initialize)) |
| | .second l => PayloadPresenceMachine.statement slots (secondLabels.trans labels) |
| (some (labels .suffix)) l |
| | .suffix => ClashMachine.literal (slots 7) (slots 8) [.not, .const spec.absentValue, .and, .or] |
| (Reduction.MachineTransfer.exitAt (slots 7) exit) |
|
|
| def steps (spec : SymbolSpec) (q i : Nat) : Nat := |
| if spec.isInput then |
| 1 + PayloadPresenceMachine.steps q i + Payload.steps q i + 1 + PayloadPresenceMachine.steps q i + 1 |
| else 1 |
|
|
| theorem trace (slots : Ports K) (labels : Label ↪ Λ) (exit : Option Λ) (spec : SymbolSpec) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (atLabels : ∀ l, program (labels l) = statement slots labels exit spec l) |
| (base : K → List Bool) (q i : Nat) (hi : i < q) |
| (ready : Ready slots base q i) (ambient : σ) : |
| (advance (TM2.step program))^[steps spec q i] |
| (some ⟨some (labels .start), clean ambient, base⟩) = |
| some ⟨exit, clean ambient, emitted (slots 7) (slots 8) base (symbolTokens spec q i)⟩ := by |
| cases hspec : spec.isInput with |
| | false => |
| simp only [steps, hspec, Bool.false_eq_true, ↓reduceIte] |
| change some (TM2.stepAux (program (labels .start)) _ _) = _ |
| rw [atLabels, statement, hspec] |
| simp only [Bool.false_eq_true, ↓reduceIte] |
| rw [ClashMachine.stepAux_literal (slots 7) (slots 8) |
| (slots.injective.ne (by decide : (7 : Fin 9) ≠ 8))] |
| cases exit <;> simp [Reduction.MachineTransfer.exitAt, TM2.stepAux, symbolTokens, hspec] |
| | true => |
| have hs : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .start), clean ambient, base⟩) = |
| some ⟨some (labels (.first .initialize)), clean ambient, base⟩ := by |
| change some (TM2.stepAux (program (labels .start)) _ _) = _ |
| rw [atLabels, statement, hspec] |
| rfl |
| have h₁ := PayloadPresenceMachine.trace slots (firstLabels.trans labels) |
| (some (labels (.payload .seed))) program (fun _ => atLabels _) base q i hi ready ambient |
| let b₁ := emitted (slots 7) (slots 8) base (presenceTokens q i) |
| have hp := Payload.trace slots (fun l => labels (.payload l)) (some (labels .conjunction)) |
| spec.trueValue spec.falseValue program (fun _ => atLabels _) |
| b₁ q i (ready.emitted (presenceTokens q i)) ambient |
| let b₂ := emitted (slots 7) (slots 8) b₁ (payloadTokens (q + 1 + i) spec.trueValue spec.falseValue) |
| have hc : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .conjunction), clean ambient, b₂⟩) = |
| some ⟨some (labels (.second .initialize)), clean ambient, |
| emitted (slots 7) (slots 8) b₂ [.and]⟩ := by |
| change some (TM2.stepAux (program (labels .conjunction)) _ _) = _ |
| rw [atLabels, statement, ClashMachine.stepAux_literal (slots 7) (slots 8) |
| (slots.injective.ne (by decide : (7 : Fin 9) ≠ 8))] |
| rfl |
| let b₃ := emitted (slots 7) (slots 8) b₂ [.and] |
| have r₃ : Ready slots b₃ q i := |
| ((ready.emitted (presenceTokens q i)).emitted |
| (payloadTokens (q + 1 + i) spec.trueValue spec.falseValue)).emitted [.and] |
| have h₂ := PayloadPresenceMachine.trace slots (secondLabels.trans labels) |
| (some (labels .suffix)) program (fun _ => atLabels _) b₃ q i hi r₃ ambient |
| let b₄ := emitted (slots 7) (slots 8) b₃ (presenceTokens q i) |
| have hf : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .suffix), clean ambient, b₄⟩) = |
| some ⟨exit, clean ambient, |
| emitted (slots 7) (slots 8) b₄ [.not, .const spec.absentValue, .and, .or]⟩ := by |
| change some (TM2.stepAux (program (labels .suffix)) _ _) = _ |
| rw [atLabels, statement, ClashMachine.stepAux_literal (slots 7) (slots 8) |
| (slots.injective.ne (by decide : (7 : Fin 9) ≠ 8))] |
| cases exit <;> rfl |
| have h := chain (chain (chain (chain (chain hs h₁) hp) hc) h₂) hf |
| simpa only [steps, hspec, ↓reduceIte, b₄, b₃, b₂, b₁, |
| ClashMachine.emitted_append (slots 7) (slots 8) |
| (slots.injective.ne (by decide : (7 : Fin 9) ≠ 8)), symbolTokens, muxTokens, |
| List.append_assoc, List.singleton_append, List.cons_append, List.nil_append] using h |
|
|
| theorem steps_le (spec : SymbolSpec) (q i : Nat) (hi : i < q) : |
| steps spec q i ≤ 120 * (q + 2) ^ 2 := by |
| have hq : q + 2 ≤ (q + 2) ^ 2 := by nlinarith |
| have hp := Payload.steps_le q i hi |
| have hc := PayloadPresenceMachine.steps_le q i hi |
| unfold steps |
| split <;> omega |
| |
| end Symbol |
| |
| namespace Row |
| |
| variable {A : Nat} |
|
|
| def tableAt (table : Fin A → SymbolSpec) (j : Nat) : SymbolSpec := |
| if hj : j < A then table ⟨j, hj⟩ else ⟨false, false, false, false⟩ |
|
|
| def tokensFrom (table : Fin A → SymbolSpec) (q i start count : Nat) : List Token := |
| forTokens count (fun j => symbolTokens (tableAt table (start + j)) q i) |
|
|
| def tokens (table : Fin A → SymbolSpec) (q i : Nat) : List Token := tokensFrom table q i 0 A |
|
|
| theorem tokensFrom_succ (table : Fin A → SymbolSpec) (q i start count : Nat) : |
| tokensFrom table q i start (count + 1) = |
| symbolTokens (tableAt table start) q i ++ tokensFrom table q i (start + 1) count := by |
| rw [tokensFrom, forTokens_succ_first] |
| simp only [Nat.add_zero] |
| apply congrArg (List.append (symbolTokens (tableAt table start) q i)) |
| apply forTokens_congr |
| intro j _ |
| rw [show start + (j + 1) = start + 1 + j by omega] |
|
|
| theorem tokens_eq_ofFn (table : Fin A → SymbolSpec) (q i : Nat) : |
| tokens table q i = (List.ofFn fun j : Fin A => symbolTokens (table j) q i).flatten := by |
| rw [tokens, tokensFrom, forTokens_eq_ofFn] |
| congr 1 |
| congr 1 |
| funext j |
| simp [tableAt, j.isLt] |
|
|
| inductive Label (A : Nat) where |
| | visit (j : Fin (A + 1)) |
| | symbol (j : Fin A) (l : Symbol.Label) |
| deriving DecidableEq, Fintype |
|
|
| def symbolLabels (j : Fin A) : Symbol.Label ↪ Label A := |
| ⟨Label.symbol j, fun _ _ h => by cases h; rfl⟩ |
| |
| def statement (slots : Ports K) (labels : Label A ↪ Λ) (exit : Option Λ) |
| (table : Fin A → SymbolSpec) : Label A → TM2.Stmt (Alphabet (K := K)) Λ (State σ) |
| | .visit j => if hj : j.val < A then .goto fun _ => labels (.symbol ⟨j.val, hj⟩ .start) |
| else Reduction.MachineTransfer.exitAt (slots 7) exit |
| | .symbol j l => Symbol.statement slots ((symbolLabels j).trans labels) |
| (some (labels (.visit ⟨j.val + 1, by omega⟩))) (table j) l |
|
|
| def stepsFrom (table : Fin A → SymbolSpec) (q i : Nat) : Nat → Nat → Nat |
| | _, 0 => 1 |
| | start, count + 1 => 1 + Symbol.steps (tableAt table start) q i + stepsFrom table q i (start + 1) count |
|
|
| def steps (table : Fin A → SymbolSpec) (q i : Nat) : Nat := stepsFrom table q i 0 A |
|
|
| theorem traceFrom (slots : Ports K) (labels : Label A ↪ Λ) (exit : Option Λ) |
| (table : Fin A → SymbolSpec) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (atLabels : ∀ l, program (labels l) = statement slots labels exit table l) |
| (base : K → List Bool) (q i : Nat) (hi : i < q) (ready : Ready slots base q i) |
| (ambient : σ) (start count : Nat) (hfinish : start + count = A) : |
| (advance (TM2.step program))^[stepsFrom table q i start count] |
| (some ⟨some (labels (.visit ⟨start, by omega⟩)), clean ambient, base⟩) = |
| some ⟨exit, clean ambient, emitted (slots 7) (slots 8) base (tokensFrom table q i start count)⟩ := by |
| induction count generalizing start base with |
| | zero => |
| have hstart : start = A := by omega |
| change some (TM2.stepAux (program (labels (.visit ⟨start, by omega⟩))) _ _) = _ |
| rw [atLabels, statement, dite_eq_right (show ¬ start < A by omega)] |
| cases exit <;> simp [TM2.stepAux, Reduction.MachineTransfer.exitAt, |
| tokensFrom, forTokens, ClashMachine.emitted_nil] |
| | succ count ih => |
| have hstart : start < A := by omega |
| let j : Fin A := ⟨start, hstart⟩ |
| have hv : (advance (TM2.step program))^[1] |
| (some ⟨some (labels (.visit ⟨start, by omega⟩)), clean ambient, base⟩) = |
| some ⟨some (labels (.symbol j .start)), clean ambient, base⟩ := by |
| change some (TM2.stepAux (program (labels (.visit ⟨start, by omega⟩))) _ _) = _ |
| rw [atLabels, statement, dite_eq_left hstart] |
| rfl |
| have hs := Symbol.trace slots ((symbolLabels j).trans labels) |
| (some (labels (.visit ⟨start + 1, by omega⟩))) (table j) program |
| (fun l => atLabels (.symbol j l)) base q i hi ready ambient |
| let nextBase := emitted (slots 7) (slots 8) base (symbolTokens (table j) q i) |
| have hn := ih nextBase (ready.emitted (symbolTokens (table j) q i)) (start + 1) (by omega) |
| have h := chain (chain hv hs) hn |
| have ht : tableAt table start = table j := dite_eq_left hstart |
| simpa only [stepsFrom, tokensFrom_succ, ht, nextBase, |
| ClashMachine.emitted_append (slots 7) (slots 8) |
| (slots.injective.ne (by decide : (7 : Fin 9) ≠ 8))] using h |
|
|
| theorem trace (slots : Ports K) (labels : Label A ↪ Λ) (exit : Option Λ) |
| (table : Fin A → SymbolSpec) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (atLabels : ∀ l, program (labels l) = statement slots labels exit table l) |
| (base : K → List Bool) (q i : Nat) (hi : i < q) (ready : Ready slots base q i) (ambient : σ) : |
| (advance (TM2.step program))^[steps table q i] |
| (some ⟨some (labels (.visit 0)), clean ambient, base⟩) = |
| some ⟨exit, clean ambient, emitted (slots 7) (slots 8) base (tokens table q i)⟩ := by |
| exact traceFrom slots labels exit table program atLabels base q i hi ready ambient 0 A (by omega) |
|
|
| theorem stepsFrom_le (table : Fin A → SymbolSpec) (q i start count : Nat) (hi : i < q) : |
| stepsFrom table q i start count ≤ count * (120 * (q + 2) ^ 2 + 1) + 1 := by |
| induction count generalizing start with |
| | zero => simp [stepsFrom] |
| | succ count ih => |
| have hs := Symbol.steps_le (tableAt table start) q i hi |
| have hr := ih (start + 1) |
| rw [stepsFrom, Nat.succ_mul] |
| omega |
|
|
| theorem steps_le (table : Fin A → SymbolSpec) (q i : Nat) (hi : i < q) : |
| steps table q i ≤ A * (120 * (q + 2) ^ 2 + 1) + 1 := stepsFrom_le table q i 0 A hi |
|
|
| def inTime (slots : Ports K) (labels : Label A ↪ Λ) (exit : Option Λ) |
| (table : Fin A → SymbolSpec) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (atLabels : ∀ l, program (labels l) = statement slots labels exit table l) |
| (base : K → List Bool) (q i : Nat) (hi : i < q) (ready : Ready slots base q i) (ambient : σ) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (labels (.visit 0)), clean ambient, base⟩ |
| (some ⟨exit, clean ambient, emitted (slots 7) (slots 8) base (tokens table q i)⟩) |
| (A * (120 * (q + 2) ^ 2 + 1) + 1) where |
| steps := steps table q i |
| evals_in_steps := by |
| change (advance (TM2.step program))^[steps table q i] _ = _ |
| exact trace slots labels exit table program atLabels base q i hi ready ambient |
| steps_le_m := steps_le table q i hi |
|
|
| variable [Fintype K] [Fintype σ] |
|
|
| def machine (slots : Ports K) (table : Fin A → SymbolSpec) (ambient : σ) : FinTM2 where |
| K := K |
| k₀ := slots 0 |
| k₁ := slots 7 |
| Γ := Alphabet |
| Λ := Label A |
| main := .visit 0 |
| σ := State σ |
| initialState := clean ambient |
| Γk₀Fin := inferInstance |
| m := statement slots (Function.Embedding.refl _) none table |
|
|
| def machineInTime (slots : Ports K) (table : Fin A → SymbolSpec) |
| (base : K → List Bool) (q i : Nat) (hi : i < q) |
| (ready : Ready slots base q i) (ambient : σ) : |
| StateTransition.EvalsToInTime (machine slots table ambient).step |
| ⟨some (.visit 0), clean ambient, base⟩ |
| (some ⟨none, clean ambient, emitted (slots 7) (slots 8) base (tokens table q i)⟩) |
| (A * (120 * (q + 2) ^ 2 + 1) + 1) := |
| inTime slots (Function.Embedding.refl _) none table (machine slots table ambient).m |
| (fun _ => rfl) base q i hi ready ambient |
|
|
| end Row |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.PayloadCellsMachine |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.PayloadRowsLoop |
|
|
| open Turing MachineComposition PostfixModel InitializationTemplate |
| open ClashMachine (State clean emitted emitted_append) |
| open PayloadCellsMachine (SymbolSpec) |
|
|
| variable {K Λ σ : Type} [DecidableEq K] {A : Nat} |
|
|
| abbrev Ports (K : Type) := Fin 11 ↪ K |
| abbrev Alphabet (_ : K) := Bool |
|
|
| def rowMap : Fin 9 ↪ Fin 11 where |
| toFun i := ⟨i.val, by omega⟩ |
| inj' := by |
| intro i j h |
| exact Fin.ext (congrArg (fun x : Fin 11 => x.val) h) |
|
|
| def rowPorts (p : Ports K) : PayloadPresenceMachine.Ports K := rowMap.trans p |
|
|
| def frame (p : Ports K) (base : K → List Bool) (remaining index capacity : Nat) : K → List Bool := |
| Function.update (Function.update (Function.update base (p 1) (encodeWord index)) |
| (p 9) (encodeWord remaining)) (p 10) (encodeWord capacity) |
|
|
| @[simp] theorem frame_index (p : Ports K) (base : K → List Bool) (m i c : Nat) : |
| frame p base m i c (p 1) = encodeWord i := by simp [frame, p.injective.eq_iff] |
|
|
| @[simp] theorem frame_remaining (p : Ports K) (base : K → List Bool) (m i c : Nat) : |
| frame p base m i c (p 9) = encodeWord m := by simp [frame, p.injective.eq_iff] |
|
|
| @[simp] theorem frame_capacity (p : Ports K) (base : K → List Bool) (m i c : Nat) : |
| frame p base m i c (p 10) = encodeWord c := by simp [frame] |
|
|
| private theorem ext_ports (p : Ports K) {f g : K → List Bool} |
| (atPorts : ∀ j, f (p j) = g (p j)) |
| (outside : ∀ k, (∀ j, k ≠ p j) → f k = g k) : f = g := by |
| funext k |
| by_cases hk : ∃ j, p j = k |
| · obtain ⟨j, rfl⟩ := hk |
| exact atPorts j |
| · exact outside k (fun j h => hk ⟨j, h.symm⟩) |
|
|
| theorem update_remaining (p : Ports K) (base : K → List Bool) (m i c r : Nat) : |
| Function.update (frame p base m i c) (p 9) (encodeWord r) = frame p base r i c := by |
| apply ext_ports p |
| · intro j |
| fin_cases j <;> simp [frame, p.injective.eq_iff] |
| · intro k hk |
| simp [frame, hk] |
| |
| theorem update_index (p : Ports K) (base : K → List Bool) (m i c r : Nat) : |
| Function.update (frame p base m i c) (p 1) (encodeWord r) = frame p base m r c := by |
| apply ext_ports p |
| · intro j |
| fin_cases j <;> simp [frame, p.injective.eq_iff] |
| · intro k hk |
| simp [frame, hk] |
| |
| theorem update_capacity (p : Ports K) (base : K → List Bool) (m i c r : Nat) : |
| Function.update (frame p base m i c) (p 10) (encodeWord r) = frame p base m i r := by |
| simp [frame] |
|
|
| theorem frame_emitted (p : Ports K) (base : K → List Bool) (m i c : Nat) (tokens : List Token) : |
| emitted (p 7) (p 8) (frame p base m i c) tokens = |
| frame p (emitted (p 7) (p 8) base tokens) m i c := by |
| apply ext_ports p |
| · intro j |
| fin_cases j <;> simp [frame, emitted, p.injective.eq_iff] |
| · intro k hk |
| simp [frame, emitted, hk] |
| |
| theorem frame_ready (p : Ports K) (base : K → List Bool) (q m i c : Nat) |
| (ready : PayloadPresenceMachine.Ready (rowPorts p) base q 0) : |
| PayloadPresenceMachine.Ready (rowPorts p) (frame p base m i c) q i := by |
| constructor |
| · change frame p base m i c (p 0) = encodeWord q |
| have boundWord : base (p 0) = encodeWord q := ready.boundWord |
| simpa [frame, p.injective.eq_iff] using boundWord |
| · exact frame_index p base m i c |
| · intro j h₀ h₁ h₇ h₈ |
| have h1 : rowMap j ≠ (1 : Fin 11) := by |
| intro h |
| apply h₁ |
| exact Fin.ext (congrArg (fun x : Fin 11 => x.val) h) |
| have h9 : rowMap j ≠ (9 : Fin 11) := by |
| intro h |
| have hv := congrArg (fun x : Fin 11 => x.val) h |
| change j.val = 9 at hv |
| omega |
| have h10 : rowMap j ≠ (10 : Fin 11) := by |
| intro h |
| have hv := congrArg (fun x : Fin 11 => x.val) h |
| change j.val = 10 at hv |
| omega |
| simpa only [rowPorts, Function.Embedding.trans_apply, frame, |
| Function.update_of_ne (p.injective.ne h10), Function.update_of_ne (p.injective.ne h9), |
| Function.update_of_ne (p.injective.ne h1)] using ready.empty j h₀ h₁ h₇ h₈ |
|
|
| inductive Label (symbols : Nat) |
| | guard | next |
| | row (entry : PayloadCellsMachine.Row.Label symbols) |
| deriving DecidableEq, Fintype |
|
|
| def rowLabels (label : Label A ↪ Λ) : PayloadCellsMachine.Row.Label A ↪ Λ where |
| toFun entry := label (.row entry) |
| inj' := by intro i j h; exact Label.row.inj (label.injective h) |
| |
| def statement (p : Ports K) (label : Label A ↪ Λ) (exit : Λ) |
| (table : Fin A → SymbolSpec) : Label A → TM2.Stmt (Alphabet (K := K)) Λ (State σ) |
| | .guard => MachineUnaryCounter.guard (p 9) (label (.row (.visit 0))) exit |
| | .next => .pop (p 10) (fun state _ => state) |
| (.push (p 1) (fun _ => true) (.goto fun _ => label .guard)) |
| | .row entry => PayloadCellsMachine.Row.statement (rowPorts p) (rowLabels label) |
| (some (label .next)) table entry |
|
|
| def Agrees (p : Ports K) (label : Label A ↪ Λ) (exit : Λ) (table : Fin A → SymbolSpec) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) : Prop := |
| ∀ entry, program (label entry) = statement p label exit table entry |
|
|
| theorem guardStep_zero (p : Ports K) (label : Label A ↪ Λ) (exit : Λ) |
| (table : Fin A → SymbolSpec) (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (ha : Agrees p label exit table program) (base : K → List Bool) (i c : Nat) (ambient : σ) : |
| TM2.step program ⟨some (label .guard), clean ambient, frame p base 0 i c⟩ = |
| some ⟨some exit, clean ambient, frame p base 0 i c⟩ := by |
| change some (TM2.stepAux (program (label .guard)) _ _) = _ |
| rw [ha .guard] |
| simp [statement, MachineUnaryCounter.guard, TM2.stepAux, clean, encodeWord] |
|
|
| theorem guardStep_succ (p : Ports K) (label : Label A ↪ Λ) (exit : Λ) |
| (table : Fin A → SymbolSpec) (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (ha : Agrees p label exit table program) (base : K → List Bool) (m i c : Nat) (ambient : σ) : |
| TM2.step program ⟨some (label .guard), clean ambient, frame p base (m + 1) i c⟩ = |
| some ⟨some (label (.row (.visit 0))), clean ambient, frame p base m i c⟩ := by |
| change some (TM2.stepAux (program (label .guard)) _ _) = _ |
| rw [ha .guard] |
| simp [statement, MachineUnaryCounter.guard, TM2.stepAux, clean, encodeWord, List.replicate_succ] |
| exact update_remaining p base (m + 1) i c m |
|
|
| theorem nextStep (p : Ports K) (label : Label A ↪ Λ) (exit : Λ) |
| (table : Fin A → SymbolSpec) (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (ha : Agrees p label exit table program) (base : K → List Bool) (m i c : Nat) (ambient : σ) : |
| TM2.step program ⟨some (label .next), clean ambient, frame p base m i (c + 1)⟩ = |
| some ⟨some (label .guard), clean ambient, frame p base m (i + 1) c⟩ := by |
| change some (TM2.stepAux (program (label .next)) _ _) = _ |
| rw [ha .next] |
| simp only [statement, TM2.stepAux, frame_capacity, encodeWord, List.replicate_succ, |
| List.cons_append, List.tail_cons] |
| rw [Function.update_of_ne (p.injective.ne (by decide : (1 : Fin 11) ≠ 10))] |
| change some (⟨some (label .guard), clean ambient, |
| Function.update (Function.update (frame p base m i (c + 1)) (p 10) (encodeWord c)) |
| (p 1) (true :: frame p base m i (c + 1) (p 1))⟩ : TM2.Cfg (Alphabet (K := K)) Λ (State σ)) = _ |
| rw [update_capacity, frame_index] |
| rw [show true :: encodeWord i = encodeWord (i + 1) by simp [encodeWord, List.replicate_succ]] |
| rw [update_index] |
|
|
| def tokens (table : Fin A → SymbolSpec) (q : Nat) : Nat → Nat → List Token |
| | _, 0 => [] |
| | i, m + 1 => PayloadCellsMachine.Row.tokens table q i ++ tokens table q (i + 1) m |
|
|
| def steps (table : Fin A → SymbolSpec) (q : Nat) : Nat → Nat → Nat |
| | _, 0 => 1 |
| | i, m + 1 => 1 + PayloadCellsMachine.Row.steps table q i + 1 + steps table q (i + 1) m |
|
|
| theorem trace (p : Ports K) (label : Label A ↪ Λ) (exit : Λ) (table : Fin A → SymbolSpec) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (ha : Agrees p label exit table program) (base : K → List Bool) (q i m c : Nat) |
| (hbound : i + m ≤ q) (ready : PayloadPresenceMachine.Ready (rowPorts p) base q 0) |
| (ambient : σ) : |
| (advance (TM2.step program))^[steps table q i m] |
| (some ⟨some (label .guard), clean ambient, frame p base m i (c + m)⟩) = |
| some ⟨some exit, clean ambient, |
| emitted (p 7) (p 8) (frame p base 0 (i + m) c) (tokens table q i m)⟩ := by |
| induction m generalizing base i with |
| | zero => |
| simpa only [steps, Function.iterate_one, advance_some, Nat.add_zero, |
| tokens, ClashMachine.emitted_nil] using guardStep_zero p label exit table program ha base i c ambient |
| | succ m ih => |
| have hi : i < q := by omega |
| have hguard : (advance (TM2.step program))^[1] |
| (some ⟨some (label .guard), clean ambient, frame p base (m + 1) i (c + (m + 1))⟩) = |
| some ⟨some (label (.row (.visit 0))), clean ambient, frame p base m i (c + (m + 1))⟩ := by |
| simpa only [Function.iterate_one, advance_some] using |
| guardStep_succ p label exit table program ha base m i (c + (m + 1)) ambient |
| have hrow := PayloadCellsMachine.Row.trace (rowPorts p) (rowLabels label) |
| (some (label .next)) table program (fun entry => ha (.row entry)) |
| (frame p base m i (c + (m + 1))) q i hi (frame_ready p base q m i _ ready) ambient |
| change (advance (TM2.step program))^[PayloadCellsMachine.Row.steps table q i] |
| (some ⟨some (label (.row (.visit 0))), clean ambient, frame p base m i (c + (m + 1))⟩) = |
| some ⟨some (label .next), clean ambient, |
| emitted (p 7) (p 8) (frame p base m i (c + (m + 1))) |
| (PayloadCellsMachine.Row.tokens table q i)⟩ at hrow |
| rw [frame_emitted] at hrow |
| let nextBase := emitted (p 7) (p 8) base (PayloadCellsMachine.Row.tokens table q i) |
| have hnext : (advance (TM2.step program))^[1] |
| (some ⟨some (label .next), clean ambient, frame p nextBase m i (c + (m + 1))⟩) = |
| some ⟨some (label .guard), clean ambient, frame p nextBase m (i + 1) (c + m)⟩ := by |
| simpa only [Function.iterate_one, advance_some, Nat.add_assoc] using |
| nextStep p label exit table program ha nextBase m i (c + m) ambient |
| have hn : PayloadPresenceMachine.Ready (rowPorts p) nextBase q 0 := |
| ready.emitted (PayloadCellsMachine.Row.tokens table q i) |
| have htail := ih nextBase (i + 1) (by omega) hn |
| have h := ClashMachine.chain (ClashMachine.chain (ClashMachine.chain hguard hrow) hnext) htail |
| have hend : i + 1 + m = i + (m + 1) := by omega |
| simpa only [steps, tokens, hend, nextBase, ← frame_emitted, |
| emitted_append (p 7) (p 8) (p.injective.ne (by decide : (7 : Fin 11) ≠ 8))] using h |
|
|
| theorem steps_le (table : Fin A → SymbolSpec) (q i m : Nat) (hbound : i + m ≤ q) : |
| steps table q i m ≤ m * (A * (120 * (q + 2) ^ 2 + 1) + 3) + 1 := by |
| induction m generalizing i with |
| | zero => simp [steps] |
| | succ m ih => |
| have ht := ih (i + 1) (by omega) |
| have hr := PayloadCellsMachine.Row.steps_le table q i (by omega) |
| rw [steps, Nat.succ_mul] |
| omega |
|
|
| theorem tokens_eq_forTokens (table : Fin A → SymbolSpec) (q i m : Nat) : |
| tokens table q i m = forTokens m (fun j => PayloadCellsMachine.Row.tokens table q (i + j)) := by |
| induction m generalizing i with |
| | zero => rfl |
| | succ m ih => |
| rw [tokens, forTokens_succ_first, Nat.add_zero, ih] |
| apply congrArg (List.append (PayloadCellsMachine.Row.tokens table q i)) |
| apply forTokens_congr |
| intro j _ |
| rw [show i + 1 + j = i + (j + 1) by omega] |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.PayloadRowsLoop |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.PayloadCellsMachine |
|
|
| open InitializationTemplate WitnessEncoding |
|
|
| local instance alphabetDecidable (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) := |
| fun _ => Classical.decEq _ |
|
|
| def symbolSpec (V : NPVerifier) (k : V.computation.tm.K) |
| (a : Option (V.computation.tm.Γ k)) : SymbolSpec := |
| if h : k = V.computation.tm.k₀ then by |
| subst k |
| exact ⟨true, decide (some (V.computation.inputAlphabet.invFun true) = a), |
| decide (some (V.computation.inputAlphabet.invFun false) = a), decide (none = a)⟩ |
| else ⟨false, false, false, decide (none = a)⟩ |
|
|
| def symbolTable (V : NPVerifier) : Fin (VerifierCircuit.indexing V).symbolCount → SymbolSpec := |
| fun j => let symbol := (VerifierCircuit.indexing V).symbols.symm j |
| symbolSpec V symbol.1 symbol.2 |
|
|
| def payloadRowTokens (V : NPVerifier) (q i : Nat) : List PostfixModel.Token := |
| Row.tokens (symbolTable V) q i |
|
|
| theorem symbolTokens_eq_initialCellTokens (V : NPVerifier) (input : List Bool) (S i : Nat) |
| (hi : i < V.witnessBound.eval input.length) |
| (hS : (inputPrefix input).length + i < S) (k : V.computation.tm.K) |
| (a : Option (V.computation.tm.Γ k)) : |
| symbolTokens (symbolSpec V k a) (V.witnessBound.eval input.length) i = |
| initialCellTokens V input S k ⟨(inputPrefix input).length + i, hS⟩ a := by |
| by_cases hk : k = V.computation.tm.k₀ |
| · subst k |
| have hp : ¬ (inputPrefix input).length + i < (inputPrefix input).length := by omega |
| have hn : (inputPrefix input).length + i - (inputPrefix input).length = i := by omega |
| have hcell : inputCellTokens (V.witnessBound.eval input.length) input |
| V.computation.inputAlphabet.invFun ((inputPrefix input).length + i) a = |
| muxTokens (presenceTokens (V.witnessBound.eval input.length) i) |
| (payloadSymbolTokens (V.witnessBound.eval input.length) |
| V.computation.inputAlphabet.invFun i a) [.const (decide (none = a))] := by |
| simp only [inputCellTokens, ite_eq_right hp, hn, ite_eq_left hi] |
| simpa [symbolTokens, symbolSpec, initialCellTokens, payloadTokens, payloadSymbolTokens] using hcell.symm |
| · simp [symbolSpec, symbolTokens, initialCellTokens, hk] |
|
|
| theorem payloadRowTokens_eq (V : NPVerifier) (input : List Bool) (S i : Nat) |
| (hi : i < V.witnessBound.eval input.length) (hS : (inputPrefix input).length + i < S) : |
| payloadRowTokens V (V.witnessBound.eval input.length) i = |
| (List.ofFn fun j : Fin (VerifierCircuit.indexing V).symbolCount => |
| let symbol := (VerifierCircuit.indexing V).symbols.symm j |
| initialCellTokens V input S symbol.1 ⟨(inputPrefix input).length + i, hS⟩ symbol.2).flatten := by |
| rw [payloadRowTokens, Row.tokens_eq_ofFn] |
| congr 1 |
| congr 1 |
| funext j |
| exact symbolTokens_eq_initialCellTokens V input S i hi hS _ _ |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.PayloadCellsMachine |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.CellsTokensAlignment |
|
|
| open WitnessEncoding InitializationTemplate PaddingCellsMachine |
|
|
| local instance (V : NPVerifier) : DecidableEq V.computation.tm.Λ := Classical.decEq _ |
| local instance (V : NPVerifier) : DecidableEq V.computation.tm.σ := Classical.decEq _ |
| local instance (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) := |
| fun _ => Classical.decEq _ |
|
|
| theorem cellsInterval_append (V : NPVerifier) (input : List Bool) (S start m n : Nat) |
| (within : start + (m + n) ≤ S) : |
| cellsInterval V input S start (m + n) within = |
| cellsInterval V input S start m (by omega) ++ |
| cellsInterval V input S (start + m) n (by omega) := by |
| simp only [cellsInterval, List.flatMap_def, ← List.ofFn_eq_map] |
| rw [List.ofFn_add, List.flatten_append] |
| simp only [Fin.val_castLE, Fin.val_natAdd, Nat.add_assoc] |
|
|
| theorem cellsInterval_full (V : NPVerifier) (input : List Bool) (S : Nat) : |
| cellsInterval V input S 0 S (by omega) = InitializationControl.cells V input S := by |
| simp only [cellsInterval, InitializationControl.cells, Nat.zero_add] |
|
|
| theorem prefix_eq_interval (V : NPVerifier) (input : List Bool) (S : Nat) |
| (within : (inputPrefix input).length ≤ S) : |
| InputCellsMachine.streamTokens (InputCellsMachine.prefixTruth V) (inputPrefix input) = |
| cellsInterval V input S 0 (inputPrefix input).length (by omega) := by |
| simpa only [cellsInterval, List.flatMap_def, ← List.ofFn_eq_map, Nat.zero_add] using |
| InputCellsMachine.prefixStream_eq_initialCells V input S within |
|
|
| theorem payload_eq_interval (V : NPVerifier) (input : List Bool) (S : Nat) |
| (within : (inputPrefix input).length + V.witnessBound.eval input.length ≤ S) : |
| PayloadRowsLoop.tokens (PayloadCellsMachine.symbolTable V) |
| (V.witnessBound.eval input.length) 0 (V.witnessBound.eval input.length) = |
| cellsInterval V input S (inputPrefix input).length (V.witnessBound.eval input.length) within := by |
| rw [PayloadRowsLoop.tokens_eq_forTokens, forTokens_eq_ofFn] |
| simp only [cellsInterval, List.flatMap_def, ← List.ofFn_eq_map, Nat.zero_add] |
| apply congrArg List.flatten |
| apply congrArg List.ofFn |
| funext i |
| exact PayloadCellsMachine.payloadRowTokens_eq V input S i.val i.isLt (by omega) |
|
|
| theorem cells_eq_streams (V : NPVerifier) (input : List Bool) (S : Nat) |
| (within : (inputPrefix input).length + V.witnessBound.eval input.length ≤ S) : |
| InputCellsMachine.streamTokens (InputCellsMachine.prefixTruth V) (inputPrefix input) ++ |
| PayloadRowsLoop.tokens (PayloadCellsMachine.symbolTable V) |
| (V.witnessBound.eval input.length) 0 (V.witnessBound.eval input.length) ++ |
| repeatedRows (blankRow V) |
| (S - (inputPrefix input).length - V.witnessBound.eval input.length) = |
| InitializationControl.cells V input S := by |
| let P := (inputPrefix input).length |
| let q := V.witnessBound.eval input.length |
| let r := S - P - q |
| have hpq : P + q ≤ S := within |
| have total : (P + q) + r = S := by dsimp only [r]; omega |
| have hpre := prefix_eq_interval V input S (by omega) |
| have hpay := payload_eq_interval V input S within |
| have hpad := cellsInterval_padding V input S (P + q) r (by omega) (by exact le_rfl) |
| rw [hpre, hpay, ← hpad] |
| have first := cellsInterval_append V input S 0 P q (by omega) |
| have second := cellsInterval_append V input S 0 (P + q) r (by omega) |
| simp only [Nat.zero_add] at first second |
| rw [← first, ← second] |
| simpa only [total] using cellsInterval_full V input S |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.CellsTokensAlignment |
|
|
| end |
|
|
| end OAI |
|
|
