| import Mathlib.Data.Fin.VecNotation |
| import Mathlib.Data.List.OfFn |
| import OAI.Computability.BinPacking.CookLevin.VerifierCircuit |
|
|
| namespace OAI |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.InitializationTemplate |
|
|
| section |
|
|
| open PostfixModel |
|
|
| def forTokens : Nat → (Nat → List Token) → List Token |
| | 0, _ => [] |
| | count + 1, body => forTokens count body ++ body count |
|
|
| theorem forTokens_eq_flatMap_range (count : Nat) (body : Nat → List Token) : |
| forTokens count body = (List.range count).flatMap body := by |
| induction count with |
| | zero => rfl |
| | succ count ih => simp [forTokens, List.range_succ, ih] |
|
|
| theorem forTokens_eq_ofFn (count : Nat) (body : Nat → List Token) : |
| forTokens count body = (List.ofFn fun i : Fin count => body i.val).flatten := by |
| induction count with |
| | zero => simp [forTokens] |
| | succ count ih => |
| rw [forTokens, ih, List.ofFn_succ'] |
| simp [List.concat_eq_append] |
|
|
| theorem forTokens_succ_first (count : Nat) (body : Nat → List Token) : |
| forTokens (count + 1) body = body 0 ++ forTokens count (fun j => body (j + 1)) := by |
| simp [forTokens_eq_flatMap_range, List.range_succ_eq_map, List.flatMap_map] |
|
|
| theorem forTokens_congr (count : Nat) (first second : Nat → List Token) |
| (h : ∀ i, i < count → first i = second i) : |
| forTokens count first = forTokens count second := by |
| induction count with |
| | zero => rfl |
| | succ count ih => |
| rw [forTokens, forTokens, ih (fun i hi => h i (by omega)), h count (by omega)] |
|
|
| theorem forTokens_length_le (count : Nat) (body : Nat → List Token) (cost : Nat) |
| (h : ∀ i, i < count → (body i).length ≤ cost) : |
| (forTokens count body).length ≤ count * cost := by |
| induction count with |
| | zero => simp [forTokens] |
| | succ count ih => |
| have hp := ih (fun i hi => h i (by omega)) |
| have hl := h count (by omega) |
| simp only [forTokens, List.length_append, Nat.succ_mul] |
| omega |
|
|
| theorem forTokens_length_eq (count : Nat) (body : Nat → List Token) (cost : Nat) |
| (h : ∀ i, i < count → (body i).length = cost) : |
| (forTokens count body).length = count * cost := by |
| induction count with |
| | zero => simp [forTokens] |
| | succ count ih => |
| rw [forTokens, List.length_append, ih (fun i hi => h i (by omega)), h count (by omega)] |
| exact (Nat.succ_mul count cost).symm |
|
|
| def closeOr (count : Nat) : List Token := [.const false] ++ List.replicate count .or |
|
|
| def nonemptyTokens (q : Nat) : List Token := |
| forTokens (q + 1) (fun i => [.input i]) ++ closeOr (q + 1) |
|
|
| def clashPairTokens (i j : Nat) : List Token := |
| if i = j then [.const false] else [.input i, .input j, .and] |
|
|
| def clashRowTokens (q i : Nat) : List Token := |
| forTokens (q + 1) (clashPairTokens i) ++ closeOr (q + 1) |
|
|
| def clashTokens (q : Nat) : List Token := |
| forTokens (q + 1) (clashRowTokens q) ++ closeOr (q + 1) |
|
|
| def validityTokens (q : Nat) : List Token := |
| nonemptyTokens q ++ clashTokens q ++ [.not, .and] |
|
|
| def presenceTokens (q n : Nat) : List Token := |
| forTokens (q + 1) (fun length => [.input length, .const (decide (n < length)), .and]) ++ |
| closeOr (q + 1) |
|
|
| def selectorLoopTokens (count start threshold : Nat) : List Token := |
| forTokens count (fun j => [.input (start + j), .const (decide (threshold ≤ j)), .and]) |
|
|
| theorem threshold_zero_iff (threshold used : Nat) : |
| threshold - used = 0 ↔ threshold ≤ used := Nat.sub_eq_zero_iff_le |
|
|
| theorem selectorLoopTokens_length (count start threshold : Nat) : |
| (selectorLoopTokens count start threshold).length = 3 * count := by |
| simpa only [selectorLoopTokens, Nat.mul_comm] using |
| forTokens_length_eq count |
| (fun j => [.input (start + j), .const (decide (threshold ≤ j)), .and]) 3 |
| (fun _ _ => rfl) |
|
|
| theorem selectorLoopTokens_succ (count start threshold : Nat) : |
| selectorLoopTokens (count + 1) start threshold = |
| [.input start, .const (decide (threshold = 0)), .and] ++ |
| selectorLoopTokens count (start + 1) (threshold - 1) := by |
| rw [selectorLoopTokens, forTokens_succ_first] |
| simp only [Nat.add_zero, Nat.le_zero] |
| apply congrArg (List.append [Token.input start, Token.const (decide (threshold = 0)), Token.and]) |
| apply forTokens_congr |
| intro j _ |
| have ha : start + (j + 1) = start + 1 + j := by omega |
| have ht : (threshold ≤ j + 1) = (threshold - 1 ≤ j) := propext (by omega) |
| simp only [ha, ht] |
|
|
| theorem selectorLoopTokens_presence (q n : Nat) : |
| selectorLoopTokens (q + 1) 0 (n + 1) ++ closeOr (q + 1) = presenceTokens q n := by |
| simp only [selectorLoopTokens, presenceTokens] |
| apply congrArg (fun xs : List Token => xs ++ closeOr (q + 1)) |
| apply forTokens_congr |
| intro j _ |
| simp only [Nat.zero_add, Nat.succ_le_iff] |
|
|
| theorem presenceTokens_length (q n : Nat) : (presenceTokens q n).length = 4 * (q + 1) + 1 := by |
| rw [← selectorLoopTokens_presence q n, List.length_append, selectorLoopTokens_length] |
| simp only [closeOr, List.length_append, List.length_cons, List.length_nil, List.length_replicate] |
| omega |
|
|
| end |
|
|
| open StatementCircuit WitnessCircuit WitnessEncoding PostfixModel PostfixAlignment CircuitBatch |
|
|
| theorem exprTokens_disjoin {ι : Type*} (wire : ι → Nat) (es : List (Expr ι)) : |
| exprTokens wire (Expr.disjoin es) = forestTokens wire es ++ closeOr es.length := by |
| induction es with |
| | nil => simp [Expr.disjoin, exprTokens, forestTokens, closeOr] |
| | cons e es ih => |
| simp [Expr.disjoin, exprTokens, forestTokens_cons, ih, closeOr, |
| List.replicate_succ', List.append_assoc] |
|
|
| theorem forestTokens_ofFn {ι : Type*} (wire : ι → Nat) (n : Nat) (es : Fin n → Expr ι) : |
| forestTokens wire (List.ofFn es) = (List.ofFn fun i => exprTokens wire (es i)).flatten := by |
| simp only [forestTokens, List.flatMap_def, List.map_ofFn, Function.comp_def] |
|
|
| def muxTokens (condition yes no : List Token) : List Token := |
| condition ++ yes ++ [.and] ++ condition ++ [.not] ++ no ++ [.and, .or] |
|
|
| theorem exprTokens_mux {ι : Type*} (wire : ι → Nat) (c y n : Expr ι) : |
| exprTokens wire (Expr.mux c y n) = |
| muxTokens (exprTokens wire c) (exprTokens wire y) (exprTokens wire n) := by |
| simp [Expr.mux, exprTokens, muxTokens, List.append_assoc] |
|
|
| theorem nonemptyTokens_eq (q : Nat) : |
| nonemptyTokens q = exprTokens Fin.val (nonemptyExpr q) := by |
| rw [nonemptyExpr, exprTokens_disjoin, forestTokens_ofFn] |
| simp [nonemptyTokens, forTokens_eq_ofFn, selectorExpr, exprTokens] |
|
|
| theorem clashPairTokens_eq (q : Nat) (i j : Fin (q + 1)) : |
| clashPairTokens i.val j.val = exprTokens Fin.val (clashPairExpr q i j) := by |
| by_cases h : i = j |
| · subst j; simp [clashPairTokens, clashPairExpr, exprTokens] |
| · have hv : i.val ≠ j.val := fun hval => h (Fin.ext hval) |
| simp [clashPairTokens, clashPairExpr, h, hv, selectorExpr, exprTokens] |
|
|
| theorem clashRowTokens_eq (q : Nat) (i : Fin (q + 1)) : |
| clashRowTokens q i.val = |
| exprTokens Fin.val (Expr.disjoin (List.ofFn (clashPairExpr q i))) := by |
| rw [exprTokens_disjoin, forestTokens_ofFn] |
| simp only [clashRowTokens, forTokens_eq_ofFn, List.length_ofFn] |
| apply congrArg (fun xs : List (List Token) => xs.flatten ++ closeOr (q + 1)) |
| apply congrArg List.ofFn |
| funext j |
| exact clashPairTokens_eq q i j |
|
|
| theorem clashTokens_eq (q : Nat) : |
| clashTokens q = exprTokens Fin.val (clashExpr q) := by |
| rw [clashExpr, exprTokens_disjoin, forestTokens_ofFn] |
| simp only [clashTokens, forTokens_eq_ofFn, List.length_ofFn] |
| apply congrArg (fun xs : List (List Token) => xs.flatten ++ closeOr (q + 1)) |
| apply congrArg List.ofFn |
| funext i |
| exact clashRowTokens_eq q i |
|
|
| theorem validityTokens_eq (q : Nat) : |
| validityTokens q = exprTokens Fin.val (validityExpr q) := by |
| simp [validityTokens, validityExpr, exprTokens, nonemptyTokens_eq, |
| clashTokens_eq, List.append_assoc] |
|
|
| theorem presenceTokens_eq (q n : Nat) : |
| presenceTokens q n = exprTokens Fin.val (presenceExpr q n) := by |
| rw [presenceExpr, exprTokens_disjoin, forestTokens_ofFn] |
| simp [presenceTokens, forTokens_eq_ofFn, selectorExpr, exprTokens] |
|
|
| section Symbols |
|
|
| variable {A : Type*} [DecidableEq A] |
|
|
| def payloadSymbolTokens (q : Nat) (f : Bool → A) (i : Nat) (a : Option A) : List Token := |
| [.input (q + 1 + i), .const (decide (some (f true) = a)), .and, |
| .input (q + 1 + i), .not, .const (decide (some (f false) = a)), .and, .or] |
|
|
| theorem payloadSymbolTokens_eq (q : Nat) (f : Bool → A) (i : Fin q) (a : Option A) : |
| payloadSymbolTokens q f i.val a = exprTokens Fin.val (payloadSymbolExpr q f i a) := by |
| simp [payloadSymbolExpr, payloadSymbolTokens, exprTokens_mux, payloadExpr, |
| exprTokens, muxTokens] |
|
|
| def inputCellTokens (q : Nat) (input : List Bool) (f : Bool → A) (n : Nat) (a : Option A) : |
| List Token := |
| if n < (inputPrefix input).length then [.const (decide (((inputPrefix input)[n]?).map f = a))] |
| else if n - (inputPrefix input).length < q then |
| muxTokens (presenceTokens q (n - (inputPrefix input).length)) |
| (payloadSymbolTokens q f (n - (inputPrefix input).length) a) |
| [.const (decide ((none : Option A) = a))] |
| else [.const (decide ((none : Option A) = a))] |
|
|
| theorem inputCellTokens_eq (q : Nat) (input : List Bool) (f : Bool → A) (n : Nat) (a : Option A) : |
| inputCellTokens q input f n a = exprTokens Fin.val (inputCellExpr q input f n a) := by |
| by_cases hp : n < (inputPrefix input).length |
| · simp only [inputCellTokens, inputCellExpr, ite_eq_left hp, exprTokens] |
| · by_cases hq : n - (inputPrefix input).length < q |
| · simp only [inputCellTokens, inputCellExpr, hp, ite_false, hq, ite_true, dite_eq_left] |
| rw [exprTokens_mux, ← presenceTokens_eq, ← payloadSymbolTokens_eq] |
| rfl |
| · simp only [inputCellTokens, inputCellExpr, ite_eq_right hp, ite_eq_right hq, |
| dite_eq_right hq, exprTokens] |
|
|
| end Symbols |
|
|
| section Initial |
|
|
| variable (V : NPVerifier) |
| variable [DecidableEq V.computation.tm.Λ] [DecidableEq V.computation.tm.σ] |
| variable [∀ k, DecidableEq (V.computation.tm.Γ k)] |
|
|
| def initialCellTokens (input : List Bool) (S : Nat) (k : V.computation.tm.K) |
| (i : Fin S) (a : Option (V.computation.tm.Γ k)) : List Token := |
| if h : k = V.computation.tm.k₀ then by |
| subst k |
| exact inputCellTokens (V.witnessBound.eval input.length) input |
| V.computation.inputAlphabet.invFun i.val a |
| else [.const (decide ((none : Option (V.computation.tm.Γ k)) = a))] |
|
|
| omit [DecidableEq V.computation.tm.Λ] [DecidableEq V.computation.tm.σ] in |
| theorem initialCellTokens_eq (input : List Bool) (S : Nat) (k : V.computation.tm.K) |
| (i : Fin S) (a : Option (V.computation.tm.Γ k)) : |
| initialCellTokens V input S k i a = exprTokens Fin.val (initialCellExpr V input S k i a) := by |
| by_cases hk : k = V.computation.tm.k₀ |
| · subst k |
| simpa [initialCellTokens, initialCellExpr] using |
| inputCellTokens_eq (V.witnessBound.eval input.length) input |
| V.computation.inputAlphabet.invFun i.val a |
| · simp [initialCellTokens, initialCellExpr, hk, exprTokens] |
|
|
| def initTokens (input : List Bool) (S : Nat) : |
| ConfigBit V.computation.tm.Γ V.computation.tm.Λ V.computation.tm.σ S → List Token |
| | .inl label => [.const (decide (some V.computation.tm.main = label))] |
| | .inr (.inl state) => [.const (decide (V.computation.tm.initialState = state))] |
| | .inr (.inr ⟨k, i, a⟩) => initialCellTokens V input S k i a |
|
|
| theorem initTokens_eq (input : List Bool) (S : Nat) |
| (bit : ConfigBit V.computation.tm.Γ V.computation.tm.Λ V.computation.tm.σ S) : |
| initTokens V input S bit = exprTokens Fin.val (initExpr V input S bit) := by |
| rcases bit with label | (state | ⟨k, i, a⟩) |
| · rfl |
| · rfl |
| · exact initialCellTokens_eq V input S k i a |
|
|
| theorem initTokens_length_le (input : List Bool) (S : Nat) |
| (bit : ConfigBit V.computation.tm.Γ V.computation.tm.Λ V.computation.tm.σ S) : |
| (initTokens V input S bit).length ≤ 8 * (V.witnessBound.eval input.length + 1) + 15 := by |
| rw [initTokens_eq, exprTokens_length] |
| exact size_initExpr_le V input S bit |
|
|
| end Initial |
|
|
| theorem validityTokens_length_le (q : Nat) : (validityTokens q).length ≤ 12 * (q + 1) ^ 2 := by |
| rw [validityTokens_eq, exprTokens_length] |
| exact size_validityExpr_le q |
|
|
| noncomputable section Frame |
|
|
| open VerifierCircuit |
|
|
| local instance labelDecidable (V : NPVerifier) : DecidableEq V.computation.tm.Λ := Classical.decEq _ |
| local instance stateDecidable (V : NPVerifier) : DecidableEq V.computation.tm.σ := Classical.decEq _ |
| local instance alphabetDecidable (V : NPVerifier) : ∀ k, DecidableEq (V.computation.tm.Γ k) := |
| fun _ => Classical.decEq _ |
|
|
| def configurationBody (V : NPVerifier) (input : List Bool) (j : Nat) : List Token := |
| if hj : j < width V input then |
| initTokens V input (capacity V input.length) ((bitEquiv V input).symm ⟨j, hj⟩) |
| else [] |
|
|
| theorem configurationBody_index (V : NPVerifier) (input : List Bool) (bit : Bit V input) : |
| configurationBody V input (bitEquiv V input bit).val = |
| initTokens V input (capacity V input.length) bit := by |
| rw [configurationBody, dite_eq_left (bitEquiv V input bit).isLt] |
| change initTokens V input (capacity V input.length) |
| ((bitEquiv V input).symm (bitEquiv V input bit)) = _ |
| rw [Equiv.symm_apply_apply] |
|
|
| theorem configurationBody_label (V : NPVerifier) (input : List Bool) |
| (label : Option V.computation.tm.Λ) : |
| configurationBody V input ((indexing V).labels label).val = |
| [.const (decide (some V.computation.tm.main = label))] := by |
| simpa only [bitEquiv, ConfigIndex.Indexing.configIndex_label, initTokens] using |
| configurationBody_index V input (.inl label) |
|
|
| theorem configurationBody_state (V : NPVerifier) (input : List Bool) |
| (state : V.computation.tm.σ) : |
| configurationBody V input ((indexing V).labelCount + ((indexing V).states state).val) = |
| [.const (decide (V.computation.tm.initialState = state))] := by |
| simpa only [bitEquiv, ConfigIndex.Indexing.configIndex_state, initTokens] using |
| configurationBody_index V input (.inr (.inl state)) |
|
|
| theorem configurationBody_cell (V : NPVerifier) (input : List Bool) |
| (k : V.computation.tm.K) (i : Fin (capacity V input.length)) |
| (a : Option (V.computation.tm.Γ k)) : |
| configurationBody V input ((indexing V).labelCount + (indexing V).stateCount + |
| i.val * (indexing V).symbolCount + ((indexing V).symbols ⟨k, a⟩).val) = |
| initialCellTokens V input (capacity V input.length) k i a := by |
| simpa only [bitEquiv, ConfigIndex.Indexing.configIndex_cell, initTokens] using |
| configurationBody_index V input (.inr (.inr ⟨k, i, a⟩)) |
|
|
| def initializationTokens (V : NPVerifier) (input : List Bool) : List Token := |
| forTokens (width V input) (configurationBody V input) ++ |
| validityTokens (V.witnessBound.eval input.length) |
|
|
| def tokenBound (V : NPVerifier) (input : List Bool) : Nat := |
| width V input * (8 * (V.witnessBound.eval input.length + 1) + 15) + |
| 12 * (V.witnessBound.eval input.length + 1) ^ 2 |
|
|
| theorem initializationTokens_eq (V : NPVerifier) (input : List Bool) : |
| initializationTokens V input = |
| forestTokens Fin.val (List.ofFn (initialExpressions V input)) := by |
| rw [forestTokens_ofFn, List.ofFn_succ'] |
| simp only [List.concat_eq_append, List.flatten_append, List.flatten_cons, |
| List.flatten_nil, List.append_nil] |
| simp only [initialExpressions, Fin.lastCases_castSucc, Fin.lastCases_last] |
| simp only [initializationTokens, forTokens_eq_ofFn, configurationBody, Fin.isLt, dite_eq_left] |
| rw [validityTokens_eq] |
| apply congrArg (fun xs : List (List Token) => xs.flatten ++ |
| exprTokens Fin.val (validityExpr (V.witnessBound.eval input.length))) |
| apply congrArg List.ofFn |
| funext i |
| exact initTokens_eq V input (capacity V input.length) ((bitEquiv V input).symm i) |
|
|
| theorem initializationTokens_length (V : NPVerifier) (input : List Bool) : |
| (initializationTokens V input).length = Batch.cost (List.ofFn (initialExpressions V input)) := by |
| rw [initializationTokens_eq, forestTokens_length] |
|
|
| theorem initialization_inputBits (V : NPVerifier) (input : List Bool) (start : Nat) : |
| PostfixModel.inputBits start (initializationTokens V input) = |
| encodeWords [start, Batch.cost (List.ofFn (initialExpressions V input))] ++ |
| tokenBits (initializationTokens V input) := by |
| simp only [PostfixModel.inputBits, initializationTokens_length] |
|
|
| theorem initializationTokens_length_le (V : NPVerifier) (input : List Bool) : |
| (initializationTokens V input).length ≤ tokenBound V input := by |
| have h := forTokens_length_le (width V input) (configurationBody V input) |
| (8 * (V.witnessBound.eval input.length + 1) + 15) (by |
| intro j hj |
| simp only [configurationBody, dite_eq_left hj] |
| exact initTokens_length_le V input (capacity V input.length) ((bitEquiv V input).symm ⟨j, hj⟩)) |
| simpa only [initializationTokens, List.length_append, tokenBound] using |
| Nat.add_le_add h (validityTokens_length_le (V.witnessBound.eval input.length)) |
|
|
| theorem initializationTokens_compile (V : NPVerifier) (input : List Bool) (start : Nat) |
| (roots : List Nat) : |
| compileTokens start roots (initializationTokens V input) = |
| some (start + Batch.cost (List.ofFn (initialExpressions V input)), |
| (Batch.roots start (List.ofFn (initialExpressions V input))).reverse ++ roots, |
| Batch.gates Fin.val start (List.ofFn (initialExpressions V input))) := by |
| rw [initializationTokens_eq] |
| exact compile_forestTokens _ _ _ _ |
|
|
| theorem initialization_tokenWords_bounded (V : NPVerifier) (input : List Bool) |
| (word : Nat) (h : word ∈ tokenWords (initializationTokens V input)) : |
| word ≤ max 5 (2 * V.witnessBound.eval input.length + 1) := by |
| rw [initializationTokens_eq] at h |
| exact forest_tokenWords_bounded Fin.val _ _ (fun i => i.isLt) word h |
|
|
| theorem initialization_tokenBits_length_le (V : NPVerifier) (input : List Bool) : |
| (tokenBits (initializationTokens V input)).length ≤ |
| 2 * tokenBound V input * (2 * V.witnessBound.eval input.length + 7) := by |
| have hw := tokenWords_length_le (initializationTokens V input) |
| have ht := initializationTokens_length_le V input |
| have hb := encodeWords_length_le (tokenWords (initializationTokens V input)) |
| (2 * V.witnessBound.eval input.length + 6) (by |
| intro word hm |
| have hh := initialization_tokenWords_bounded V input word hm |
| have hm' : max 5 (2 * V.witnessBound.eval input.length + 1) ≤ |
| 2 * V.witnessBound.eval input.length + 6 := by omega |
| exact hh.trans hm') |
| have hwords : (tokenWords (initializationTokens V input)).length ≤ 2 * tokenBound V input := |
| hw.trans (Nat.mul_le_mul_left 2 ht) |
| exact hb.trans (Nat.mul_le_mul_right _ hwords) |
|
|
| end Frame |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.InitializationTemplate |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.ClashMachine |
|
|
| open Turing MachineComposition PostfixModel InitializationTemplate |
| open Reduction.MachineSubstitution (pushWord stepAux_pushWord) |
|
|
| variable {K Λ σ : Type} [DecidableEq K] |
|
|
| abbrev Alphabet (_ : K) := Bool |
| abbrev State (σ : Type) := (σ × Bool) × Option Bool |
|
|
| def clean (ambient : σ) : State σ := ((ambient, false), none) |
|
|
| def emitted (output count : K) (base : K → List Bool) (tokens : List Token) : K → List Bool := |
| Function.update (Function.update base output ((tokenBits tokens).reverse ++ base output)) |
| count (List.replicate tokens.length true ++ base count) |
|
|
| @[simp] theorem emitted_output (output count : K) (hne : output ≠ count) |
| (base : K → List Bool) (tokens : List Token) : |
| emitted output count base tokens output = (tokenBits tokens).reverse ++ base output := by |
| simp [emitted, hne] |
|
|
| @[simp] theorem emitted_count (output count : K) (base : K → List Bool) (tokens : List Token) : |
| emitted output count base tokens count = List.replicate tokens.length true ++ base count := by |
| simp [emitted] |
|
|
| theorem emitted_other (output count k : K) (ho : k ≠ output) (hc : k ≠ count) |
| (base : K → List Bool) (tokens : List Token) : emitted output count base tokens k = base k := by |
| simp [emitted, ho, hc] |
|
|
| theorem tokenBits_append (first second : List Token) : |
| tokenBits (first ++ second) = tokenBits first ++ tokenBits second := by |
| simp [tokenBits, tokenWords] |
|
|
| theorem emitted_append (output count : K) (hne : output ≠ count) |
| (base : K → List Bool) (first second : List Token) : |
| emitted output count (emitted output count base first) second = |
| emitted output count base (first ++ second) := by |
| funext k |
| by_cases ho : k = output |
| · subst k |
| simp [emitted, hne, tokenBits_append, List.reverse_append, List.append_assoc] |
| · by_cases hc : k = count |
| · subst k |
| have hr : List.replicate second.length true ++ List.replicate first.length true = |
| List.replicate (first.length + second.length) true := by |
| rw [← List.replicate_add, Nat.add_comm] |
| simp only [emitted_count, List.length_append, ← List.append_assoc, hr] |
| · simp [emitted, ho, hc] |
|
|
| @[simp] theorem emitted_nil (output count : K) (base : K → List Bool) : |
| emitted output count base [] = base := by |
| simp [emitted, tokenBits, tokenWords, encodeWords] |
|
|
| 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] |
|
|
| def literal (output count : K) (tokens : List Token) |
| (continuation : TM2.Stmt (Alphabet (K := K)) Λ (State σ)) : |
| TM2.Stmt (Alphabet (K := K)) Λ (State σ) := |
| pushWord output (tokenBits tokens) |
| (pushWord count (List.replicate tokens.length true) continuation) |
|
|
| theorem stepAux_literal (output count : K) (hne : output ≠ count) |
| (tokens : List Token) (continuation : TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (state : State σ) (base : K → List Bool) : |
| TM2.stepAux (literal output count tokens continuation) state base = |
| TM2.stepAux continuation state (emitted output count base tokens) := by |
| simp [literal, stepAux_pushWord, emitted, Ne.symm hne] |
|
|
| namespace Input |
|
|
| inductive Label where |
| | tag | scan | emit (b : Bool) | restore |
| deriving DecidableEq |
|
|
| instance : Fintype Label where |
| elems := { .tag, .scan, .emit false, .emit true, .restore } |
| complete l := by cases l with |
| | emit b => cases b <;> simp |
| | tag => simp |
| | scan => simp |
| | restore => simp |
|
|
| def statement (slots : Fin 4 ↪ K) (labels : Label → Λ) (exit : Option Λ) : |
| Label → TM2.Stmt (Alphabet (K := K)) Λ (State σ) |
| | .tag => pushWord (slots 2) (encodeWord 5) |
| (.push (slots 3) (fun _ => true) (.goto fun _ => labels .scan)) |
| | .scan => MachineTransducerCopy.scanLoop (slots 0) (slots 1) false |
| (fun _ b => labels (.emit b)) (labels .restore) |
| | .emit b => MachineTransducerCopy.emitter (slots 2) (fun (_ : Bool) _ => false) |
| (fun _ b => [b]) (labels .scan) false b |
| | .restore => Reduction.MachineTransfer.loopAt (slots 1) (slots 0) id false |
| (labels .restore) exit |
|
|
| def steps (n : Nat) : Nat := 3 * (n + 1) + 3 |
|
|
| private theorem identity_output (xs : List Bool) (control : Bool) : |
| Reduction.MachineTransducer.output (fun (_ : Bool) _ => false) |
| (fun _ b => [b]) control xs = xs := by |
| induction xs generalizing control with |
| | nil => rfl |
| | cons b xs ih => simp [Reduction.MachineTransducer.output, ih] |
|
|
| theorem trace (slots : Fin 4 ↪ K) (labels : Label → Λ) (exit : Option Λ) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (atLabels : ∀ l, program (labels l) = statement slots labels exit l) |
| (base : K → List Bool) (n : Nat) |
| (sourceWord : base (slots 0) = encodeWord n) (scratchEmpty : base (slots 1) = []) |
| (ambient : σ) : |
| (advance (TM2.step program))^[steps n] |
| (some ⟨some (labels .tag), clean ambient, base⟩) = |
| some ⟨exit, clean ambient, emitted (slots 2) (slots 3) base [.input n]⟩ := by |
| let tagged := Function.update (Function.update base (slots 2) |
| ((encodeWord 5).reverse ++ base (slots 2))) (slots 3) (true :: base (slots 3)) |
| have htag : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .tag), clean ambient, base⟩) = |
| some ⟨some (labels .scan), clean ambient, tagged⟩ := by |
| change some (TM2.stepAux (program (labels .tag)) _ _) = _ |
| rw [atLabels, statement, stepAux_pushWord] |
| simp [TM2.stepAux, tagged, slots.injective.eq_iff] |
| have hs : tagged (slots 0) = encodeWord n := by |
| simpa [tagged, slots.injective.eq_iff] using sourceWord |
| have ht : tagged (slots 1) = [] := by |
| simpa [tagged, slots.injective.eq_iff] using scratchEmpty |
| have hcopy := MachineTransducerCopy.transduceCopyTrace (slots 0) (slots 1) (slots 2) |
| (slots.injective.ne (by decide)) (slots.injective.ne (by decide)) |
| (slots.injective.ne (by decide)) false (fun (_ : Bool) _ => false) (fun _ b => [b]) |
| (labels .scan) (labels .restore) (fun _ b => labels (.emit b)) exit program |
| (atLabels .scan) |
| (fun (control symbol : Bool) => by |
| simpa only [statement, MachineTransducerCopy.emitter] using (atLabels (Label.emit symbol))) |
| (atLabels .restore) tagged ht ambient false none |
| rw [hs, encodeWord_length, identity_output] at hcopy |
| have hout : Function.update tagged (slots 2) ((encodeWord n).reverse ++ tagged (slots 2)) = |
| emitted (slots 2) (slots 3) base [.input n] := by |
| funext k |
| by_cases ho : k = slots 2 |
| · subst k |
| simp [tagged, emitted, tokenBits, tokenWords, Token.words, encodeWords, |
| slots.injective.eq_iff, List.reverse_append, List.append_assoc] |
| · by_cases hc : k = slots 3 |
| · subst k |
| simp [tagged, emitted, slots.injective.eq_iff] |
| · simp [tagged, emitted, ho, hc] |
| rw [hout] at hcopy |
| have h := chain htag hcopy |
| simpa only [steps, clean, Nat.add_comm 1] using h |
|
|
| end Input |
|
|
| namespace Pair |
|
|
| def leftMap : Fin 4 ↪ Fin 6 := ⟨![0, 1, 2, 3], by decide⟩ |
| def rightMap : Fin 4 ↪ Fin 6 := ⟨![1, 0, 2, 3], by decide⟩ |
| def inputLeftMap : Fin 4 ↪ Fin 6 := ⟨![0, 2, 4, 5], by decide⟩ |
| def inputRightMap : Fin 4 ↪ Fin 6 := ⟨![1, 2, 4, 5], by decide⟩ |
|
|
| inductive Label where |
| | left (l : MachineUnaryLessAt.Label) |
| | right (l : MachineUnaryLessAt.Label) |
| | branchLeft | branchRight | diagonal |
| | inputLeft (l : Input.Label) |
| | inputRight (l : Input.Label) |
| | conjunction |
| deriving DecidableEq, Fintype |
|
|
| def choose (yes no : Λ) : TM2.Stmt (Alphabet (K := K)) Λ (State σ) := |
| .branch (fun s => s.1.2) |
| (.load (fun s => clean s.1.1) (.goto fun _ => yes)) |
| (.load (fun s => clean s.1.1) (.goto fun _ => no)) |
|
|
| theorem stepAux_choose (yes no : Λ) (base : K → List Bool) (ambient : σ) (flag : Bool) : |
| TM2.stepAux (choose yes no) ((ambient, flag), none) base = |
| ⟨some (if flag then yes else no), clean ambient, base⟩ := by |
| cases flag <;> rfl |
|
|
| def statement (slots : Fin 6 ↪ K) (labels : Label → Λ) (exit : Option Λ) : |
| Label → TM2.Stmt (Alphabet (K := K)) Λ (State σ) |
| | .left l => MachineUnaryLessAt.statement (leftMap.trans slots) |
| (fun l => labels (.left l)) (some (labels .branchLeft)) l |
| | .right l => MachineUnaryLessAt.statement (rightMap.trans slots) |
| (fun l => labels (.right l)) (some (labels .branchRight)) l |
| | .branchLeft => choose (labels (.inputLeft .tag)) (labels (.right .scan)) |
| | .branchRight => choose (labels (.inputLeft .tag)) (labels .diagonal) |
| | .diagonal => literal (slots 4) (slots 5) [.const false] |
| (Reduction.MachineTransfer.exitAt (slots 4) exit) |
| | .inputLeft l => Input.statement (inputLeftMap.trans slots) |
| (fun l => labels (.inputLeft l)) (some (labels (.inputRight .tag))) l |
| | .inputRight l => Input.statement (inputRightMap.trans slots) |
| (fun l => labels (.inputRight l)) (some (labels .conjunction)) l |
| | .conjunction => literal (slots 4) (slots 5) [.and] |
| (Reduction.MachineTransfer.exitAt (slots 4) exit) |
|
|
| def offSteps (i j : Nat) : Nat := Input.steps i + Input.steps j + 1 |
|
|
| theorem offTrace (slots : Fin 6 ↪ K) (labels : Label → Λ) (exit : Option Λ) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (atLabels : ∀ l, program (labels l) = statement slots labels exit l) |
| (base : K → List Bool) (i j : Nat) |
| (leftWord : base (slots 0) = encodeWord i) (rightWord : base (slots 1) = encodeWord j) |
| (leftEmpty : base (slots 2) = []) (ambient : σ) : |
| (advance (TM2.step program))^[offSteps i j] |
| (some ⟨some (labels (.inputLeft .tag)), clean ambient, base⟩) = |
| some ⟨exit, clean ambient, emitted (slots 4) (slots 5) base [.input i, .input j, .and]⟩ := by |
| have hi := Input.trace (inputLeftMap.trans slots) (fun l => labels (.inputLeft l)) |
| (some (labels (.inputRight .tag))) program (fun _ => atLabels _) |
| base i leftWord leftEmpty ambient |
| change (advance (TM2.step program))^[Input.steps i] |
| (some ⟨some (labels (.inputLeft .tag)), clean ambient, base⟩) = |
| some ⟨some (labels (.inputRight .tag)), clean ambient, |
| emitted (slots 4) (slots 5) base [.input i]⟩ at hi |
| let afterLeft := emitted (slots 4) (slots 5) base [.input i] |
| have hjWord : afterLeft (slots 1) = encodeWord j := by |
| simpa [afterLeft, emitted, slots.injective.eq_iff] using rightWord |
| have hjScratch : afterLeft (slots 2) = [] := by |
| simpa [afterLeft, emitted, slots.injective.eq_iff] using leftEmpty |
| have hj := Input.trace (inputRightMap.trans slots) (fun l => labels (.inputRight l)) |
| (some (labels .conjunction)) program (fun _ => atLabels _) |
| afterLeft j hjWord hjScratch ambient |
| change (advance (TM2.step program))^[Input.steps j] |
| (some ⟨some (labels (.inputRight .tag)), clean ambient, afterLeft⟩) = |
| some ⟨some (labels .conjunction), clean ambient, |
| emitted (slots 4) (slots 5) afterLeft [.input j]⟩ at hj |
| let afterRight := emitted (slots 4) (slots 5) afterLeft [.input j] |
| have hand : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .conjunction), clean ambient, afterRight⟩) = |
| some ⟨exit, clean ambient, emitted (slots 4) (slots 5) afterRight [.and]⟩ := by |
| change some (TM2.stepAux (program (labels .conjunction)) _ _) = _ |
| rw [atLabels, statement, stepAux_literal _ _ (slots.injective.ne (by decide))] |
| cases exit <;> rfl |
| have h := chain (chain hi hj) hand |
| simp only [afterRight, afterLeft, |
| emitted_append (slots 4) (slots 5) (slots.injective.ne (by decide : (4 : Fin 6) ≠ 5)), |
| List.singleton_append] at h |
| exact h |
|
|
| def steps (i j : Nat) : Nat := MachineUnaryLessAt.steps i j + 1 + |
| if i < j then offSteps i j else |
| MachineUnaryLessAt.steps j i + 1 + if j < i then offSteps i j else 1 |
|
|
| theorem trace (slots : Fin 6 ↪ K) (labels : Label → Λ) (exit : Option Λ) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (atLabels : ∀ l, program (labels l) = statement slots labels exit l) |
| (base : K → List Bool) (i j : Nat) |
| (leftWord : base (slots 0) = encodeWord i) (rightWord : base (slots 1) = encodeWord j) |
| (leftEmpty : base (slots 2) = []) (rightEmpty : base (slots 3) = []) (ambient : σ) : |
| (advance (TM2.step program))^[steps i j] |
| (some ⟨some (labels (.left .scan)), clean ambient, base⟩) = |
| some ⟨exit, clean ambient, emitted (slots 4) (slots 5) base (clashPairTokens i j)⟩ := by |
| have hl := MachineUnaryLessAt.lessThanTrace (leftMap.trans slots) |
| (fun l => labels (.left l)) (some (labels .branchLeft)) program (fun _ => atLabels _) |
| base i j [] [] (by simpa [leftMap] using leftWord) (by simpa [leftMap] using rightWord) |
| leftEmpty rightEmpty ambient false none |
| change (advance (TM2.step program))^[MachineUnaryLessAt.steps i j] |
| (some ⟨some (labels (.left .scan)), clean ambient, base⟩) = |
| some ⟨some (labels .branchLeft), ((ambient, decide (i < j)), none), base⟩ at hl |
| have hr := MachineUnaryLessAt.lessThanTrace (rightMap.trans slots) |
| (fun l => labels (.right l)) (some (labels .branchRight)) program (fun _ => atLabels _) |
| base j i [] [] (by simpa [rightMap] using rightWord) (by simpa [rightMap] using leftWord) |
| leftEmpty rightEmpty ambient false none |
| change (advance (TM2.step program))^[MachineUnaryLessAt.steps j i] |
| (some ⟨some (labels (.right .scan)), clean ambient, base⟩) = |
| some ⟨some (labels .branchRight), ((ambient, decide (j < i)), none), base⟩ at hr |
| have hbl : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .branchLeft), ((ambient, decide (i < j)), none), base⟩) = |
| some ⟨some (if i < j then labels (.inputLeft .tag) else labels (.right .scan)), |
| clean ambient, base⟩ := by |
| change some (TM2.stepAux (program (labels .branchLeft)) _ _) = _ |
| rw [atLabels, statement, stepAux_choose] |
| simp |
| have hbr : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .branchRight), ((ambient, decide (j < i)), none), base⟩) = |
| some ⟨some (if j < i then labels (.inputLeft .tag) else labels .diagonal), |
| clean ambient, base⟩ := by |
| change some (TM2.stepAux (program (labels .branchRight)) _ _) = _ |
| rw [atLabels, statement, stepAux_choose] |
| simp |
| have hoff := offTrace slots labels exit program atLabels base i j leftWord rightWord leftEmpty ambient |
| by_cases hij : i < j |
| · rw [ite_eq_left hij] at hbl |
| have h := chain (chain hl hbl) hoff |
| simpa only [steps, ite_eq_left hij, clashPairTokens, ite_eq_right (Nat.ne_of_lt hij)] using h |
| · rw [ite_eq_right hij] at hbl |
| by_cases hji : j < i |
| · rw [ite_eq_left hji] at hbr |
| have h := chain (chain (chain (chain hl hbl) hr) hbr) hoff |
| simpa only [steps, ite_eq_right hij, ite_eq_left hji, clashPairTokens, |
| ite_eq_right (Ne.symm (Nat.ne_of_lt hji)), Nat.add_assoc] using h |
| · rw [ite_eq_right hji] at hbr |
| have hd : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .diagonal), clean ambient, base⟩) = |
| some ⟨exit, clean ambient, emitted (slots 4) (slots 5) base [.const false]⟩ := by |
| change some (TM2.stepAux (program (labels .diagonal)) _ _) = _ |
| rw [atLabels, statement, stepAux_literal _ _ (slots.injective.ne (by decide))] |
| cases exit <;> rfl |
| have heq : i = j := by omega |
| have h := chain (chain (chain (chain hl hbl) hr) hbr) hd |
| simpa only [steps, ite_eq_right hij, ite_eq_right hji, clashPairTokens, |
| ite_eq_left heq, Nat.add_assoc] using h |
|
|
| theorem steps_le (i j : Nat) : steps i j ≤ 12 * (i + j + 2) := by |
| unfold steps offSteps Input.steps MachineUnaryLessAt.steps |
| have h₁ := Nat.min_le_left i j |
| have h₂ := Nat.min_le_left j i |
| split <;> (try split) <;> omega |
|
|
| end Pair |
|
|
| namespace Row |
|
|
| def pairMap : Fin 6 ↪ Fin 7 := ⟨![1, 2, 3, 4, 5, 6], by decide⟩ |
|
|
| inductive Label where |
| | guard |
| | pair (l : Pair.Label) |
| | increment |
| deriving DecidableEq, Fintype |
|
|
| def statement (slots : Fin 7 ↪ K) (labels : Label → Λ) (done : Λ) : |
| Label → TM2.Stmt (Alphabet (K := K)) Λ (State σ) |
| | .guard => MachineUnaryCounter.guard (slots 0) (labels (.pair (.left .scan))) done |
| | .pair l => Pair.statement (pairMap.trans slots) (fun l => labels (.pair l)) |
| (some (labels .increment)) l |
| | .increment => .push (slots 2) (fun _ => true) (.goto fun _ => labels .guard) |
|
|
| def frame (slots : Fin 7 ↪ K) (base : K → List Bool) (remaining current : Nat) : K → List Bool := |
| Function.update (Function.update base (slots 0) (encodeWord remaining)) (slots 2) (encodeWord current) |
|
|
| @[simp] theorem frame_current (slots : Fin 7 ↪ K) (base : K → List Bool) (r j : Nat) : |
| frame slots base r j (slots 2) = encodeWord j := by simp [frame] |
|
|
| @[simp] theorem frame_remaining (slots : Fin 7 ↪ K) (base : K → List Bool) (r j : Nat) : |
| frame slots base r j (slots 0) = encodeWord r := by simp [frame, slots.injective.eq_iff] |
|
|
| theorem counter_frame (slots : Fin 7 ↪ K) (base : K → List Bool) (r r' j : Nat) : |
| MachineUnaryCounter.counterTapes (slots 0) (frame slots base r j) r' [] = |
| frame slots base r' j := by |
| funext k |
| by_cases h₀ : k = slots 0 |
| · subst k; simp [MachineUnaryCounter.counterTapes, frame, slots.injective.eq_iff] |
| · by_cases h₂ : k = slots 2 <;> simp [MachineUnaryCounter.counterTapes, frame, h₀, h₂] |
|
|
| theorem emitted_frame (slots : Fin 7 ↪ K) (base : K → List Bool) (r j : Nat) (tokens : List Token) : |
| emitted (slots 5) (slots 6) (frame slots base r j) tokens = |
| frame slots (emitted (slots 5) (slots 6) base tokens) r j := by |
| funext k |
| by_cases h₀ : k = slots 0 |
| · subst k; simp [emitted, frame, slots.injective.eq_iff] |
| · by_cases h₂ : k = slots 2 |
| · subst k; simp [emitted, frame, slots.injective.eq_iff] |
| · by_cases h₅ : k = slots 5 |
| · subst k; simp [emitted, frame, slots.injective.eq_iff] |
| · by_cases h₆ : k = slots 6 |
| · subst k; simp [emitted, frame, slots.injective.eq_iff] |
| · simp [emitted, frame, h₀, h₂, h₅, h₆] |
|
|
| theorem increment_frame (slots : Fin 7 ↪ K) (base : K → List Bool) (r j : Nat) : |
| Function.update (frame slots base r j) (slots 2) (true :: encodeWord j) = |
| frame slots base r (j + 1) := by |
| simp [frame, encodeWord, List.replicate_succ] |
|
|
| def tokens (count i start : Nat) : List Token := |
| forTokens count (fun j => clashPairTokens i (start + j)) |
|
|
| theorem tokens_zero (i start : Nat) : tokens 0 i start = [] := rfl |
|
|
| theorem tokens_succ (count i start : Nat) : |
| tokens (count + 1) i start = clashPairTokens i start ++ tokens count i (start + 1) := by |
| rw [tokens, forTokens_succ_first] |
| simp only [Nat.add_zero] |
| apply congrArg (List.append (clashPairTokens i start)) |
| apply forTokens_congr |
| intro j _ |
| rw [show start + (j + 1) = start + 1 + j by omega] |
|
|
| def steps : Nat → Nat → Nat → Nat |
| | 0, _, _ => 1 |
| | count + 1, i, start => 1 + Pair.steps i start + 1 + steps count i (start + 1) |
|
|
| theorem trace (slots : Fin 7 ↪ K) (labels : Label → Λ) (done : Λ) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State σ)) |
| (atLabels : ∀ l, program (labels l) = statement slots labels done l) |
| (base : K → List Bool) (count i start : Nat) |
| (leftWord : base (slots 1) = encodeWord i) |
| (leftEmpty : base (slots 3) = []) (rightEmpty : base (slots 4) = []) (ambient : σ) : |
| (advance (TM2.step program))^[steps count i start] |
| (some ⟨some (labels .guard), clean ambient, frame slots base count start⟩) = |
| some ⟨some done, clean ambient, |
| frame slots (emitted (slots 5) (slots 6) base (tokens count i start)) 0 (start + count)⟩ := by |
| induction count generalizing base start with |
| | zero => |
| have h := MachineUnaryCounter.guardTrace_zero (slots 0) (labels .guard) |
| (labels (.pair (.left .scan))) done program (atLabels .guard) |
| (frame slots base 0 start) [] (ambient, false) none |
| simpa only [counter_frame, steps, tokens_zero, emitted_nil, Nat.add_zero, clean] using h |
| | succ count ih => |
| have hg := MachineUnaryCounter.guardTrace_succ (slots 0) (labels .guard) |
| (labels (.pair (.left .scan))) done program (atLabels .guard) |
| (frame slots base count start) count [] (ambient, false) none |
| simp only [counter_frame] at hg |
| have hiWord : frame slots base count start (slots 1) = encodeWord i := by |
| simpa [frame, slots.injective.eq_iff] using leftWord |
| have hsLeft : frame slots base count start (slots 3) = [] := by |
| simpa [frame, slots.injective.eq_iff] using leftEmpty |
| have hsRight : frame slots base count start (slots 4) = [] := by |
| simpa [frame, slots.injective.eq_iff] using rightEmpty |
| have hp := Pair.trace (pairMap.trans slots) (fun l => labels (.pair l)) |
| (some (labels .increment)) program (fun _ => atLabels _) |
| (frame slots base count start) i start hiWord (frame_current slots base count start) |
| hsLeft hsRight ambient |
| change (advance (TM2.step program))^[Pair.steps i start] |
| (some ⟨some (labels (.pair (.left .scan))), clean ambient, frame slots base count start⟩) = |
| some ⟨some (labels .increment), clean ambient, |
| emitted (slots 5) (slots 6) (frame slots base count start) (clashPairTokens i start)⟩ at hp |
| rw [emitted_frame] at hp |
| let nextBase := emitted (slots 5) (slots 6) base (clashPairTokens i start) |
| have hn : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .increment), clean ambient, frame slots nextBase count start⟩) = |
| some ⟨some (labels .guard), clean ambient, frame slots nextBase count (start + 1)⟩ := by |
| change some (TM2.stepAux (program (labels .increment)) _ _) = _ |
| rw [atLabels, statement] |
| simp only [TM2.stepAux, frame_current, increment_frame] |
| have hni : nextBase (slots 1) = encodeWord i := by |
| simpa [nextBase, emitted, slots.injective.eq_iff] using leftWord |
| have hnl : nextBase (slots 3) = [] := by |
| simpa [nextBase, emitted, slots.injective.eq_iff] using leftEmpty |
| have hnr : nextBase (slots 4) = [] := by |
| simpa [nextBase, emitted, slots.injective.eq_iff] using rightEmpty |
| have hr := ih nextBase (start + 1) hni hnl hnr |
| have h := chain (chain (chain hg hp) hn) hr |
| rw [show start + 1 + count = start + (count + 1) by omega] at h |
| simp only [nextBase, |
| emitted_append (slots 5) (slots 6) (slots.injective.ne (by decide : (5 : Fin 7) ≠ 6)), |
| ← tokens_succ] at h |
| exact h |
|
|
| theorem steps_le (count i start B : Nat) (hB : i + start + count ≤ B) : |
| steps count i start ≤ count * (12 * (B + 2) + 2) + 1 := by |
| induction count generalizing start with |
| | zero => simp [steps] |
| | succ count ih => |
| have hr := ih (start + 1) (by omega) |
| have hp := Pair.steps_le i start |
| have hpos : i + start + 2 ≤ B + 2 := by omega |
| have hm := Nat.mul_le_mul_left 12 hpos |
| rw [steps, Nat.succ_mul] |
| omega |
|
|
| end Row |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.ClashMachine |
|
|
| end OAI |
|
|
