| import OAI.Computability.BinPacking.CookLevin.ClashMachine |
| import OAI.Computability.BinPacking.CookLevin.TransitionArena |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.AcceptanceTemplate |
|
|
| open StatementCircuit VerifierCircuit PostfixModel PostfixAlignment InitializationTemplate |
|
|
| 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 _ |
|
|
| def headMask (V : NPVerifier) (k : V.computation.tm.K) |
| (symbol : Option (V.computation.tm.Γ k)) : Bool := by |
| by_cases h : k = V.computation.tm.k₁ |
| · subst k |
| exact decide (some (V.computation.outputAlphabet.invFun true) = symbol) |
| · exact decide ((none : Option (V.computation.tm.Γ k)) = symbol) |
|
|
| theorem accepting_label (V : NPVerifier) (S : Nat) (label : Option V.computation.tm.Λ) : |
| configEncoding S (accepting V) (.inl label) = decide (none = label) := rfl |
|
|
| theorem accepting_state (V : NPVerifier) (S : Nat) (state : V.computation.tm.σ) : |
| configEncoding S (accepting V) (.inr (.inl state)) = |
| decide (V.computation.tm.initialState = state) := rfl |
|
|
| theorem accepting_cell (V : NPVerifier) (S : Nat) (k : V.computation.tm.K) |
| (i : Fin S) (symbol : Option (V.computation.tm.Γ k)) : |
| configEncoding S (accepting V) (.inr (.inr ⟨k, i, symbol⟩)) = |
| if i.val = 0 then headMask V k symbol else decide ((none : Option (V.computation.tm.Γ k)) = symbol) := by |
| by_cases hk : k = V.computation.tm.k₁ |
| · subst k |
| rcases i with ⟨i, hi⟩ |
| cases i <;> simp [configEncoding, inputEncoding, accepting, Turing.haltList, |
| StackEncoding.encode, headMask] |
| · simp [configEncoding, inputEncoding, accepting, Turing.haltList, hk, |
| StackEncoding.encode, headMask] |
|
|
| def targetBit (V : NPVerifier) (input : List Bool) (j : Fin (width V input)) : Bool := |
| configEncoding (capacity V input.length) (accepting V) ((bitEquiv V input).symm j) |
|
|
| def mismatchTokens (expected : Bool) (wire : Nat) : List Token := |
| if expected then [.input wire, .not] else [.input wire] |
|
|
| def tokens (V : NPVerifier) (input : List Bool) |
| (wire : Fin (width V input + 1) → Nat) : List Token := |
| [.input (wire (Fin.last (width V input)))] ++ |
| (List.ofFn fun j : Fin (width V input) => |
| mismatchTokens (targetBit V input j) (wire j.castSucc)).flatten ++ |
| closeOr (width V input) ++ [.not, .and] |
|
|
| theorem mismatchTokens_eq (V : NPVerifier) (input : List Bool) |
| (wire : Fin (width V input + 1) → Nat) (j : Fin (width V input)) : |
| mismatchTokens (targetBit V input j) (wire j.castSucc) = |
| exprTokens wire (mismatchExpr V input j) := by |
| by_cases h : configEncoding (capacity V input.length) (accepting V) |
| ((bitEquiv V input).symm j) = true |
| · simp [mismatchTokens, targetBit, mismatchExpr, exprTokens, h] |
| · simp [mismatchTokens, targetBit, mismatchExpr, exprTokens, h] |
|
|
| theorem tokens_eq (V : NPVerifier) (input : List Bool) |
| (wire : Fin (width V input + 1) → Nat) : |
| tokens V input wire = exprTokens wire (acceptanceExpr V input) := by |
| simp only [acceptanceExpr, exprTokens, exprTokens_disjoin, |
| forestTokens_ofFn, List.length_ofFn] |
| simp [tokens, mismatchTokens_eq, List.append_assoc] |
|
|
| theorem compile_tokens (V : NPVerifier) (input : List Bool) |
| (wire : Fin (width V input + 1) → Nat) (start : Nat) (oldRoots : List Nat) : |
| compileTokens start oldRoots (tokens V input wire) = |
| some (start + (acceptanceExpr V input).size, |
| (acceptanceExpr V input).root start :: oldRoots, |
| (acceptanceExpr V input).gates wire start) := by |
| rw [tokens_eq] |
| exact compile_exprTokens wire (acceptanceExpr V input) start oldRoots |
|
|
| theorem tokens_length_le (V : NPVerifier) (input : List Bool) |
| (wire : Fin (width V input + 1) → Nat) : |
| (tokens V input wire).length ≤ 3 * width V input + 4 := by |
| rw [tokens_eq, exprTokens_length] |
| exact acceptanceExpr_size_le V input |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.AcceptanceTemplate |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.TransitionMachine |
|
|
| open Turing MachineComposition TransitionTemplate TermMachine PostfixModel |
|
|
| variable {K Λ σ : Type} {Γ : K → Type} |
| variable [DecidableEq K] [Fintype σ] [DecidableEq σ] |
| variable [∀ k, DecidableEq (Γ k)] [∀ k, Fintype (Γ k)] [DecidableEq Λ] [Fintype Λ] |
|
|
| abbrev Template := Global (Γ := Γ) (Λ := Λ) (σ := σ) |
|
|
| def listTokens (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (terms : List (Template (Γ := Γ) (Λ := Λ) (σ := σ))) (input : Input) : List Token := |
| terms.flatMap fun term => globalTokens indexing term input |
|
|
| def compileList (indexing : ConfigIndex.Indexing Γ Λ σ) : |
| (terms : List (Template (Γ := Γ) (Λ := Λ) (σ := σ))) → |
| Emitter (RootsValid indexing) (listTokens indexing terms) |
| | [] => (Emitter.literal (RootsValid indexing) []).congr (fun _ => rfl) |
| | term :: terms => ((compileGlobal indexing term).seq (compileList indexing terms)).congr |
| (fun _ => rfl) |
|
|
| def prefixTokens (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (terms : List (Template (Γ := Γ) (Λ := Λ) (σ := σ) × Bool)) |
| (input : Input) : List Token := |
| terms.flatMap fun term => globalTokens indexing term.1 input ++ |
| (if term.2 then [.not] else []) |
|
|
| def compilePrefix (indexing : ConfigIndex.Indexing Γ Λ σ) : |
| (terms : List (Template (Γ := Γ) (Λ := Λ) (σ := σ) × Bool)) → |
| Emitter (RootsValid indexing) (prefixTokens indexing terms) |
| | [] => (Emitter.literal (RootsValid indexing) []).congr (fun _ => rfl) |
| | term :: terms => |
| (((compileGlobal indexing term.1).seq |
| (Emitter.literal (RootsValid indexing) (if term.2 then [.not] else []))).seq |
| (compilePrefix indexing terms)).congr (fun _ => rfl) |
|
|
| def withCursor (input : Input) (cursor : Nat) : Input := { input with cursor := cursor } |
|
|
| def cursorTapes (base : Tape → List Bool) (cursor : Nat) : Tape → List Bool := |
| Function.update base .cursor (encodeWord cursor) |
|
|
| @[simp] theorem withCursor_cursor (input : Input) (cursor : Nat) : |
| (withCursor input cursor).cursor = cursor := rfl |
|
|
| @[simp] theorem withCursor_capacity (input : Input) (cursor : Nat) : |
| (withCursor input cursor).capacity = input.capacity := rfl |
|
|
| @[simp] theorem withCursor_roots (input : Input) (cursor : Nat) : |
| (withCursor input cursor).roots = input.roots := rfl |
|
|
| @[simp] theorem withCursor_withCursor (input : Input) (first second : Nat) : |
| withCursor (withCursor input first) second = withCursor input second := rfl |
|
|
| theorem Frame.cursor {input : Input} {base : Tape → List Bool} |
| (frame : Frame input base) (cursor : Nat) : |
| Frame (withCursor input cursor) (cursorTapes base cursor) := by |
| refine ⟨by simp [cursorTapes], ?_, ?_, ?_⟩ |
| · simpa [cursorTapes] using frame.capacityWord |
| · simpa [cursorTapes] using frame.rootsWord |
| · intro tape ht |
| have hc : tape ≠ .cursor := by intro h; subst tape; simp [work] at ht |
| simpa [cursorTapes, hc] using frame.clean tape ht |
|
|
| @[simp] theorem cursorTapes_same {input : Input} {base : Tape → List Bool} |
| (frame : Frame input base) : cursorTapes base input.cursor = base := by |
| simp only [cursorTapes, ← frame.cursorWord, Function.update_eq_self] |
|
|
| @[simp] theorem cursorTapes_twice (base : Tape → List Bool) (first second : Nat) : |
| cursorTapes (cursorTapes base first) second = cursorTapes base second := by |
| simp [cursorTapes] |
|
|
| theorem emitTapes_cursor (base : Tape → List Bool) (cursor : Nat) (tokens : List Token) : |
| emitTapes (cursorTapes base cursor) tokens = cursorTapes (emitTapes base tokens) cursor := by |
| funext tape |
| cases tape <;> simp [cursorTapes, emitTapes] |
|
|
| structure Plan where |
| «prefix» : List (Template (Γ := Γ) (Λ := Λ) (σ := σ) × Bool) |
| cells : List (Template (Γ := Γ) (Λ := Λ) (σ := σ)) |
| carry : Bool |
|
|
| def Valid (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : Prop := |
| indexing.width input.capacity + (if plan.carry then 1 else 0) ≤ input.roots.length |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem Valid.roots {indexing : ConfigIndex.Indexing Γ Λ σ} |
| {plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)} {input : Input} |
| (h : Valid indexing plan input) : RootsValid indexing input := by |
| unfold Valid at h |
| unfold RootsValid |
| omega |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem Valid.withCursor {indexing : ConfigIndex.Indexing Γ Λ σ} |
| {plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)} {input : Input} |
| (h : Valid indexing plan input) (cursor : Nat) : |
| Valid indexing plan (withCursor input cursor) := h |
|
|
| def finalValid (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : Prop := |
| Valid indexing plan input ∧ input.cursor = input.capacity |
|
|
| def finalTokens (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : List Token := |
| if plan.carry then [.input (rootLookup input.roots |
| (affineAddress .current indexing.symbolCount (indexing.labelCount + indexing.stateCount) input))] |
| else [] |
|
|
| def finalEmitter (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : |
| Emitter (finalValid indexing plan) (finalTokens indexing plan) := by |
| cases hc : plan.carry with |
| | false => |
| exact (Emitter.literal (finalValid indexing plan) []).congr (fun input => by |
| simp [finalTokens, hc]) |
| | true => |
| let emitter := Emitter.affineRoot (finalValid indexing plan) .current indexing.symbolCount |
| (indexing.labelCount + indexing.stateCount) (by |
| intro input hv |
| have haddr : affineAddress .current indexing.symbolCount |
| (indexing.labelCount + indexing.stateCount) input = indexing.width input.capacity := by |
| simp [affineAddress, Position.eval, hv.2, ConfigIndex.Indexing.width, |
| Nat.mul_comm, Nat.add_comm, Nat.add_assoc] |
| have hlt : indexing.width input.capacity < input.roots.length := by |
| have h := hv.1 |
| simp only [Valid, hc, ite_true] at h |
| omega |
| rw [haddr] |
| simp only [rootLookup, List.getElem?_eq_getElem hlt, Option.getD_some]) |
| exact emitter.congr (fun input => by simp [finalTokens, hc]) |
|
|
| def guard : Selector (testPredicate true .current) := Selector.positionTest true .current |
|
|
| inductive Label (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) |
| | prefix (label : (compilePrefix indexing plan.prefix).Label) |
| | test (label : guard.Label) |
| | dispatch |
| | cells (label : (compileList indexing plan.cells).Label) |
| | increment |
| | finishTokens (label : (finalEmitter indexing plan).Label) |
| | drain | finish |
| deriving Fintype |
|
|
| attribute [-instance] instFintypeLabel |
|
|
| instance labelFintype (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : Fintype (Label indexing plan) := |
| Fintype.ofEquiv |
| ((compilePrefix indexing plan.prefix).Label ⊕ guard.Label ⊕ Unit ⊕ |
| (compileList indexing plan.cells).Label ⊕ Unit ⊕ (finalEmitter indexing plan).Label ⊕ Unit ⊕ Unit) |
| (Label.proxyTypeEquiv indexing plan) |
|
|
| def program (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : |
| Label indexing plan → TM2.Stmt Alphabet (Label indexing plan) State |
| | .prefix label => MachineSubroutine.statement Label.prefix (some (.test guard.entry)) |
| ((compilePrefix indexing plan.prefix).program label) |
| | .test label => MachineSubroutine.statement Label.test (some .dispatch) (guard.program label) |
| | .dispatch => .branch (fun state => state.1.2) |
| (.load (fun _ => initialState) (.goto fun _ => .cells (compileList indexing plan.cells).entry)) |
| (.load (fun _ => initialState) (.goto fun _ => .finishTokens (finalEmitter indexing plan).entry)) |
| | .cells label => MachineSubroutine.statement Label.cells (some .increment) |
| ((compileList indexing plan.cells).program label) |
| | .increment => .push .cursor (fun _ => true) (.goto fun _ => .test guard.entry) |
| | .finishTokens label => MachineSubroutine.statement Label.finishTokens (some .drain) |
| ((finalEmitter indexing plan).program label) |
| | .drain => MachineDrain.drain .cursor .drain (some .finish) |
| | .finish => .push .cursor (fun _ => false) (.load (fun _ => initialState) .halt) |
|
|
| def machine (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : FinTM2 := by |
| letI := (compilePrefix indexing plan.prefix).finite |
| letI := guard.finite |
| letI := (compileList indexing plan.cells).finite |
| letI := (finalEmitter indexing plan).finite |
| exact { |
| K := Tape |
| k₀ := .cursor |
| k₁ := .reversed |
| Γ := Alphabet |
| Λ := Label indexing plan |
| main := .prefix (compilePrefix indexing plan.prefix).entry |
| σ := State |
| initialState := initialState |
| m := program indexing plan } |
|
|
| def cellTokens (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) (cursor : Nat) : List Token := |
| listTokens indexing plan.cells (withCursor input cursor) |
|
|
| def remainingTokens (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : Nat → Nat → List Token |
| | cursor, 0 => finalTokens indexing plan (withCursor input cursor) |
| | cursor, remaining + 1 => cellTokens indexing plan input cursor ++ |
| remainingTokens indexing plan input (cursor + 1) remaining |
|
|
| def loopSteps (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : Nat → Nat → Nat |
| | cursor, 0 => guard.steps (withCursor input cursor) + 1 + |
| (finalEmitter indexing plan).steps (withCursor input cursor) + (cursor + 2) + 1 |
| | cursor, remaining + 1 => guard.steps (withCursor input cursor) + 1 + |
| (compileList indexing plan.cells).steps (withCursor input cursor) + 1 + |
| loopSteps indexing plan input (cursor + 1) remaining |
|
|
| private theorem trace_trans {α : Type*} (f : α → α) {a b : Nat} {x y z : α} |
| (first : f^[a] x = y) (second : f^[b] y = z) : f^[a + b] x = z := by |
| rw [Nat.add_comm, Function.iterate_add_apply, first, second] |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem guardTrace (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) |
| (base : Tape → List Bool) (frame : Frame input base) : |
| (advance (TM2.step (program indexing plan)))^[guard.steps input] |
| (some ⟨some (.test guard.entry), initialState, base⟩) = |
| some ⟨some .dispatch, (((), decide (input.cursor < input.capacity)), none), base⟩ := by |
| have h := MachineSubroutine.trace Label.test (some Label.dispatch) guard.program |
| (program indexing plan) (fun _ => rfl) (guard.steps input) _ _ |
| (guard.trace input base frame) |
| simpa [MachineSubroutine.configuration, MachineSubroutine.label, testPredicate, Position.eval] |
| using! h |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem dispatchTrace (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (base : Tape → List Bool) (decision : Bool) : |
| (advance (TM2.step (program indexing plan)))^[1] |
| (some ⟨some .dispatch, (((), decision), none), base⟩) = |
| some ⟨some (if decision then .cells (compileList indexing plan.cells).entry |
| else .finishTokens (finalEmitter indexing plan).entry), initialState, base⟩ := by |
| cases decision <;> rfl |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem incrementTrace (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) |
| (base : Tape → List Bool) (frame : Frame input base) : |
| (advance (TM2.step (program indexing plan)))^[1] |
| (some ⟨some .increment, initialState, base⟩) = |
| some ⟨some (.test guard.entry), initialState, cursorTapes base (input.cursor + 1)⟩ := by |
| have hw : true :: base .cursor = encodeWord (input.cursor + 1) := by |
| rw [frame.cursorWord] |
| simp [encodeWord, List.replicate_succ] |
| change some (TM2.stepAux (program indexing plan .increment) initialState base) = _ |
| simp [program, TM2.stepAux, cursorTapes, hw] |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem resetTrace (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) |
| (base : Tape → List Bool) (frame : Frame input base) : |
| (advance (TM2.step (program indexing plan)))^[input.cursor + 3] |
| (some ⟨some .drain, initialState, base⟩) = |
| some ⟨none, initialState, cursorTapes base 0⟩ := by |
| have drain := MachineDrain.drainTrace .cursor Label.drain (some Label.finish) |
| (program indexing plan) rfl base (encodeWord input.cursor) ((), false) none |
| have heq : Function.update base .cursor (encodeWord input.cursor) = base := by |
| rw [← frame.cursorWord, Function.update_eq_self] |
| rw [heq, encodeWord_length] at drain |
| have finish : (advance (TM2.step (program indexing plan)))^[1] |
| (some ⟨some .finish, initialState, Function.update base .cursor []⟩) = |
| some ⟨none, initialState, cursorTapes base 0⟩ := by |
| change some (TM2.stepAux (program indexing plan .finish) initialState _) = _ |
| simp [program, TM2.stepAux, cursorTapes, encodeWord] |
| simpa [Nat.add_assoc, initialState] using trace_trans _ drain finish |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem loopTrace (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) |
| (valid : Valid indexing plan input) (cursor remaining : Nat) |
| (hcapacity : cursor + remaining = input.capacity) |
| (base : Tape → List Bool) (frame : Frame (withCursor input cursor) base) : |
| (advance (TM2.step (program indexing plan)))^[loopSteps indexing plan input cursor remaining] |
| (some ⟨some (.test guard.entry), initialState, base⟩) = |
| some ⟨none, initialState, |
| cursorTapes (emitTapes base (remainingTokens indexing plan input cursor remaining)) 0⟩ := by |
| induction remaining generalizing cursor base with |
| | zero => |
| have hc : cursor = input.capacity := by omega |
| have hg := guardTrace indexing plan (withCursor input cursor) base frame |
| have hd := dispatchTrace indexing plan base false |
| have hfalse : decide ((withCursor input cursor).cursor < |
| (withCursor input cursor).capacity) = false := by simp [hc] |
| rw [hfalse] at hg |
| simp only [Bool.false_eq_true, ite_false] at hd |
| have hv : finalValid indexing plan (withCursor input cursor) := ⟨valid.withCursor cursor, hc⟩ |
| have hf := (finalEmitter indexing plan).traceAt Label.finishTokens (some Label.drain) |
| (program indexing plan) (fun _ => rfl) (withCursor input cursor) hv base frame |
| have hr := resetTrace indexing plan (withCursor input cursor) |
| (emitTapes base (finalTokens indexing plan (withCursor input cursor))) |
| (frame.emit (finalTokens indexing plan (withCursor input cursor))) |
| have total := trace_trans _ (trace_trans _ (trace_trans _ hg hd) hf) hr |
| simpa only [loopSteps, remainingTokens, withCursor_cursor, Nat.add_assoc] using total |
| | succ remaining ih => |
| have hc : cursor < input.capacity := by omega |
| have hg := guardTrace indexing plan (withCursor input cursor) base frame |
| have hd := dispatchTrace indexing plan base true |
| have htrue : decide ((withCursor input cursor).cursor < |
| (withCursor input cursor).capacity) = true := by simp [hc] |
| rw [htrue] at hg |
| simp only [ite_true] at hd |
| have hb := (compileList indexing plan.cells).traceAt Label.cells (some Label.increment) |
| (program indexing plan) (fun _ => rfl) (withCursor input cursor) |
| (valid.withCursor cursor).roots base frame |
| have hi := incrementTrace indexing plan (withCursor input cursor) |
| (emitTapes base (cellTokens indexing plan input cursor)) |
| (frame.emit (cellTokens indexing plan input cursor)) |
| have hn := ih (cursor + 1) (by omega) |
| (cursorTapes (emitTapes base (cellTokens indexing plan input cursor)) (cursor + 1)) |
| (by simpa only [withCursor_withCursor] using |
| Frame.cursor (frame.emit (cellTokens indexing plan input cursor)) (cursor + 1)) |
| have total := trace_trans _ (trace_trans _ (trace_trans _ (trace_trans _ hg hd) hb) hi) hn |
| simpa only [loopSteps, remainingTokens, cellTokens, withCursor_cursor, |
| emitTapes_cursor, cursorTapes_twice, emitTapes_append, Nat.add_assoc] using total |
|
|
| def outputTokens (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : List Token := |
| prefixTokens indexing plan.prefix (withCursor input 0) ++ |
| remainingTokens indexing plan input 0 input.capacity |
|
|
| def steps (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : Nat := |
| (compilePrefix indexing plan.prefix).steps (withCursor input 0) + |
| loopSteps indexing plan input 0 input.capacity |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem fullTrace (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) |
| (valid : Valid indexing plan input) (base : Tape → List Bool) |
| (frame : Frame (withCursor input 0) base) : |
| (advance (TM2.step (program indexing plan)))^[steps indexing plan input] |
| (some ⟨some (.prefix (compilePrefix indexing plan.prefix).entry), initialState, base⟩) = |
| some ⟨none, initialState, emitTapes base (outputTokens indexing plan input)⟩ := by |
| have hp := (compilePrefix indexing plan.prefix).traceAt Label.prefix (some (.test guard.entry)) |
| (program indexing plan) (fun _ => rfl) (withCursor input 0) |
| (valid.withCursor 0).roots base frame |
| have hl := loopTrace indexing plan input valid 0 input.capacity (by omega) |
| (emitTapes base (prefixTokens indexing plan.prefix (withCursor input 0))) |
| (frame.emit (prefixTokens indexing plan.prefix (withCursor input 0))) |
| have hc : cursorTapes base 0 = base := cursorTapes_same frame |
| simpa only [steps, emitTapes_append, ← emitTapes_cursor, hc, outputTokens] |
| using trace_trans _ hp hl |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem traceAt {Caller : Type} (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) |
| (labels : Label indexing plan → Caller) (exit : Option Caller) |
| (target : Caller → TM2.Stmt Alphabet Caller State) |
| (code : ∀ label, target (labels label) = |
| MachineSubroutine.statement labels exit (program indexing plan label)) |
| (input : Input) (valid : Valid indexing plan input) (base : Tape → List Bool) |
| (frame : Frame (withCursor input 0) base) : |
| (advance (TM2.step target))^[steps indexing plan input] |
| (some ⟨some (labels (.prefix (compilePrefix indexing plan.prefix).entry)), initialState, base⟩) = |
| some ⟨exit, initialState, emitTapes base (outputTokens indexing plan input)⟩ := by |
| have h := MachineSubroutine.trace labels exit (program indexing plan) target code |
| (steps indexing plan input) _ _ (fullTrace indexing plan input valid base frame) |
| simpa only [MachineSubroutine.configuration, MachineSubroutine.label] using h |
|
|
| def loopConstant (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : Nat := |
| guard.constant + (compileList indexing plan.cells).constant + |
| (finalEmitter indexing plan).constant + 5 |
|
|
| def dataSize (input : Input) : Nat := input.capacity + (encodeWords input.roots).length |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem loopSteps_le (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) |
| (valid : Valid indexing plan input) (cursor remaining : Nat) |
| (hcapacity : cursor + remaining = input.capacity) : |
| loopSteps indexing plan input cursor remaining ≤ |
| (remaining + 1) * loopConstant indexing plan * |
| (2 * input.capacity + (encodeWords input.roots).length + 1) := by |
| let B := 2 * input.capacity + (encodeWords input.roots).length + 1 |
| have hB : 1 ≤ B := by dsimp [B]; omega |
| induction remaining generalizing cursor with |
| | zero => |
| have hc : cursor = input.capacity := by omega |
| have hs : (withCursor input cursor).size + 1 ≤ B := by simp [Input.size, B]; omega |
| have hg := guard.bound (withCursor input cursor) |
| have hf := (finalEmitter indexing plan).bound (withCursor input cursor) |
| ⟨valid.withCursor cursor, hc⟩ |
| have hg' := hg.trans (Nat.mul_le_mul_left guard.constant hs) |
| have hf' := hf.trans (Nat.mul_le_mul_left (finalEmitter indexing plan).constant hs) |
| have hcB : cursor ≤ B := by dsimp [B]; omega |
| simp only [loopSteps, Nat.zero_add, Nat.one_mul] |
| change _ ≤ loopConstant indexing plan * B |
| dsimp [loopConstant] |
| nlinarith [Nat.zero_le ((compileList indexing plan.cells).constant * B)] |
| | succ remaining ih => |
| have hc : cursor ≤ input.capacity := by omega |
| have hs : (withCursor input cursor).size + 1 ≤ B := by simp [Input.size, B]; omega |
| have hg := guard.bound (withCursor input cursor) |
| have hb := (compileList indexing plan.cells).bound (withCursor input cursor) |
| (valid.withCursor cursor).roots |
| have hg' := hg.trans (Nat.mul_le_mul_left guard.constant hs) |
| have hb' := hb.trans (Nat.mul_le_mul_left (compileList indexing plan.cells).constant hs) |
| have hi := ih (cursor + 1) (by omega) |
| simp only [loopSteps] |
| have hstep : guard.steps (withCursor input cursor) + 1 + |
| (compileList indexing plan.cells).steps (withCursor input cursor) + 1 ≤ |
| loopConstant indexing plan * B := by |
| dsimp [loopConstant] |
| nlinarith [Nat.zero_le ((finalEmitter indexing plan).constant * B)] |
| calc |
| _ ≤ loopConstant indexing plan * B + (remaining + 1) * loopConstant indexing plan * B := |
| Nat.add_le_add hstep hi |
| _ = _ := by dsimp [B]; ring |
|
|
| def timeConstant (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : Nat := |
| 2 * ((compilePrefix indexing plan.prefix).constant + loopConstant indexing plan) |
|
|
| noncomputable def timePolynomial (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) : Polynomial Nat := |
| Polynomial.C (timeConstant indexing plan) * (Polynomial.X + 1)^2 |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem steps_le (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) |
| (valid : Valid indexing plan input) : |
| steps indexing plan input ≤ timeConstant indexing plan * (dataSize input + 1)^2 := by |
| have hp := (compilePrefix indexing plan.prefix).bound (withCursor input 0) |
| (valid.withCursor 0).roots |
| have hl := loopSteps_le indexing plan input valid 0 input.capacity (by omega) |
| have hcap : input.capacity + 1 ≤ dataSize input + 1 := by simp [dataSize] |
| have hdata : 2 * input.capacity + (encodeWords input.roots).length + 1 ≤ |
| 2 * (dataSize input + 1) := by unfold dataSize; omega |
| have hmul := Nat.mul_le_mul hcap hdata |
| have hp' : (compilePrefix indexing plan.prefix).steps (withCursor input 0) ≤ |
| (compilePrefix indexing plan.prefix).constant * (dataSize input + 1) := by |
| simpa [withCursor, Input.size, dataSize] using hp |
| have hprod := Nat.mul_le_mul_left (loopConstant indexing plan) hmul |
| have hsq : dataSize input + 1 ≤ (dataSize input + 1)^2 := by nlinarith |
| have hprefix := Nat.mul_le_mul_left (compilePrefix indexing plan.prefix).constant hsq |
| unfold steps timeConstant |
| nlinarith |
|
|
| def inPolynomialTime (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) |
| (valid : Valid indexing plan input) (base : Tape → List Bool) |
| (frame : Frame (withCursor input 0) base) : |
| StateTransition.EvalsToInTime (machine indexing plan).step |
| ⟨some (Label.prefix (compilePrefix indexing plan.prefix).entry), initialState, base⟩ |
| (some ⟨none, initialState, emitTapes base (outputTokens indexing plan input)⟩) |
| ((timePolynomial indexing plan).eval (dataSize input)) where |
| steps := steps indexing plan input |
| evals_in_steps := fullTrace indexing plan input valid base frame |
| steps_le_m := by |
| simpa only [timePolynomial, Polynomial.eval_mul, Polynomial.eval_C, |
| Polynomial.eval_pow, Polynomial.eval_add, Polynomial.eval_X, Polynomial.eval_one] |
| using steps_le indexing plan input valid |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem remainingTokens_eq_range (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) (cursor remaining : Nat) : |
| remainingTokens indexing plan input cursor remaining = |
| ((List.range' cursor remaining).flatMap (cellTokens indexing plan input)) ++ |
| finalTokens indexing plan (withCursor input (cursor + remaining)) := by |
| induction remaining generalizing cursor with |
| | zero => simp [remainingTokens] |
| | succ remaining ih => |
| simp [remainingTokens, List.range'_succ, ih, List.append_assoc, |
| Nat.add_comm, Nat.add_left_comm] |
|
|
| def carriedTokens (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : List Token := |
| if plan.carry then [.input (rootLookup input.roots (indexing.width input.capacity))] else [] |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem finalTokens_at_capacity (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : |
| finalTokens indexing plan (withCursor input input.capacity) = carriedTokens indexing plan input := by |
| simp [finalTokens, carriedTokens, affineAddress, Position.eval, |
| ConfigIndex.Indexing.width, Nat.mul_comm, Nat.add_comm, Nat.add_assoc] |
|
|
| omit [DecidableEq K] [Fintype σ] [DecidableEq σ] [(tape : K) → DecidableEq (Γ tape)] |
| [(tape : K) → Fintype (Γ tape)] [DecidableEq Λ] [Fintype Λ] in |
| theorem outputTokens_eq_blocks (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (plan : Plan (Γ := Γ) (Λ := Λ) (σ := σ)) (input : Input) : |
| outputTokens indexing plan input = |
| prefixTokens indexing plan.prefix (withCursor input 0) ++ |
| ((List.finRange input.capacity).flatMap fun cursor => |
| cellTokens indexing plan input cursor.val) ++ carriedTokens indexing plan input := by |
| rw [outputTokens, remainingTokens_eq_range] |
| simp only [Nat.zero_add, finalTokens_at_capacity] |
| rw [← List.range_eq_range', ← List.map_coe_finRange_eq_range, List.flatMap_map] |
| simp only [List.append_assoc] |
|
|
| def transitionPrefixKinds (indexing : ConfigIndex.Indexing Γ Λ σ) : List (OutputKind Γ Λ σ) := |
| ((List.finRange indexing.labelCount).map fun i => .inl (indexing.labels.symm i)) ++ |
| ((List.finRange indexing.stateCount).map fun i => .inr (.inl (indexing.states.symm i))) |
|
|
| def transitionCellKinds (indexing : ConfigIndex.Indexing Γ Λ σ) : List (OutputKind Γ Λ σ) := |
| (List.finRange indexing.symbolCount).map fun i => .inr (.inr (indexing.symbols.symm i)) |
|
|
| noncomputable def transitionPlan (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) : Plan (Γ := Γ) (Λ := Λ) (σ := σ) where |
| «prefix» := (transitionPrefixKinds indexing).map fun kind => (sticky machineProgram kind, false) |
| cells := (transitionCellKinds indexing).map (sticky machineProgram) |
| carry := true |
|
|
| theorem transition_outputTokens (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (input : Input) : |
| outputTokens indexing (transitionPlan indexing machineProgram) input = |
| TransitionTemplate.forestTokens indexing input.roots input.capacity machineProgram ++ |
| [.input (rootLookup input.roots (indexing.width input.capacity))] := by |
| rw [outputTokens_eq_blocks] |
| simp [transitionPlan, transitionPrefixKinds, transitionCellKinds, |
| prefixTokens, listTokens, cellTokens, globalTokens, carriedTokens, |
| TransitionTemplate.forestTokens, OutputOrder.outputOrder_eq_blocks, |
| List.flatMap_append, List.flatMap_map, List.flatMap_assoc, withCursor, bitKind, bitCursor, |
| List.append_assoc] |
|
|
| noncomputable def transitionInPolynomialTime (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (input : Input) |
| (valid : indexing.width input.capacity + 1 ≤ input.roots.length) |
| (base : Tape → List Bool) (frame : Frame (withCursor input 0) base) : |
| StateTransition.EvalsToInTime (machine indexing (transitionPlan indexing machineProgram)).step |
| ⟨some (Label.prefix (compilePrefix indexing (transitionPlan indexing machineProgram).prefix).entry), |
| initialState, base⟩ |
| (some ⟨none, initialState, emitTapes base |
| (TransitionTemplate.forestTokens indexing input.roots input.capacity machineProgram ++ |
| [.input (rootLookup input.roots (indexing.width input.capacity))])⟩) |
| ((timePolynomial indexing (transitionPlan indexing machineProgram)).eval (dataSize input)) := by |
| have hv : Valid indexing (transitionPlan indexing machineProgram) input := by |
| simpa only [Valid, transitionPlan, ite_true] using valid |
| simpa only [transition_outputTokens] using |
| inPolynomialTime indexing (transitionPlan indexing machineProgram) input hv base frame |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.TransitionMachine |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.AcceptancePlan |
|
|
| open StatementCircuit TransitionTemplate AcceptanceTemplate |
| open PostfixModel VerifierCircuit TermMachine |
|
|
| local instance (V : NPVerifier) : Fintype V.computation.tm.Λ := V.computation.tm.ΛFin |
| local instance (V : NPVerifier) : Fintype V.computation.tm.σ := V.computation.tm.σFin |
| local instance (V : NPVerifier) : ∀ k, Fintype (V.computation.tm.Γ k) := V.finiteAlphabet |
| 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 _ |
|
|
| def negateIf {K σ : Type} {Γ : K → Type} (condition : Bool) (e : Term Γ σ) : Term Γ σ := |
| if condition then .not e else e |
|
|
| def stateTemplate (V : NPVerifier) (state : V.computation.tm.σ) : |
| Global (Γ := V.computation.tm.Γ) (Λ := V.computation.tm.Λ) (σ := V.computation.tm.σ) := |
| .data (negateIf (decide (V.computation.tm.initialState = state)) (.state state)) |
|
|
| def cellTemplate (V : NPVerifier) (k : V.computation.tm.K) |
| (symbol : Option (V.computation.tm.Γ k)) : |
| Global (Γ := V.computation.tm.Γ) (Λ := V.computation.tm.Λ) (σ := V.computation.tm.σ) := |
| .data (.atZero .current |
| (negateIf (headMask V k symbol) (.cell k .current symbol)) |
| (negateIf (decide ((none : Option (V.computation.tm.Γ k)) = symbol)) |
| (.cell k .current symbol))) |
|
|
| def plan (V : NPVerifier) : |
| TransitionMachine.Plan (Γ := V.computation.tm.Γ) (Λ := V.computation.tm.Λ) |
| (σ := V.computation.tm.σ) where |
| «prefix» := |
| ((List.finRange (indexing V).labelCount).map fun i => |
| (Global.label ((indexing V).labels.symm i), |
| decide ((none : Option V.computation.tm.Λ) = (indexing V).labels.symm i))) ++ |
| ((List.finRange (indexing V).stateCount).map fun i => |
| (stateTemplate V ((indexing V).states.symm i), false)) |
| cells := (List.finRange (indexing V).symbolCount).map fun i => |
| let symbol := (indexing V).symbols.symm i |
| cellTemplate V symbol.1 symbol.2 |
| carry := false |
|
|
| def mismatchForest (V : NPVerifier) (roots : List Nat) (S : Nat) : List Token := |
| (outputOrder (indexing V) S).flatMap fun bit => |
| mismatchTokens (configEncoding S (accepting V) bit) |
| (configWire (indexing V) roots S bit) |
|
|
| theorem label_tokens (V : NPVerifier) (roots : List Nat) (S cursor : Nat) |
| (label : Option V.computation.tm.Λ) : |
| (Global.label label).tokens (indexing V) roots S cursor ++ |
| (if decide ((none : Option V.computation.tm.Λ) = label) then [.not] else []) = |
| mismatchTokens (configEncoding S (accepting V) (.inl label)) |
| (configWire (indexing V) roots S (.inl label)) := by |
| rw [accepting_label] |
| by_cases h : (none : Option V.computation.tm.Λ) = label |
| · simp [Global.tokens, configWire, mismatchTokens, h] |
| · simp [Global.tokens, configWire, mismatchTokens, h] |
|
|
| theorem state_tokens (V : NPVerifier) (roots : List Nat) (S cursor : Nat) |
| (state : V.computation.tm.σ) : |
| (stateTemplate V state).tokens (indexing V) roots S cursor = |
| mismatchTokens (configEncoding S (accepting V) (.inr (.inl state))) |
| (configWire (indexing V) roots S (.inr (.inl state))) := by |
| rw [accepting_state] |
| by_cases h : V.computation.tm.initialState = state |
| · simp [stateTemplate, negateIf, Global.tokens, Term.tokens, configWire, mismatchTokens, h] |
| · simp [stateTemplate, negateIf, Global.tokens, Term.tokens, configWire, mismatchTokens, h] |
|
|
| theorem cell_tokens (V : NPVerifier) (roots : List Nat) (S : Nat) |
| (i : Fin S) (k : V.computation.tm.K) (symbol : Option (V.computation.tm.Γ k)) : |
| (cellTemplate V k symbol).tokens (indexing V) roots S i.val = |
| mismatchTokens (configEncoding S (accepting V) (.inr (.inr ⟨k, i, symbol⟩))) |
| (configWire (indexing V) roots S (.inr (.inr ⟨k, i, symbol⟩))) := by |
| rw [accepting_cell] |
| have hS : 0 < S := lt_of_le_of_lt (Nat.zero_le i.val) i.isLt |
| by_cases hi : i.val = 0 |
| · cases hb : headMask V k symbol <;> |
| simp [cellTemplate, negateIf, Global.tokens, Term.tokens, Position.eval, |
| hS, hi, hb, mismatchTokens, configWire] |
| · by_cases hs : (none : Option (V.computation.tm.Γ k)) = symbol |
| · simp [cellTemplate, negateIf, Global.tokens, Term.tokens, Position.eval, |
| i.isLt, hi, hs, mismatchTokens, configWire] |
| · simp [cellTemplate, negateIf, Global.tokens, Term.tokens, Position.eval, |
| i.isLt, hi, hs, mismatchTokens, configWire] |
|
|
| theorem outputTokens_eq (V : NPVerifier) (input : TermMachine.Input) : |
| TransitionMachine.outputTokens (indexing V) (plan V) input = |
| mismatchForest V input.roots input.capacity := by |
| rw [TransitionMachine.outputTokens_eq_blocks] |
| simp only [mismatchForest, OutputOrder.outputOrder_eq_blocks, List.flatMap_append, |
| List.flatMap_map, List.flatMap_assoc] |
| simp only [plan, TransitionMachine.prefixTokens, List.flatMap_append, List.flatMap_map, |
| TransitionMachine.cellTokens, TransitionMachine.listTokens, |
| TermMachine.globalTokens, TransitionMachine.withCursor_roots, |
| TransitionMachine.withCursor_capacity, TransitionMachine.withCursor_cursor, |
| TransitionMachine.carriedTokens, Bool.false_eq_true, ↓reduceIte, List.append_nil] |
| congr 1 |
| · congr 1 |
| · apply List.flatMap_congr |
| intro i _ |
| exact label_tokens V input.roots input.capacity 0 ((indexing V).labels.symm i) |
| · apply List.flatMap_congr |
| intro i _ |
| simpa using state_tokens V input.roots input.capacity 0 ((indexing V).states.symm i) |
| · apply List.flatMap_congr |
| intro i _ |
| apply List.flatMap_congr |
| intro j _ |
| exact cell_tokens V input.roots input.capacity i |
| ((indexing V).symbols.symm j).1 ((indexing V).symbols.symm j).2 |
|
|
| theorem mismatchForest_circuit (V : NPVerifier) (input : List Bool) (roots : List Nat) : |
| mismatchForest V roots (capacity V input.length) = |
| (List.ofFn fun j : Fin (width V input) => |
| mismatchTokens (targetBit V input j) (rootLookup roots j.val)).flatten := by |
| simp only [mismatchForest, outputOrder, List.flatMap_def, |
| Function.comp_def, configWire, Equiv.apply_symm_apply, targetBit, |
| ← List.ofFn_eq_map, List.map_ofFn, bitEquiv] |
|
|
| theorem fullTokens_eq (V : NPVerifier) (input : List Bool) (roots : List Nat) : |
| AcceptanceTemplate.tokens V input (fun j => rootLookup roots j.val) = |
| [.input (rootLookup roots (width V input))] ++ |
| TransitionMachine.outputTokens (indexing V) (plan V) |
| ⟨0, capacity V input.length, roots⟩ ++ |
| InitializationTemplate.closeOr (width V input) ++ [.not, .and] := by |
| rw [outputTokens_eq, mismatchForest_circuit] |
| rfl |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.AcceptancePlan |
|
|
| namespace BinPackingGames.Foundations.Complexity.CookLevin.TransitionIteration |
|
|
| open Turing MachineComposition StatementCircuit CircuitBatch TransitionTemplate |
|
|
| open TransitionArena |
|
|
| variable {K Λ σ : Type} {Γ : K → Type} |
| variable [DecidableEq K] [Fintype σ] [DecidableEq σ] |
| variable [∀ k, DecidableEq (Γ k)] [∀ k, Fintype (Γ k)] [DecidableEq Λ] [Fintype Λ] |
|
|
| noncomputable def tokens (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (S : Nat) |
| (snapshot : ProducerInvariant.Snapshot) : List PostfixModel.Token := |
| ProducerInvariant.transitionTokens indexing machineProgram S snapshot.roots |
|
|
| noncomputable def emitSteps (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (S : Nat) |
| (snapshot : ProducerInvariant.Snapshot) : Nat := |
| TransitionMachine.steps indexing (TransitionMachine.transitionPlan indexing machineProgram) |
| (termInput S snapshot) |
|
|
| theorem emitTraceAt {Caller : Type} (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) |
| (labels : TransitionMachine.Label indexing (TransitionMachine.transitionPlan indexing machineProgram) → Caller) |
| (exit : Option Caller) (target : Caller → TM2.Stmt Alphabet Caller State) |
| (code : ∀ label, target (labels label) = ForestPlacement.statement termPorts labels exit |
| (TransitionMachine.program indexing (TransitionMachine.transitionPlan indexing machineProgram) label)) |
| (base : Tape → List Bool) (S remaining : Nat) (snapshot : ProducerInvariant.Snapshot) |
| (valid : indexing.width S + 1 ≤ snapshot.roots.length) : |
| (advance (TM2.step target))^[emitSteps indexing machineProgram S snapshot] |
| (some ⟨some (labels (.prefix (TransitionMachine.compilePrefix indexing |
| (TransitionMachine.transitionPlan indexing machineProgram).prefix).entry)), |
| TermMachine.initialState, tapes base S remaining snapshot⟩) = |
| some ⟨exit, TermMachine.initialState, |
| preparedTapes base S remaining snapshot (tokens indexing machineProgram S snapshot)⟩ := by |
| let input := termInput S snapshot |
| let plan := TransitionMachine.transitionPlan indexing machineProgram |
| have hv : TransitionMachine.Valid indexing plan input := by |
| simpa [TransitionMachine.Valid, plan, TransitionMachine.transitionPlan, input, termInput] using valid |
| have sourceTrace := TransitionMachine.fullTrace indexing plan input hv |
| (fun tape => tapes base S remaining snapshot (termPorts tape)) |
| (termFrame base S remaining snapshot) |
| have placed := ForestPlacement.trace termPorts labels exit (tapes base S remaining snapshot) |
| (TransitionMachine.program indexing plan) target code |
| (TransitionMachine.steps indexing plan input) _ _ sourceTrace |
| simp only [ForestPlacement.configuration, ForestPlacement.placedLabel, |
| ForestPlacement.fill_self] at placed |
| rw [TransitionMachine.transition_outputTokens, place_emitTapes] at placed |
| simpa only [emitSteps, tokens, ProducerInvariant.transitionTokens, input, termInput, plan] |
| using placed |
|
|
| abbrev Label (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) := |
| Unit ⊕ (TransitionMachine.Label indexing |
| (TransitionMachine.transitionPlan indexing machineProgram) ⊕ ForestStage.Label) |
|
|
| def entry (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) : Label indexing machineProgram := .inl () |
|
|
| def emitLabel (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) |
| (label : TransitionMachine.Label indexing (TransitionMachine.transitionPlan indexing machineProgram)) : |
| Label indexing machineProgram := .inr (.inl label) |
|
|
| def lowerLabel (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (label : ForestStage.Label) : |
| Label indexing machineProgram := .inr (.inr label) |
|
|
| noncomputable def emitEntry (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) : Label indexing machineProgram := |
| emitLabel indexing machineProgram (.prefix (TransitionMachine.compilePrefix indexing |
| (TransitionMachine.transitionPlan indexing machineProgram).prefix).entry) |
|
|
| def countdownStatement {Caller : Type} (next : Caller) : TM2.Stmt Alphabet Caller State := |
| .peek (.inr .countdown) (fun _ head => (((), head.getD false), none)) |
| (.branch (fun state => state.1.2) |
| (.pop (.inr .countdown) (fun _ _ => TermMachine.initialState) (.goto fun _ => next)) |
| (.pop (.inr .countdown) (fun _ _ => TermMachine.initialState) .halt)) |
|
|
| noncomputable def program (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) : |
| Label indexing machineProgram → TM2.Stmt Alphabet (Label indexing machineProgram) State |
| | .inl _ => countdownStatement (emitEntry indexing machineProgram) |
| | .inr (.inl label) => ForestPlacement.statement termPorts (emitLabel indexing machineProgram) |
| (some (lowerLabel indexing machineProgram .reverseTokens)) |
| (TransitionMachine.program indexing (TransitionMachine.transitionPlan indexing machineProgram) label) |
| | .inr (.inr label) => ForestStage.statement (σ := Unit) forestPorts |
| (lowerLabel indexing machineProgram) (some (entry indexing machineProgram)) label |
|
|
| noncomputable def machine (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) : FinTM2 where |
| K := Tape |
| k₀ := .inr .raw |
| k₁ := .inl .records |
| Γ := Alphabet |
| Λ := Label indexing machineProgram |
| main := entry indexing machineProgram |
| σ := State |
| initialState := TermMachine.initialState |
| m := program indexing machineProgram |
|
|
| theorem guardZero (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (base : Tape → List Bool) |
| (S : Nat) (snapshot : ProducerInvariant.Snapshot) : |
| (advance (TM2.step (program indexing machineProgram)))^[1] |
| (some ⟨some (entry indexing machineProgram), TermMachine.initialState, tapes base S 0 snapshot⟩) = |
| some ⟨none, TermMachine.initialState, finishTapes base S snapshot⟩ := by |
| change some (TM2.stepAux (program indexing machineProgram (entry indexing machineProgram)) |
| TermMachine.initialState (tapes base S 0 snapshot)) = _ |
| simp [program, entry, countdownStatement, TM2.stepAux, tapes, encodeWord, finishTapes] |
|
|
| theorem guardSucc (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (base : Tape → List Bool) |
| (S remaining : Nat) (snapshot : ProducerInvariant.Snapshot) : |
| (advance (TM2.step (program indexing machineProgram)))^[1] |
| (some ⟨some (entry indexing machineProgram), TermMachine.initialState, |
| tapes base S (remaining + 1) snapshot⟩) = |
| some ⟨some (emitEntry indexing machineProgram), TermMachine.initialState, |
| tapes base S remaining snapshot⟩ := by |
| change some (TM2.stepAux (program indexing machineProgram (entry indexing machineProgram)) |
| TermMachine.initialState (tapes base S (remaining + 1) snapshot)) = _ |
| simp only [program, entry, countdownStatement, TM2.stepAux] |
| have hhead : (tapes base S (remaining + 1) snapshot (.inr .countdown)).head? = some true := by |
| simp [tapes, encodeWord, List.replicate_succ] |
| rw [hhead] |
| simpa only [Option.getD_some, Bool.cond_true] using |
| congrArg (fun stack => some (TM2.Cfg.mk (some (emitEntry indexing machineProgram)) |
| TermMachine.initialState stack)) (tapes_countdown_tail base S remaining snapshot) |
|
|
| variable {inputs : Nat} |
|
|
| noncomputable def stageGates (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (S : Nat) |
| (frame : CircuitBatch.Frame inputs (indexing.width S + 1)) : List Gate := |
| Batch.gates (fun i => (frame.wires i).val) (ProducerInvariant.next frame) |
| (List.ofFn (ProducerInvariant.stepExpressions indexing machineProgram S)) |
|
|
| noncomputable def lowerSteps (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (S : Nat) |
| (frame : CircuitBatch.Frame inputs (indexing.width S + 1)) : Nat := |
| ForestStage.steps (tokens indexing machineProgram S (ProducerInvariant.snapshot frame)) |
| (ProducerInvariant.next frame) |
| (ProducerInvariant.rootValues |
| (frame.step (ProducerInvariant.stepExpressions indexing machineProgram S))).reverse |
| (stageGates indexing machineProgram S frame) (encodeWords (ProducerInvariant.rootValues frame)) |
|
|
| noncomputable def stageSteps (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (S : Nat) |
| (frame : CircuitBatch.Frame inputs (indexing.width S + 1)) : Nat := |
| emitSteps indexing machineProgram S (ProducerInvariant.snapshot frame) + |
| lowerSteps indexing machineProgram S frame |
|
|
| noncomputable def steps (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (S : Nat) : |
| CircuitBatch.Frame inputs (indexing.width S + 1) → Nat → Nat |
| | _, 0 => 1 |
| | frame, remaining + 1 => 1 + stageSteps indexing machineProgram S frame + |
| steps indexing machineProgram S |
| (frame.step (ProducerInvariant.stepExpressions indexing machineProgram S)) remaining |
|
|
| 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] |
|
|
| theorem place_forest_initial (base : Tape → List Bool) (S remaining : Nat) |
| (snapshot : ProducerInvariant.Snapshot) (ts : List PostfixModel.Token) : |
| ForestPlacement.fill forestPorts (tapes base S remaining snapshot) |
| (ForestStage.initialLocal snapshot.current ts snapshot.reversedRecords |
| (encodeWords snapshot.roots)) = preparedTapes base S remaining snapshot ts := by |
| rw [fill_forest] |
| funext tape |
| cases tape with |
| | inl tape => |
| cases tape with |
| | lower tape => cases tape <;> simp [ForestStage.initialLocal, preparedTapes, tapes] |
| | tokens => simp [ForestStage.initialLocal, preparedTapes] |
| | records => simp [ForestStage.initialLocal, preparedTapes, tapes] |
| | rootTable => simp [ForestStage.initialLocal, preparedTapes, tapes] |
| | inr tape => cases tape <;> simp [preparedTapes, tapes] |
|
|
| theorem place_forest_final {oldWidth newWidth : Nat} |
| (base : Tape → List Bool) (S remaining : Nat) (frame : Frame inputs oldWidth) |
| (es : Fin newWidth → Expr (Fin oldWidth)) : |
| ForestPlacement.fill forestPorts (tapes base S remaining (ProducerInvariant.snapshot frame)) |
| (ForestStage.finalLocal (ProducerInvariant.next (frame.step es)) |
| (ProducerInvariant.rootValues (frame.step es)).reverse |
| (recordsBits (gateRecords |
| (ProducerInvariant.next frame) |
| (Batch.gates (fun i => (frame.wires i).val) (ProducerInvariant.next frame) (List.ofFn es)))) |
| (ProducerInvariant.snapshot frame).reversedRecords) = |
| tapes base S remaining (ProducerInvariant.snapshot (frame.step es)) := by |
| have hr := congrArg List.reverse (ProducerInvariant.recordBits_step frame es) |
| rw [List.reverse_append] at hr |
| rw [fill_forest] |
| funext tape |
| cases tape with |
| | inl tape => |
| cases tape with |
| | lower tape => cases tape <;> rfl |
| | tokens => rfl |
| | rootTable => simp only [ForestStage.finalLocal, List.reverse_reverse]; rfl |
| | records => exact hr.symm |
| | inr tape => cases tape <;> rfl |
|
|
| theorem stageTrace (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (base : Tape → List Bool) |
| (S remaining : Nat) (frame : Frame inputs (indexing.width S + 1)) : |
| (advance (TM2.step (program indexing machineProgram)))^[ |
| stageSteps indexing machineProgram S frame] |
| (some ⟨some (emitEntry indexing machineProgram), TermMachine.initialState, |
| tapes base S remaining (ProducerInvariant.snapshot frame)⟩) = |
| some ⟨some (entry indexing machineProgram), TermMachine.initialState, |
| tapes base S remaining (ProducerInvariant.snapshot |
| (frame.step (ProducerInvariant.stepExpressions indexing machineProgram S)))⟩ := by |
| let es := ProducerInvariant.stepExpressions indexing machineProgram S |
| have emitted := emitTraceAt indexing machineProgram (emitLabel indexing machineProgram) |
| (some (lowerLabel indexing machineProgram .reverseTokens)) (program indexing machineProgram) |
| (fun _ => rfl) base S remaining (ProducerInvariant.snapshot frame) |
| (by simp only [ProducerInvariant.snapshot, List.length_ofFn]; exact le_rfl) |
| have compiled := ForestStage.traceAt (σ := Unit) forestPorts (lowerLabel indexing machineProgram) |
| (some (entry indexing machineProgram)) (program indexing machineProgram) (fun _ => rfl) |
| (tapes base S remaining (ProducerInvariant.snapshot frame)) ((), false) |
| (tokens indexing machineProgram S (ProducerInvariant.snapshot frame)) |
| (ProducerInvariant.next frame) (ProducerInvariant.next (frame.step es)) |
| (ProducerInvariant.rootValues (frame.step es)).reverse (stageGates indexing machineProgram S frame) |
| (ProducerInvariant.snapshot frame).reversedRecords (encodeWords (ProducerInvariant.rootValues frame)) |
| (ProducerInvariant.compile_transitionTokens indexing machineProgram S frame) |
| have initial := place_forest_initial base S remaining (ProducerInvariant.snapshot frame) |
| (tokens indexing machineProgram S (ProducerInvariant.snapshot frame)) |
| change ForestPlacement.fill forestPorts (tapes base S remaining (ProducerInvariant.snapshot frame)) |
| (ForestStage.initialLocal (ProducerInvariant.next frame) |
| (tokens indexing machineProgram S (ProducerInvariant.snapshot frame)) |
| (ProducerInvariant.snapshot frame).reversedRecords (encodeWords (ProducerInvariant.rootValues frame))) = _ at initial |
| rw [initial] at compiled |
| have final := place_forest_final base S remaining frame es |
| change ForestPlacement.fill forestPorts (tapes base S remaining (ProducerInvariant.snapshot frame)) |
| (ForestStage.finalLocal (ProducerInvariant.next (frame.step es)) |
| (ProducerInvariant.rootValues (frame.step es)).reverse |
| (recordsBits (gateRecords (ProducerInvariant.next frame) (stageGates indexing machineProgram S frame))) |
| (ProducerInvariant.snapshot frame).reversedRecords) = _ at final |
| rw [final] at compiled |
| simpa only [stageSteps, lowerSteps, emitEntry, es, TermMachine.initialState] |
| using chain emitted compiled |
|
|
| theorem repeatTrace (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (base : Tape → List Bool) |
| (S : Nat) (frame : Frame inputs (indexing.width S + 1)) (remaining : Nat) : |
| (advance (TM2.step (program indexing machineProgram)))^[steps indexing machineProgram S frame remaining] |
| (some ⟨some (entry indexing machineProgram), TermMachine.initialState, |
| tapes base S remaining (ProducerInvariant.snapshot frame)⟩) = |
| some ⟨none, TermMachine.initialState, finishTapes base S (ProducerInvariant.snapshot |
| (frame.repeat (ProducerInvariant.stepExpressions indexing machineProgram S) remaining))⟩ := by |
| induction remaining generalizing frame with |
| | zero => exact guardZero indexing machineProgram base S (ProducerInvariant.snapshot frame) |
| | succ remaining ih => |
| have first := chain (guardSucc indexing machineProgram base S remaining (ProducerInvariant.snapshot frame)) |
| (stageTrace indexing machineProgram base S remaining frame) |
| have result := chain first (ih (frame.step (ProducerInvariant.stepExpressions indexing machineProgram S))) |
| simpa only [steps, ProducerInvariant.step_repeat] using result |
|
|
| noncomputable def repeatInTime (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) (base : Tape → List Bool) |
| (S : Nat) (frame : Frame inputs (indexing.width S + 1)) (remaining : Nat) : |
| StateTransition.EvalsToInTime (machine indexing machineProgram).step |
| ⟨some (entry indexing machineProgram), TermMachine.initialState, |
| tapes base S remaining (ProducerInvariant.snapshot frame)⟩ |
| (some ⟨none, TermMachine.initialState, finishTapes base S (ProducerInvariant.snapshot |
| (frame.repeat (ProducerInvariant.stepExpressions indexing machineProgram S) remaining))⟩) |
| (steps indexing machineProgram S frame remaining) where |
| steps := steps indexing machineProgram S frame remaining |
| evals_in_steps := repeatTrace indexing machineProgram base S frame remaining |
| steps_le_m := le_rfl |
|
|
| theorem repeatTraceAt {Caller : Type} (indexing : ConfigIndex.Indexing Γ Λ σ) |
| (machineProgram : Λ → TM2.Stmt Γ Λ σ) |
| (labels : Label indexing machineProgram → Caller) (exit : Option Caller) |
| (target : Caller → TM2.Stmt Alphabet Caller State) |
| (code : ∀ label, target (labels label) = |
| MachineSubroutine.statement labels exit (program indexing machineProgram label)) |
| (base : Tape → List Bool) (S : Nat) |
| (frame : Frame inputs (indexing.width S + 1)) (remaining : Nat) : |
| (advance (TM2.step target))^[steps indexing machineProgram S frame remaining] |
| (some ⟨some (labels (entry indexing machineProgram)), TermMachine.initialState, |
| tapes base S remaining (ProducerInvariant.snapshot frame)⟩) = |
| some ⟨exit, TermMachine.initialState, finishTapes base S (ProducerInvariant.snapshot |
| (frame.repeat (ProducerInvariant.stepExpressions indexing machineProgram S) remaining))⟩ := by |
| simpa only [MachineSubroutine.configuration, MachineSubroutine.label] using |
| MachineSubroutine.trace labels exit (program indexing machineProgram) target code |
| (steps indexing machineProgram S frame remaining) _ _ |
| (repeatTrace indexing machineProgram base S frame remaining) |
|
|
| end BinPackingGames.Foundations.Complexity.CookLevin.TransitionIteration |
|
|
| end |
|
|
| end OAI |
|
|
