| import Mathlib |
| import OAI.Computability.MaxCut.Machines.MachineBinaryParsing |
| import OAI.Computability.MaxCut.Machines.MachineBinaryRenameLoop |
|
|
| namespace OAI |
|
|
| /-! |
| The word-level correspondence used by the ordinary-binary renaming machine. |
| Literal occurrences stay in clause order, and equality is tested on canonical |
| binary payloads. The output body consists of the first occurrence index and |
| the sign of every literal, in the inherited dense formula codec. |
| -/ |
|
|
| namespace MaxCutGames.BinaryRenameWords |
|
|
| open BinaryFormula MaxCutGames.Foundations |
|
|
| def clauseLiterals (c : Clause) : List Literal := [(c)[0], (c)[1], (c)[2]] |
|
|
| def literals (clauses : List Clause) : List Literal := clauses.flatMap clauseLiterals |
|
|
| def token (literal : Literal) : BinaryNameSearch.Token := |
| (literal.positive, literal.name.bits) |
|
|
| def tokens (clauses : List Clause) : List BinaryNameSearch.Token := |
| (literals clauses).map token |
|
|
| @[simp] theorem literals_nil : literals [] = [] := rfl |
|
|
| @[simp] theorem literals_cons (c : Clause) (cs : List Clause) : |
| literals (c :: cs) = (c)[0] :: (c)[1] :: (c)[2] :: literals cs := rfl |
|
|
| @[simp] theorem literals_length (cs : List Clause) : |
| (literals cs).length = 3 * cs.length := by |
| induction cs with |
| | nil => rfl |
| | cons c cs ih => simp only [literals_cons, List.length_cons, ih]; omega |
|
|
| @[simp] theorem tokens_length (cs : List Clause) : |
| (tokens cs).length = 3 * cs.length := by simp [tokens] |
|
|
| theorem literals_names (F : Formula) : |
| (literals F.clauses).map Literal.name = sourceNames F := by |
| simp only [literals, sourceNames, List.map_flatMap] |
| rfl |
|
|
| theorem tokens_payloads (F : Formula) : |
| BinaryNameSearch.payloads (tokens F.clauses) = (sourceNames F).map Nat.bits := by |
| rw [← literals_names] |
| simp only [BinaryNameSearch.payloads, tokens, List.map_map, token, Function.comp_def] |
|
|
| theorem token_bits (literal : Literal) : |
| BinaryNameSearch.tokenBits (token literal) = BinaryEncoding.literalBits literal := by |
| simp only [BinaryNameSearch.tokenBits, token, BinaryEncoding.literalBits, |
| BinaryEncoding.nameBits, BinaryParsing.frame_eq] |
|
|
| / |
| theorem tokens_stream (cs : List Clause) : |
| BinaryNameSearch.stream (tokens cs) = BinaryTokenMachine.tokens cs := by |
| induction cs with |
| | nil => rfl |
| | cons c cs ih => |
| simp only [tokens, literals_cons, List.map_cons, BinaryNameSearch.stream_cons, |
| token_bits, BinaryTokenMachine.tokens_cons, BinaryEncoding.clauseBits] |
| simpa only [tokens, List.append_assoc] using |
| congrArg (fun tail => BinaryEncoding.literalBits (c)[0] ++ |
| BinaryEncoding.literalBits (c)[1] ++ BinaryEncoding.literalBits (c)[2] ++ tail) ih |
|
|
| theorem tokens_canonical (cs : List Clause) : |
| ∀ t ∈ tokens cs, BinaryNameMachine.canonical t.2 = true := by |
| intro t mem |
| obtain ⟨literal, _, rfl⟩ := List.mem_map.mp mem |
| exact BinaryParsing.canonical_nat_bits literal.name |
|
|
| theorem payload_index (F : Formula) (name : Nat) : |
| (BinaryNameSearch.payloads (tokens F.clauses)).idxOf name.bits = |
| (sourceNames F).idxOf name := by |
| rw [tokens_payloads, BinaryOccurrenceRename.idxOf_binary_payloads] |
|
|
| theorem token_payload_mem (cs : List Clause) (literal : Literal) |
| (mem : literal ∈ literals cs) : |
| literal.name.bits ∈ BinaryNameSearch.payloads (tokens cs) := by |
| apply List.mem_map.mpr |
| refine ⟨token literal, ?_, rfl⟩ |
| exact List.mem_map.mpr ⟨literal, mem, rfl⟩ |
|
|
| theorem payloadSize_tokens (cs : List Clause) : |
| BinaryNameSearch.payloadSize (tokens cs) = BinaryEncoding.namesBitSize cs := by |
| induction cs with |
| | nil => rfl |
| | cons c cs ih => |
| simp only [tokens, literals_cons, List.map_cons, |
| BinaryNameSearch.payloadSize_cons, token, Nat.size_eq_bits_len, |
| BinaryEncoding.namesBitSize_cons] at * |
| simpa only [BinaryEncoding.clauseNameSize, BinaryFormula.clauseNames, |
| List.map_cons, List.map_nil, List.sum_cons, List.sum_nil, |
| Nat.add_zero, Nat.add_assoc] using congrArg |
| (fun tail => (c)[0].name.size + ((c)[1].name.size + ((c)[2].name.size + tail))) ih |
|
|
| def outputLiteral (names : List Nat) (literal : Literal) : List Bool := |
| Complexity.encodeWord (names.idxOf literal.name) ++ |
| Complexity.encodeWord (if literal.positive then 1 else 0) |
|
|
| def body (F : Formula) : List Bool := |
| (literals F.clauses).flatMap (outputLiteral (sourceNames F)) |
|
|
| theorem encoded_clause (F : Formula) (c : Clause) (mem : c ∈ F.clauses) : |
| Complexity.encodeWords (Complexity.clauseWords (BinaryOccurrenceRename.clause F c mem)) = |
| (clauseLiterals c).flatMap (outputLiteral (sourceNames F)) := by |
| simp [Complexity.clauseWords, Complexity.literalWords, Complexity.encodeWords, |
| BinaryOccurrenceRename.clause, BinaryOccurrenceRename.literal, |
| BinaryOccurrenceRename.nameIndex, clauseLiterals, outputLiteral, List.append_assoc] |
| rfl |
|
|
| private theorem encodeWords_flatMap_inline_MachineBinaryRenameWords {α : Type} (xs : List α) (f : α → List Nat) : |
| Complexity.encodeWords (xs.flatMap f) = |
| xs.flatMap (fun x => Complexity.encodeWords (f x)) := by |
| induction xs with |
| | nil => rfl |
| | cons x xs ih => simp only [List.flatMap_cons, Complexity.encodeWords_append, ih] |
|
|
| / |
| theorem encoded_body (F : Formula) : |
| Complexity.encodeWords ((BinaryOccurrenceRename.renamed F).clauses.flatMap |
| Complexity.clauseWords) = body F := by |
| rw [encodeWords_flatMap_inline_MachineBinaryRenameWords] |
| change (F.clauses.attach.map (fun c => BinaryOccurrenceRename.clause F c.val c.property)).flatMap |
| (fun c => Complexity.encodeWords (Complexity.clauseWords c)) = body F |
| rw [List.flatMap_map] |
| simp only [encoded_clause] |
| have h := congrArg (fun cs : List Clause => |
| cs.flatMap (fun c => (clauseLiterals c).flatMap (outputLiteral (sourceNames F)))) |
| (List.attach_map_subtype_val F.clauses) |
| simpa only [List.flatMap_map, body, literals, List.flatMap_assoc] using h |
|
|
| / |
| theorem encoded_renamed (F : Formula) : |
| Complexity.formulaBits (BinaryOccurrenceRename.renamed F) = |
| Complexity.encodeWord (3 * F.clauses.length) ++ |
| Complexity.encodeWord F.clauses.length ++ body F := by |
| simp only [Complexity.formulaBits, Complexity.formulaWords, Complexity.encodeWords_append, |
| Complexity.encodeWords, List.append_nil, |
| BinaryOccurrenceRename.renamed_variable_count, |
| BinaryOccurrenceRename.renamed_clause_count, encoded_body, List.append_assoc] |
|
|
| end MaxCutGames.BinaryRenameWords |
|
|
| /-! |
| An actual finite Boolean-stack routine prepending two unary header words to an |
| already restored serialized body. It consumes counters containing `n` and `m` |
| true bits, respectively, in exactly `n + m + 4` transitions. All ambient stacks |
| and the finite ambient state are preserved. The input counters need no separate |
| counting pass: a caller can accumulate them while constructing the body. |
|
|
| The generic placement theorem uses only four displayed instruction equations. |
| The concrete machine below has three Boolean stacks and four control labels; |
| its final transfer halts directly. This is a staged configuration computation, |
| not a single-input `initList` assertion that silently assumes two extra inputs. |
| -/ |
|
|
| namespace MaxCutGames.BinaryHeaderMachine |
|
|
| open Turing |
| open MaxCutGames.Foundations.Complexity |
| open MachineComposition |
| open MaxCutGames.Reduction.MachineTransfer |
|
|
| abbrev Alphabet {K : Type} (_ : K) := Bool |
| abbrev State (A : Type) := A × Option Bool |
|
|
| section Placement |
|
|
| variable {K Λ A : Type} [DecidableEq K] |
|
|
| / |
| def delimiter (destination : K) (next : Λ) : TM2.Stmt (Alphabet (K := K)) Λ (State A) := |
| .push destination (fun _ => false) |
| (.load (fun state => (state.1, none)) (.goto fun _ => next)) |
|
|
| def tapes (variableTape clauses destination : K) (base : K → List Bool) |
| (variableCounter clauseCounter output : List Bool) : K → List Bool := |
| Function.update (Function.update (Function.update base variableTape variableCounter) |
| clauses clauseCounter) destination output |
|
|
| @[simp] theorem tapes_variables (variableTape clauses destination : K) |
| (vc : variableTape ≠ clauses) (vd : variableTape ≠ destination) (base : K → List Bool) |
| (variableCounter clauseCounter output : List Bool) : |
| tapes variableTape clauses destination base variableCounter clauseCounter output variableTape = |
| variableCounter := by |
| simp [tapes, vc, vd] |
|
|
| @[simp] theorem tapes_clauses (variableTape clauses destination : K) |
| (cd : clauses ≠ destination) (base : K → List Bool) |
| (variableCounter clauseCounter output : List Bool) : |
| tapes variableTape clauses destination base variableCounter clauseCounter output clauses = |
| clauseCounter := by |
| simp [tapes, cd] |
|
|
| @[simp] theorem tapes_destination (variableTape clauses destination : K) (base : K → List Bool) |
| (variableCounter clauseCounter output : List Bool) : |
| tapes variableTape clauses destination base variableCounter clauseCounter output destination = |
| output := by |
| simp [tapes] |
|
|
| theorem tapes_other (variableTape clauses destination k : K) |
| (kv : k ≠ variableTape) (kc : k ≠ clauses) (kd : k ≠ destination) |
| (base : K → List Bool) (variableCounter clauseCounter output : List Bool) : |
| tapes variableTape clauses destination base variableCounter clauseCounter output k = base k := by |
| simp [tapes, kv, kc, kd] |
|
|
| private theorem update_variables_inline_MachineBinaryHeaderMachine (variableTape clauses destination : K) |
| (vc : variableTape ≠ clauses) (vd : variableTape ≠ destination) (base : K → List Bool) |
| (variableCounter clauseCounter output replacement : List Bool) : |
| Function.update (tapes variableTape clauses destination base variableCounter clauseCounter output) |
| variableTape replacement = tapes variableTape clauses destination base replacement clauseCounter output := by |
| funext k |
| by_cases hv : k = variableTape |
| · subst k |
| simp [tapes, vc, vd] |
| · by_cases hd : k = destination |
| · subst k |
| simp [tapes, hv] |
| · by_cases hc : k = clauses |
| · subst k |
| simp [tapes, hv, hd] |
| · simp [tapes, hv, hc, hd] |
|
|
| private theorem update_clauses_inline_MachineBinaryHeaderMachine (variableTape clauses destination : K) |
| (cd : clauses ≠ destination) (base : K → List Bool) |
| (variableCounter clauseCounter output replacement : List Bool) : |
| Function.update (tapes variableTape clauses destination base variableCounter clauseCounter output) |
| clauses replacement = tapes variableTape clauses destination base variableCounter replacement output := by |
| funext k |
| by_cases hc : k = clauses |
| · subst k |
| simp [tapes, cd] |
| · by_cases hd : k = destination |
| · subst k |
| simp [tapes, hc] |
| · simp [tapes, hc, hd] |
|
|
| private theorem update_destination_inline_MachineBinaryHeaderMachine (variableTape clauses destination : K) (base : K → List Bool) |
| (variableCounter clauseCounter output replacement : List Bool) : |
| Function.update (tapes variableTape clauses destination base variableCounter clauseCounter output) |
| destination replacement = tapes variableTape clauses destination base variableCounter clauseCounter replacement := by |
| simp [tapes] |
|
|
| variable (variableTape clauses destination : K) |
| variable (vc : variableTape ≠ clauses) (vd : variableTape ≠ destination) (cd : clauses ≠ destination) |
| variable (clauseStart clauseLoop variableStart variableLoop : Λ) (exit : Option Λ) |
| variable (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) |
| variable (atClauseStart : program clauseStart = delimiter destination clauseLoop) |
| variable (atClauseLoop : program clauseLoop = |
| loopAt clauses destination id false clauseLoop (some variableStart)) |
| variable (atVariableStart : program variableStart = delimiter destination variableLoop) |
| variable (atVariableLoop : program variableLoop = |
| loopAt variableTape destination id false variableLoop exit) |
| variable (base : K → List Bool) (ambient : A) |
|
|
| include atClauseStart in |
| theorem clauseDelimiterStep (variableCounter clauseCounter output : List Bool) |
| (register : Option Bool) : |
| TM2.step program |
| ⟨some clauseStart, (ambient, register), |
| tapes variableTape clauses destination base variableCounter clauseCounter output⟩ = |
| some ⟨some clauseLoop, (ambient, none), |
| tapes variableTape clauses destination base variableCounter clauseCounter (false :: output)⟩ := by |
| change some (TM2.stepAux (program clauseStart) _ _) = _ |
| rw [atClauseStart] |
| simp [delimiter, TM2.stepAux, update_destination_inline_MachineBinaryHeaderMachine] |
|
|
| include atVariableStart in |
| theorem variableDelimiterStep (variableCounter clauseCounter output : List Bool) |
| (register : Option Bool) : |
| TM2.step program |
| ⟨some variableStart, (ambient, register), |
| tapes variableTape clauses destination base variableCounter clauseCounter output⟩ = |
| some ⟨some variableLoop, (ambient, none), |
| tapes variableTape clauses destination base variableCounter clauseCounter (false :: output)⟩ := by |
| change some (TM2.stepAux (program variableStart) _ _) = _ |
| rw [atVariableStart] |
| simp [delimiter, TM2.stepAux, update_destination_inline_MachineBinaryHeaderMachine] |
|
|
| include cd atClauseLoop in |
| theorem clauseCounterTrace (m : Nat) (variableCounter output : List Bool) |
| (register : Option Bool) : |
| (advance (TM2.step program))^[m + 1] |
| (some ⟨some clauseLoop, (ambient, register), |
| tapes variableTape clauses destination base variableCounter (List.replicate m true) output⟩) = |
| some ⟨some variableStart, (ambient, none), |
| tapes variableTape clauses destination base variableCounter [] (List.replicate m true ++ output)⟩ := by |
| have h := transferAt_fromTapes (Γ := Alphabet) clauses destination cd id false |
| clauseLoop (some variableStart) program atClauseLoop |
| (tapes variableTape clauses destination base variableCounter (List.replicate m true) output) |
| ambient register |
| change (nextAt destination program)^[m + 1] |
| (some ⟨some clauseLoop, (ambient, register), |
| tapes variableTape clauses destination base variableCounter (List.replicate m true) output⟩) = _ |
| simpa only [tapes_clauses variableTape clauses destination cd, tapes_destination, |
| List.length_replicate, List.reverse_replicate, List.map_id_fun, id_eq, |
| tapesAt, update_clauses_inline_MachineBinaryHeaderMachine variableTape clauses destination cd, update_destination_inline_MachineBinaryHeaderMachine, |
| nextAt, advance] using h |
|
|
| include vc vd atVariableLoop in |
| theorem variableCounterTrace (n : Nat) (clauseCounter output : List Bool) |
| (register : Option Bool) : |
| (advance (TM2.step program))^[n + 1] |
| (some ⟨some variableLoop, (ambient, register), |
| tapes variableTape clauses destination base (List.replicate n true) clauseCounter output⟩) = |
| some ⟨exit, (ambient, none), |
| tapes variableTape clauses destination base [] clauseCounter (List.replicate n true ++ output)⟩ := by |
| have h := transferAt_fromTapes (Γ := Alphabet) variableTape destination vd id false |
| variableLoop exit program atVariableLoop |
| (tapes variableTape clauses destination base (List.replicate n true) clauseCounter output) |
| ambient register |
| change (nextAt destination program)^[n + 1] |
| (some ⟨some variableLoop, (ambient, register), |
| tapes variableTape clauses destination base (List.replicate n true) clauseCounter output⟩) = _ |
| simpa only [tapes_variables variableTape clauses destination vc vd, tapes_destination, |
| List.length_replicate, List.reverse_replicate, List.map_id_fun, id_eq, |
| tapesAt, update_variables_inline_MachineBinaryHeaderMachine variableTape clauses destination vc vd, update_destination_inline_MachineBinaryHeaderMachine, |
| nextAt, advance] using h |
|
|
| private theorem joinTrace_inline_MachineBinaryHeaderMachine {X : Type*} {f : X → X} {a b c : X} {n m : Nat} |
| (first : f^[n] a = b) (second : f^[m] b = c) : f^[n + m] a = c := by |
| rw [Nat.add_comm, Function.iterate_add_apply, first, second] |
|
|
| include vc vd cd atClauseStart atClauseLoop atVariableStart atVariableLoop |
|
|
| / |
| theorem headerTrace (n m : Nat) (body : List Bool) (register : Option Bool) : |
| (advance (TM2.step program))^[n + m + 4] |
| (some ⟨some clauseStart, (ambient, register), |
| tapes variableTape clauses destination base |
| (List.replicate n true) (List.replicate m true) body⟩) = |
| some ⟨exit, (ambient, none), |
| tapes variableTape clauses destination base [] [] (encodeWord n ++ encodeWord m ++ body)⟩ := by |
| have first := clauseDelimiterStep variableTape clauses destination clauseStart clauseLoop program |
| atClauseStart base ambient (List.replicate n true) (List.replicate m true) body register |
| change (advance (TM2.step program))^[1] |
| (some ⟨some clauseStart, (ambient, register), |
| tapes variableTape clauses destination base (List.replicate n true) (List.replicate m true) body⟩) = _ at first |
| have second := clauseCounterTrace variableTape clauses destination cd clauseLoop variableStart program |
| atClauseLoop base ambient m (List.replicate n true) (false :: body) none |
| have third := variableDelimiterStep variableTape clauses destination variableStart variableLoop program |
| atVariableStart base ambient (List.replicate n true) [] |
| (List.replicate m true ++ false :: body) none |
| change (advance (TM2.step program))^[1] |
| (some ⟨some variableStart, (ambient, none), |
| tapes variableTape clauses destination base (List.replicate n true) [] |
| (List.replicate m true ++ false :: body)⟩) = _ at third |
| have fourth := variableCounterTrace variableTape clauses destination vc vd variableLoop exit program |
| atVariableLoop base ambient n [] (false :: (List.replicate m true ++ false :: body)) none |
| have full := joinTrace_inline_MachineBinaryHeaderMachine (joinTrace_inline_MachineBinaryHeaderMachine (joinTrace_inline_MachineBinaryHeaderMachine first second) third) fourth |
| have htime : ((1 + (m + 1)) + 1) + (n + 1) = n + m + 4 := by omega |
| rw [htime] at full |
| simpa only [encodeWord, List.append_assoc, List.singleton_append, |
| List.cons_append, List.nil_append] using full |
|
|
| def headerInTime (n m : Nat) (body : List Bool) (register : Option Bool) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some clauseStart, (ambient, register), |
| tapes variableTape clauses destination base (List.replicate n true) (List.replicate m true) body⟩ |
| (some ⟨exit, (ambient, none), |
| tapes variableTape clauses destination base [] [] (encodeWord n ++ encodeWord m ++ body)⟩) |
| (n + m + 4) where |
| steps := n + m + 4 |
| evals_in_steps := headerTrace variableTape clauses destination vc vd cd |
| clauseStart clauseLoop variableStart variableLoop exit program |
| atClauseStart atClauseLoop atVariableStart atVariableLoop base ambient n m body register |
| steps_le_m := Nat.le_refl _ |
|
|
| end Placement |
|
|
| abbrev ConcreteTape := Fin 3 |
| abbrev ConcreteLabel := Fin 4 |
|
|
| def concreteProgram (label : ConcreteLabel) : |
| TM2.Stmt (Alphabet (K := ConcreteTape)) ConcreteLabel (State Unit) := |
| if label = 0 then delimiter 2 1 |
| else if label = 1 then loopAt 1 2 id false 1 (some 2) |
| else if label = 2 then delimiter 2 3 |
| else loopAt 0 2 id false 3 none |
|
|
| abbrev machine : FinTM2 where |
| K := ConcreteTape |
| k₀ := 0 |
| k₁ := 2 |
| Γ := Alphabet |
| Λ := ConcreteLabel |
| main := 0 |
| σ := State Unit |
| initialState := ((), none) |
| m := concreteProgram |
|
|
| / |
| def start (n m : Nat) (body : List Bool) : machine.Cfg := |
| ⟨some 0, ((), none), |
| tapes 0 1 2 (fun _ : ConcreteTape => []) (List.replicate n true) (List.replicate m true) body⟩ |
|
|
| theorem haltList_eq (body : List Bool) : |
| haltList machine body = |
| ⟨none, ((), none), tapes 0 1 2 (fun _ : ConcreteTape => []) [] [] body⟩ := by |
| unfold haltList |
| congr 1 |
| funext k |
| fin_cases k <;> simp [machine, tapes] |
|
|
| / |
| def machineInTime (n m : Nat) (body : List Bool) : |
| StateTransition.EvalsToInTime machine.step (start n m body) |
| (some (haltList machine (encodeWord n ++ encodeWord m ++ body))) (n + m + 4) := by |
| rw [haltList_eq] |
| exact headerInTime (0 : ConcreteTape) 1 2 (by decide) (by decide) (by decide) |
| (0 : ConcreteLabel) 1 2 3 none concreteProgram |
| (by simp [concreteProgram]) (by simp [concreteProgram]) |
| (by simp [concreteProgram]) (by simp [concreteProgram]) |
| (fun _ => []) () n m body none |
|
|
| theorem machine_finiteAlphabet (k : machine.K) : Finite (machine.Γ k) := by |
| change Finite Bool |
| infer_instance |
|
|
| end MaxCutGames.BinaryHeaderMachine |
|
|
| /-! |
| The finite Boolean-stack driver for first-occurrence renaming. Its permanent |
| input is copied to a cursor, each literal is translated by the checked search |
| loop, and the physical output is restored, prefixed with its count headers, |
| and cleaned up. Every tape uses Bool and every control component is finite. |
| -/ |
|
|
| namespace MaxCutGames.BinaryRenameMachine |
|
|
| open Turing MaxCutGames.Foundations |
| open Complexity Complexity.MachineComposition |
| open MaxCutGames.Reduction.MachineTransfer |
|
|
| abbrev Tape := Fin 12 |
| abbrev Alphabet (_ : Tape) := Bool |
| abbrev State := BinaryRenameLoop.State Unit |
|
|
| inductive Label |
| | copyOut | copyBack |
| | loop (label : BinaryRenameLoop.Label) |
| | restore | clauseStart | clauseLoop | variableStart | variableLoop |
| | cleanup | reject |
| deriving DecidableEq, Fintype |
|
|
| def loopTapes : Fin 11 → Tape := Fin.castSucc |
|
|
| theorem loopTapes_injective : Function.Injective loopTapes := by |
| intro i j h |
| apply Fin.ext |
| exact congrArg (fun k : Tape => k.val) h |
|
|
| def program : Label → TM2.Stmt Alphabet Label State |
| | .copyOut => loopAt 1 6 id false .copyOut (some .copyBack) |
| | .copyBack => MachineCopy.forkLoop 6 1 0 false .copyBack (some (.loop .entry)) |
| | .loop label => BinaryRenameLoop.instruction loopTapes Label.loop |
| (some .restore) (some .reject) label |
| | .restore => loopAt 8 11 id false .restore (some .clauseStart) |
| | .clauseStart => BinaryHeaderMachine.delimiter 11 .clauseLoop |
| | .clauseLoop => loopAt 10 11 id false .clauseLoop (some .variableStart) |
| | .variableStart => BinaryHeaderMachine.delimiter 11 .variableLoop |
| | .variableLoop => loopAt 9 11 id false .variableLoop (some .cleanup) |
| | .cleanup => MachineDrain.drain 1 .cleanup none |
| | .reject => .halt |
|
|
| abbrev machine : FinTM2 where |
| K := Tape |
| k₀ := 1 |
| k₁ := 11 |
| Γ := Alphabet |
| Λ := Label |
| main := .copyOut |
| σ := State |
| initialState := BinaryRenameLoop.clean () 0 |
| m := program |
|
|
| def tapes (permanent cursor reversed variableCounter clauseCounter output : List Bool) : |
| Tape → List Bool := fun k => |
| if k = 0 then cursor |
| else if k = 1 then permanent |
| else if k = 8 then reversed |
| else if k = 9 then variableCounter |
| else if k = 10 then clauseCounter |
| else if k = 11 then output |
| else [] |
|
|
| def cfg (label : Option Label) |
| (permanent cursor reversed variableCounter clauseCounter output : List Bool) : machine.Cfg := |
| ⟨label, BinaryRenameLoop.clean () 0, |
| tapes permanent cursor reversed variableCounter clauseCounter output⟩ |
|
|
| theorem initList_eq (input : List Bool) : |
| initList machine input = cfg (some .copyOut) input [] [] [] [] [] := by |
| unfold initList cfg |
| congr 1 |
| funext k |
| fin_cases k <;> simp [tapes, machine] |
|
|
| theorem haltList_eq (output : List Bool) : |
| haltList machine output = cfg none [] [] [] [] [] output := by |
| unfold haltList cfg |
| congr 1 |
| funext k |
| fin_cases k <;> simp [tapes, machine] |
|
|
| theorem copyTrace (input : List Bool) : |
| (advance machine.step)^[2 * (input.length + 1)] |
| (some (cfg (some .copyOut) input [] [] [] [] [])) = |
| some (cfg (some (.loop .entry)) input input [] [] [] []) := by |
| have updated : Function.update (tapes input [] [] [] [] []) 0 input = |
| tapes input input [] [] [] [] := by |
| funext k |
| fin_cases k <;> simp [tapes] |
| have h := MachineCopy.copyTrace (1 : Tape) 0 6 (by decide) (by decide) (by decide) |
| false .copyOut .copyBack (some (.loop .entry)) program rfl rfl |
| (tapes input [] [] [] [] []) (by simp [tapes]) |
| (BinaryRenameLoop.clean () 0).1 none |
| have first : tapes input [] [] [] [] [] 1 = input := rfl |
| have second : tapes input [] [] [] [] [] 0 = [] := rfl |
| rw [first, second, List.append_nil, updated] at h |
| exact h |
|
|
| theorem restoreTrace (input body variableCounter clauseCounter : List Bool) : |
| (advance machine.step)^[body.length + 1] |
| (some (cfg (some .restore) input [] body.reverse variableCounter clauseCounter [])) = |
| some (cfg (some .clauseStart) input [] [] variableCounter clauseCounter body) := by |
| change (nextAt (11 : Tape) program)^[body.length + 1] |
| (some (cfg (some .restore) input [] body.reverse variableCounter clauseCounter [])) = _ |
| have updated : tapesAt (8 : Tape) 11 |
| (tapes input [] body.reverse variableCounter clauseCounter []) [] body = |
| tapes input [] [] variableCounter clauseCounter body := by |
| funext k |
| fin_cases k <;> simp [tapesAt, tapes] |
| have h := transferAt_fromTapes (Γ := Alphabet) (8 : Tape) 11 (by decide) id false |
| .restore (some .clauseStart) program rfl |
| (tapes input [] body.reverse variableCounter clauseCounter []) |
| (BinaryRenameLoop.clean () 0).1 none |
| have source : tapes input [] body.reverse variableCounter clauseCounter [] 8 = body.reverse := rfl |
| have output : tapes input [] body.reverse variableCounter clauseCounter [] 11 = [] := rfl |
| rw [source, output, List.length_reverse, List.reverse_reverse, List.map_id_fun, |
| List.append_nil, id_eq, updated] at h |
| exact h |
|
|
| theorem headerTrace (input body : List Bool) (n m : Nat) : |
| (advance machine.step)^[n + m + 4] |
| (some (cfg (some .clauseStart) input [] [] |
| (List.replicate n true) (List.replicate m true) body)) = |
| some (cfg (some .cleanup) input [] [] [] [] |
| (encodeWord n ++ encodeWord m ++ body)) := by |
| change (advance (TM2.step program))^[n + m + 4] |
| (some ⟨some .clauseStart, ((BinaryRenameLoop.clean () 0).1, none), |
| tapes input [] [] (List.replicate n true) (List.replicate m true) body⟩) = |
| some ⟨some .cleanup, ((BinaryRenameLoop.clean () 0).1, none), |
| tapes input [] [] [] [] (encodeWord n ++ encodeWord m ++ body)⟩ |
| have updated (variableWord clauses output : List Bool) : |
| BinaryHeaderMachine.tapes (9 : Tape) 10 11 (tapes input [] [] [] [] []) |
| variableWord clauses output = tapes input [] [] variableWord clauses output := by |
| funext k |
| fin_cases k <;> simp [BinaryHeaderMachine.tapes, tapes] |
| have h := BinaryHeaderMachine.headerTrace (9 : Tape) 10 11 |
| (by decide) (by decide) (by decide) |
| .clauseStart .clauseLoop .variableStart .variableLoop (some .cleanup) program |
| rfl rfl rfl rfl (tapes input [] [] [] [] []) |
| (BinaryRenameLoop.clean () 0).1 n m body none |
| simp only [updated] at h |
| exact h |
|
|
| theorem cleanupTrace (input output : List Bool) : |
| (advance machine.step)^[input.length + 1] |
| (some (cfg (some .cleanup) input [] [] [] [] output)) = |
| some (cfg none [] [] [] [] [] output) := by |
| change (advance (TM2.step program))^[input.length + 1] |
| (some ⟨some .cleanup, ((BinaryRenameLoop.clean () 0).1, none), |
| tapes input [] [] [] [] output⟩) = |
| some ⟨none, ((BinaryRenameLoop.clean () 0).1, none), tapes [] [] [] [] [] output⟩ |
| have updated (word : List Bool) : |
| Function.update (tapes [] [] [] [] [] output) 1 word = |
| tapes word [] [] [] [] output := by |
| funext k |
| fin_cases k <;> simp [tapes] |
| have h := MachineDrain.drainTrace (1 : Tape) .cleanup none program rfl |
| (tapes [] [] [] [] [] output) input (BinaryRenameLoop.clean () 0).1 none |
| simp only [updated] at h |
| exact h |
|
|
| theorem outputBody_eq (formula : BinaryFormula.Formula) : |
| BinaryRenameLoop.outputBody (BinaryRenameWords.tokens formula.clauses) |
| (BinaryRenameWords.tokens formula.clauses) = BinaryRenameWords.body formula := by |
| change ((BinaryRenameWords.literals formula.clauses).map BinaryRenameWords.token).flatMap |
| (fun t => BinaryLiteralMachine.outputWord (BinaryRenameWords.tokens formula.clauses) |
| t.2 t.1) = (BinaryRenameWords.literals formula.clauses).flatMap |
| (BinaryRenameWords.outputLiteral (BinaryFormula.sourceNames formula)) |
| rw [List.flatMap_map] |
| apply List.flatMap_congr |
| intro literal _ |
| simp only [BinaryRenameWords.token, BinaryLiteralMachine.outputWord, |
| BinaryLiteralMachine.index, BinaryLiteralMachine.signWord, |
| BinaryRenameWords.payload_index, BinaryRenameWords.outputLiteral] |
| rfl |
|
|
| theorem loopTrace (formula : BinaryFormula.Formula) : |
| (advance machine.step)^[BinaryRenameLoop.steps (BinaryRenameWords.tokens formula.clauses) |
| (BinaryRenameWords.tokens formula.clauses)] |
| (some (cfg (some (.loop .entry)) (BinaryTokenMachine.tokens formula.clauses) |
| (BinaryTokenMachine.tokens formula.clauses) [] [] [] [])) = |
| some (cfg (some .restore) (BinaryTokenMachine.tokens formula.clauses) [] |
| (BinaryRenameWords.body formula).reverse (List.replicate (3 * formula.clauses.length) true) |
| (List.replicate formula.clauses.length true) []) := by |
| change (advance (TM2.step program))^[BinaryRenameLoop.steps |
| (BinaryRenameWords.tokens formula.clauses) (BinaryRenameWords.tokens formula.clauses)] |
| (some ⟨some (.loop .entry), BinaryRenameLoop.clean () 0, |
| tapes (BinaryTokenMachine.tokens formula.clauses) (BinaryTokenMachine.tokens formula.clauses) |
| [] [] [] []⟩) = |
| some ⟨some .restore, BinaryRenameLoop.clean () 0, |
| tapes (BinaryTokenMachine.tokens formula.clauses) [] (BinaryRenameWords.body formula).reverse |
| (List.replicate (3 * formula.clauses.length) true) |
| (List.replicate formula.clauses.length true) []⟩ |
| let input := BinaryTokenMachine.tokens formula.clauses |
| have updated (cursor output variableWord clauseWord : List Bool) : |
| BinaryRenameLoop.loopTapes loopTapes (tapes input [] [] [] [] []) |
| cursor output variableWord clauseWord = |
| tapes input cursor output variableWord clauseWord [] := by |
| funext k |
| fin_cases k <;> simp [BinaryRenameLoop.loopTapes, loopTapes, tapes] |
| have scratch (i : Fin 11) (lo : 2 ≤ i.val) (hi : i.val ≤ 7) : |
| tapes input [] [] [] [] [] (loopTapes i) = [] := by |
| have n0 : loopTapes i ≠ 0 := by intro h; have := congrArg Fin.val h; simp [loopTapes] at this; omega |
| have n1 : loopTapes i ≠ 1 := by intro h; have := congrArg Fin.val h; simp [loopTapes] at this; omega |
| have n8 : loopTapes i ≠ 8 := by intro h; have := congrArg Fin.val h; simp [loopTapes] at this; omega |
| have n9 : loopTapes i ≠ 9 := by intro h; have := congrArg Fin.val h; simp [loopTapes] at this; omega |
| have n10 : loopTapes i ≠ 10 := by intro h; have := congrArg Fin.val h; simp [loopTapes] at this; omega |
| have n11 : loopTapes i ≠ 11 := by intro h; have := congrArg Fin.val h; simp [loopTapes] at this; omega |
| simp [tapes, n0, n1, n8, n9, n10, n11] |
| have run := BinaryRenameLoop.triplesTrace loopTapes loopTapes_injective Label.loop |
| (some .restore) (some .reject) program (fun _ => rfl) |
| (tapes input [] [] [] [] []) () |
| (BinaryRenameWords.tokens formula.clauses) (BinaryRenameWords.tokens formula.clauses) |
| formula.clauses.length (BinaryRenameWords.tokens_length formula.clauses) [] [] [] |
| (BinaryRenameWords.tokens_canonical formula.clauses) (fun _ h => h) |
| (by change input = _; rw [BinaryRenameWords.tokens_stream]) scratch |
| simp only [updated, BinaryRenameWords.tokens_stream, outputBody_eq, List.append_nil, input] at run |
| exact run |
|
|
| private theorem joinTrace_inline_MachineBinaryRenameMachine {X : Type*} {f : X → X} {a b c : X} {n m : Nat} |
| (first : f^[n] a = b) (second : f^[m] b = c) : f^[n + m] a = c := by |
| rw [Nat.add_comm, Function.iterate_add_apply, first, second] |
|
|
| def steps (formula : BinaryFormula.Formula) : Nat := |
| 2 * ((BinaryTokenMachine.tokens formula.clauses).length + 1) + |
| BinaryRenameLoop.steps (BinaryRenameWords.tokens formula.clauses) |
| (BinaryRenameWords.tokens formula.clauses) + |
| ((BinaryRenameWords.body formula).length + 1) + (4 * formula.clauses.length + 4) + |
| ((BinaryTokenMachine.tokens formula.clauses).length + 1) |
|
|
| theorem renameTrace (formula : BinaryFormula.Formula) : |
| (advance machine.step)^[steps formula] |
| (some (initList machine (BinaryTokenMachine.tokens formula.clauses))) = |
| some (haltList machine (formulaBits (BinaryOccurrenceRename.renamed formula))) := by |
| have first := copyTrace (BinaryTokenMachine.tokens formula.clauses) |
| have second := loopTrace formula |
| have third := restoreTrace (BinaryTokenMachine.tokens formula.clauses) |
| (BinaryRenameWords.body formula) (List.replicate (3 * formula.clauses.length) true) |
| (List.replicate formula.clauses.length true) |
| have fourth := headerTrace (BinaryTokenMachine.tokens formula.clauses) |
| (BinaryRenameWords.body formula) (3 * formula.clauses.length) formula.clauses.length |
| have fifth := cleanupTrace (BinaryTokenMachine.tokens formula.clauses) |
| (encodeWord (3 * formula.clauses.length) ++ encodeWord formula.clauses.length ++ |
| BinaryRenameWords.body formula) |
| have full := joinTrace_inline_MachineBinaryRenameMachine (joinTrace_inline_MachineBinaryRenameMachine (joinTrace_inline_MachineBinaryRenameMachine (joinTrace_inline_MachineBinaryRenameMachine first second) third) fourth) fifth |
| have count : 3 * formula.clauses.length + formula.clauses.length + 4 = |
| 4 * formula.clauses.length + 4 := by omega |
| simpa only [steps, initList_eq, haltList_eq, BinaryRenameWords.encoded_renamed, count] using full |
|
|
| theorem clause_count_le_stream (formula : BinaryFormula.Formula) : |
| formula.clauses.length ≤ (BinaryTokenMachine.tokens formula.clauses).length := by |
| rw [BinaryTokenMachine.tokens_length] |
| omega |
|
|
| theorem body_length_le (formula : BinaryFormula.Formula) : |
| (BinaryRenameWords.body formula).length ≤ |
| 9 * (BinaryTokenMachine.tokens formula.clauses).length ^ 2 + |
| 10 * (BinaryTokenMachine.tokens formula.clauses).length + 2 := by |
| have initial := BinaryOccurrenceRename.renamed_encoding_bound formula |
| rw [BinaryRenameWords.encoded_renamed] at initial |
| simp only [List.length_append] at initial |
| have count := clause_count_le_stream formula |
| have square := Nat.mul_self_le_mul_self count |
| nlinarith |
|
|
| noncomputable def timePolynomial : Polynomial Nat := |
| Polynomial.C 12 * Polynomial.X ^ 3 + Polynomial.C 35 * Polynomial.X ^ 2 + |
| Polynomial.C 28 * Polynomial.X + Polynomial.C 11 |
|
|
| theorem steps_le (formula : BinaryFormula.Formula) : |
| steps formula ≤ timePolynomial.eval (BinaryTokenMachine.tokens formula.clauses).length := by |
| have loopBound := BinaryRenameLoop.steps_le |
| (BinaryRenameWords.tokens formula.clauses) (BinaryRenameWords.tokens formula.clauses) |
| (fun _ h => h) |
| rw [BinaryRenameWords.tokens_stream, BinaryRenameWords.tokens_length] at loopBound |
| have literalCount : 3 * formula.clauses.length ≤ |
| (BinaryTokenMachine.tokens formula.clauses).length := by |
| rw [BinaryTokenMachine.tokens_length] |
| omega |
| have product := Nat.mul_le_mul_left |
| (BinaryRenameLoop.perLiteralBound (BinaryTokenMachine.tokens formula.clauses).length) |
| literalCount |
| have output := body_length_le formula |
| have count := clause_count_le_stream formula |
| simp only [timePolynomial, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_pow, |
| Polynomial.eval_C, Polynomial.eval_X] |
| unfold steps BinaryRenameLoop.perLiteralBound at * |
| nlinarith |
|
|
| def outputsInTime (formula : BinaryFormula.Formula) : |
| TM2OutputsInTime machine (BinaryTokenMachine.tokens formula.clauses) |
| (some (formulaBits (BinaryOccurrenceRename.renamed formula))) |
| (timePolynomial.eval (BinaryTokenMachine.tokens formula.clauses).length) where |
| steps := steps formula |
| evals_in_steps := renameTrace formula |
| steps_le_m := steps_le formula |
|
|
| / |
| bound; its polynomial argument is the token stream's physical bit length. -/ |
| noncomputable def tokenComputation : |
| TM2ComputableInPolyTime (fun formula : BinaryFormula.Formula => |
| BinaryTokenMachine.tokens formula.clauses) formulaBits BinaryOccurrenceRename.renamed where |
| tm := machine |
| inputAlphabet := Equiv.refl Bool |
| outputAlphabet := Equiv.refl Bool |
| time := timePolynomial |
| outputsFun formula := by |
| change TM2OutputsInTime machine ((BinaryTokenMachine.tokens formula.clauses).map id) |
| (some ((formulaBits (BinaryOccurrenceRename.renamed formula)).map id)) |
| (timePolynomial.eval (BinaryTokenMachine.tokens formula.clauses).length) |
| simpa only [List.map_id_fun, id_eq] using outputsInTime formula |
|
|
| / |
| or word: the intermediate semantic value is the same formula. -/ |
| noncomputable def preprocessing : |
| TM2ComputableInPolyTime BinaryEncoding.formulaBits |
| (fun formula : BinaryFormula.Formula => BinaryTokenMachine.tokens formula.clauses) |
| (id : BinaryFormula.Formula → BinaryFormula.Formula) where |
| tm := BinaryTokenMachine.computableInPolyTime.tm |
| inputAlphabet := BinaryTokenMachine.computableInPolyTime.inputAlphabet |
| outputAlphabet := BinaryTokenMachine.computableInPolyTime.outputAlphabet |
| time := BinaryTokenMachine.computableInPolyTime.time |
| outputsFun := BinaryTokenMachine.computableInPolyTime.outputsFun |
|
|
| / |
| renaming. Sparse name magnitudes are never expanded in unary. -/ |
| noncomputable def computableInPolyTime : |
| TM2ComputableInPolyTime BinaryEncoding.formulaBits formulaBits |
| BinaryOccurrenceRename.renamed := |
| MachineSequential.composeBits preprocessing tokenComputation |
|
|
| theorem machine_finiteAlphabet (k : machine.K) : Finite (machine.Γ k) := by |
| change Finite Bool |
| infer_instance |
|
|
| theorem computation_finiteAlphabet : MachineFiniteAlphabet.FiniteAlphabet computableInPolyTime.tm := |
| MachineFiniteAlphabet.composeBits preprocessing tokenComputation |
| BinaryTokenMachine.machine_finiteAlphabet machine_finiteAlphabet |
|
|
| end MaxCutGames.BinaryRenameMachine |
|
|
| end OAI |
|
|
