| import Mathlib.Data.List.FinRange |
| import Mathlib.Data.List.OfFn |
| import Mathlib.Tactic.DeriveFintype |
| import OAI.Computability.BinPacking.Computation.MachineFiniteTable |
| import OAI.Computability.BinPacking.Computation.MachineInitialHeaders |
| import OAI.Computability.BinPacking.Computation.PoweringMasterState |
|
|
| namespace OAI |
|
|
| namespace BinPackingGames.Foundations.PCP.RawInitialRows |
|
|
| open Target GraphTables RawInitialTables |
|
|
| def orderedList {α : Type*} {n : Nat} (e : α ≃ Fin n) : List α := |
| List.ofFn e.symm |
|
|
| theorem orderedList_cast {α : Type*} {m n : Nat} (e : α ≃ Fin m) (h : m = n) : |
| orderedList (e.trans (finCongr h)) = orderedList e := by |
| subst n |
| rfl |
|
|
| theorem orderedList_prod {α β : Type*} {m n : Nat} |
| (e : α ≃ Fin m) (f : β ≃ Fin n) : |
| orderedList ((e.prodCongr f).trans finProdFinEquiv) = |
| (orderedList e).flatMap (fun a => (orderedList f).map (fun b => (a, b))) := by |
| change List.ofFn (fun q : Fin (m * n) => |
| (e.symm (finProdFinEquiv.symm q).1, f.symm (finProdFinEquiv.symm q).2)) = _ |
| rw [List.ofFn_mul] |
| simp only [orderedList, List.flatMap_def, List.map_ofFn] |
| apply congrArg List.flatten |
| apply congrArg List.ofFn |
| funext i |
| apply congrArg List.ofFn |
| funext j |
| have h : (⟨i.val * n + j.val, by |
| calc |
| i.val * n + j.val < (i.val + 1) * n := |
| (Nat.add_lt_add_left j.isLt _).trans_eq (by rw [Nat.add_mul, Nat.one_mul]) |
| _ ≤ m * n := Nat.mul_le_mul_right _ i.isLt⟩ : Fin (m * n)) = |
| finProdFinEquiv (i, j) := by |
| apply Fin.ext |
| simp [finProdFinEquiv, Nat.add_comm, Nat.mul_comm] |
| rw [h, Equiv.symm_apply_apply] |
| rfl |
|
|
| theorem orderedList_sum {α β : Type*} {m n : Nat} |
| (e : α ≃ Fin m) (f : β ≃ Fin n) : |
| orderedList ((e.sumCongr f).trans finSumFinEquiv) = |
| (orderedList e).map Sum.inl ++ (orderedList f).map Sum.inr := by |
| change List.ofFn (fun q : Fin (m + n) => |
| (e.sumCongr f).symm (finSumFinEquiv.symm q)) = _ |
| rw [List.ofFn_add] |
| change (List.ofFn (fun i : Fin m => |
| (e.sumCongr f).symm (finSumFinEquiv.symm (i.castAdd n)))) ++ |
| (List.ofFn (fun i : Fin n => |
| (e.sumCongr f).symm (finSumFinEquiv.symm (i.natAdd m)))) = _ |
| simp [orderedList, List.map_ofFn] |
| rfl |
|
|
| def clauseDarts (F : Formula) (i : Fin F.clauses.length) : List (InitialGraph.Dart F) := |
| [.inl ((i, .first), false), .inl ((i, .first), true), |
| .inl ((i, .second), false), .inl ((i, .second), true), |
| .inl ((i, .third), false), .inl ((i, .third), true)] |
|
|
| theorem orderedList_dartOrder (F : Formula) : |
| orderedList (dartOrder F) = |
| (List.finRange F.clauses.length).flatMap (clauseDarts F) ++ [.inr ()] := by |
| rw [dartOrder, orderedList_cast, orderedList_sum, orderedList_prod] |
| rw [eventOrder, orderedList_prod] |
| have hs : orderedList slotOrder = [.first, .second, .third] := rfl |
| have hb : orderedList finTwoEquiv.symm = [false, true] := rfl |
| have hu : orderedList unitOrder = [()] := rfl |
| rw [hs, hb, hu] |
| simp [orderedList, List.finRange, List.flatMap_assoc, List.map_flatMap, |
| ] |
| rfl |
|
|
| def rowFor (F : Formula) (d : InitialGraph.Dart F) : |
| DartRow (F.variables + F.clauses.length + 1) (6 * F.clauses.length + 1) where |
| tail := vertexOrder F (InitialGraph.tail F d) |
| reverseIndex := dartOrder F (InitialGraph.reverse F d) |
| relation := relationOf (fun a b => InitialGraph.predicate F d (decodedLabel a) (decodedLabel b)) |
|
|
| theorem rowList_table (F : Formula) : |
| rowList (table F) = (orderedList (dartOrder F)).map (rowFor F) := by |
| simp only [rowList, table, ofEnumeratedGraph, ofGraph, graphRows, Vector.toList_ofFn, |
| orderedList, List.map_ofFn] |
| rfl |
|
|
| theorem rowWords_incidence (F : Formula) (i : Fin F.clauses.length) |
| (slot : Slot) (orientation : Bool) : |
| rowWords (rowFor F (.inl ((i, slot), orientation))) = |
| incidenceWords F.variables i.val (clauseNames (clauseAt F i)) |
| (clauseSigns (clauseAt F i)) slot orientation := by |
| have ht : (rowFor F (.inl ((i, slot), orientation))).tail.val = |
| if orientation then nameWord (clauseNames (clauseAt F i)) slot else F.variables + i.val := by |
| cases orientation <;> cases slot <;> rfl |
| have hr : (rowFor F (.inl ((i, slot), orientation))).reverseIndex.val = |
| 6 * i.val + 2 * (slotOrder slot).val + (if orientation then 0 else 1) := by |
| cases orientation <;> cases slot <;> |
| simp [rowFor, InitialGraph.reverse, dartOrder, eventOrder, slotOrder, unitOrder, |
| finProdFinEquiv, finSumFinEquiv, finTwoEquiv, Nat.mul_add, |
| Nat.mul_comm, Nat.mul_left_comm, Nat.add_comm] |
| have hp : (rowFor F (.inl ((i, slot), orientation))).relation = |
| relationOf (relationPredicate (clauseSigns (clauseAt F i)) slot orientation) := by |
| cases orientation <;> rfl |
| unfold rowWords incidenceWords relationWordsFor |
| rw [ht, hr, hp] |
| |
| theorem rowWords_dummy (F : Formula) : |
| rowWords (rowFor F (.inr ())) = dummyWords F.variables F.clauses.length := by |
| have ht : (rowFor F (.inr ())).tail.val = F.variables + F.clauses.length := rfl |
| have hr : (rowFor F (.inr ())).reverseIndex.val = 6 * F.clauses.length := by |
| simp [rowFor, InitialGraph.reverse, dartOrder, unitOrder, finSumFinEquiv] |
| have hp : (rowFor F (.inr ())).relation = relationOf (fun _ _ => true) := rfl |
| have hw : relationWords (relationOf (fun _ _ => true)) = List.replicate 4096 1 := by |
| unfold relationWords |
| rw [relationOf, Vector.toList_ofFn, List.map_ofFn] |
| exact List.ofFn_const 4096 1 |
| unfold rowWords dummyWords |
| rw [ht, hr, hp, hw] |
|
|
| theorem clauseDarts_rowWords (F : Formula) (i : Fin F.clauses.length) : |
| (clauseDarts F i).flatMap (fun d => rowWords (rowFor F d)) = |
| clauseWords F.variables i.val (clauseNames (clauseAt F i)) |
| (clauseSigns (clauseAt F i)) := by |
| simp [clauseDarts, rowWords_incidence, clauseWords, List.append_assoc] |
|
|
| theorem tableWords_eq (F : Formula) : |
| tableWords (table F) = |
| [F.variables + F.clauses.length + 1, 6 * F.clauses.length + 1] ++ |
| (List.finRange F.clauses.length).flatMap (fun i => |
| clauseWords F.variables i.val (clauseNames (clauseAt F i)) |
| (clauseSigns (clauseAt F i))) ++ dummyWords F.variables F.clauses.length := by |
| rw [tableWords, rowList_table, orderedList_dartOrder] |
| simp [List.flatMap_map, List.flatMap_append, List.flatMap_assoc, clauseDarts_rowWords, |
| rowWords_dummy] |
|
|
| end BinPackingGames.Foundations.PCP.RawInitialRows |
|
|
| namespace BinPackingGames.Foundations.PCP.RawInitialMachineModel |
|
|
| open Turing Complexity Hastad |
|
|
| inductive Tape |
| | input | variables | counter | index | field (slot : Fin 6) |
| | scratch | reversed | output |
| deriving DecidableEq, Fintype |
|
|
| abbrev Signs := Bool × Bool × Bool |
| abbrev State := Signs × Option Bool |
| abbrev Alphabet (_ : Tape) := Bool |
|
|
| inductive CopyPhase |
| | tailVariables (slot : Fin 3) |
| | tailIndex (slot : Fin 3) |
| | variableName (slot : Fin 3) |
| | reverseIndex (slot : Fin 3) (orientation : Bool) |
| | dummyVariables | dummyIndex | dummyReverse |
| deriving DecidableEq, Fintype |
|
|
| inductive Label |
| | headerStart (slot : Fin 2) | headerLoop (slot : Fin 2) |
| | scanN | restoreN | scanM1 | restoreM1 | closeFirst |
| | scanM6 | restoreM6 | closeSecond | initializeIndex | guard |
| | fieldStart (slot : Fin 6) | fieldLoop (slot : Fin 6) | loadSigns |
| | scan (phase : CopyPhase) | restore (phase : CopyPhase) |
| | closeTail (slot : Fin 3) (orientation : Bool) |
| | closeReverse (slot : Fin 3) (orientation : Bool) |
| | relation (slot : Fin 3) (orientation : Bool) |
| | cleanupField (slot : Fin 6) | incrementIndex |
| | closeDummyTail | closeDummyReverse | dummyRelation |
| | cleanupFinal (slot : Fin 3) | reset | finalReverse |
| deriving DecidableEq, Fintype |
|
|
| def initialState : State := ((false, false, false), none) |
|
|
| def stateKeys : List State := |
| [false, true].flatMap fun a => [false, true].flatMap fun b => |
| [false, true].flatMap fun c => |
| [none, some false, some true].map fun register => ((a, b, c), register) |
|
|
| theorem stateKeys_complete (state : State) : state ∈ stateKeys := by |
| rcases state with ⟨⟨a, b, c⟩, register⟩ |
| cases a <;> cases b <;> cases c <;> cases register with |
| | none => simp [stateKeys] |
| | some bit => cases bit <;> simp [stateKeys] |
| |
| def nameField (slot : Fin 3) : Fin 6 := ⟨2 * slot.val, by omega⟩ |
|
|
| def copySource : CopyPhase → Tape |
| | .tailVariables _ | .dummyVariables => .variables |
| | .variableName slot => .field (nameField slot) |
| | _ => .index |
|
|
| def copyScale : CopyPhase → Nat |
| | .reverseIndex _ _ | .dummyReverse => 6 |
| | _ => 1 |
|
|
| def copyNext : CopyPhase → Label |
| | .tailVariables slot => .scan (.tailIndex slot) |
| | .tailIndex slot => .closeTail slot false |
| | .variableName slot => .closeTail slot true |
| | .reverseIndex slot orientation => .closeReverse slot orientation |
| | .dummyVariables => .scan .dummyIndex |
| | .dummyIndex => .closeDummyTail |
| | .dummyReverse => .closeDummyReverse |
|
|
| def relationNext (slot : Fin 3) (orientation : Bool) : Label := |
| if orientation then |
| if h : slot.val + 1 < 3 then .scan (.tailVariables ⟨slot.val + 1, h⟩) |
| else .cleanupField 0 |
| else .scan (.variableName slot) |
|
|
| def finalTape (slot : Fin 3) : Tape := |
| if slot.val = 0 then .variables else if slot.val = 1 then .counter else .index |
|
|
| def drain (tape : Tape) (again next : Label) : TM2.Stmt Alphabet Label State := |
| MachineDrain.drain tape again (some next) |
|
|
| def headerTape (slot : Fin 2) : Tape := if slot.val = 0 then .variables else .counter |
|
|
| def relationOutput (slot : Fin 3) (orientation : Bool) (state : State) : List Bool := |
| (encodeWords (RawInitialRows.relationWordsFor state.1 |
| (RawInitialTables.slotOrder.symm slot) orientation)).reverse |
|
|
| def program : Label → TM2.Stmt Alphabet Label State |
| | .headerStart slot => SourceMachine.fieldStart (headerTape slot) (.headerLoop slot) |
| | .headerLoop slot => SourceMachine.fieldLoop .input (headerTape slot) (.headerLoop slot) |
| (if slot.val = 0 then some (.headerStart 1) else some .scanN) |
| | .scanN => MachineInitialHeaders.prefixScan .variables .scratch .reversed 1 .scanN .restoreN |
| | .restoreN => Reduction.MachineTransfer.loopAt .scratch .variables id false .restoreN (some .scanM1) |
| | .scanM1 => MachineInitialHeaders.prefixScan .counter .scratch .reversed 1 .scanM1 .restoreM1 |
| | .restoreM1 => Reduction.MachineTransfer.loopAt .scratch .counter id false .restoreM1 (some .closeFirst) |
| | .closeFirst => Reduction.MachineSubstitution.pushWord .reversed [true, false] |
| (.goto fun _ => .scanM6) |
| | .scanM6 => MachineInitialHeaders.prefixScan .counter .scratch .reversed 6 .scanM6 .restoreM6 |
| | .restoreM6 => Reduction.MachineTransfer.loopAt .scratch .counter id false .restoreM6 (some .closeSecond) |
| | .closeSecond => Reduction.MachineSubstitution.pushWord .reversed [true, false] |
| (.goto fun _ => .initializeIndex) |
| | .initializeIndex => .push .index (fun _ => false) (.goto fun _ => .guard) |
| | .guard => MachineUnaryCounter.guard .counter (.fieldStart 0) (.scan .dummyVariables) |
| | .fieldStart slot => SourceMachine.fieldStart (.field slot) (.fieldLoop slot) |
| | .fieldLoop slot => SourceMachine.fieldLoop .input (.field slot) (.fieldLoop slot) |
| (if h : slot.val + 1 < 6 then some (.fieldStart ⟨slot.val + 1, h⟩) |
| else some .loadSigns) |
| | .loadSigns => |
| .peek (.field 1) (fun state head => ((head.getD false, state.1.2), state.2)) |
| (.peek (.field 3) (fun state head => ((state.1.1, head.getD false, state.1.2.2), state.2)) |
| (.peek (.field 5) (fun state head => ((state.1.1, state.1.2.1, head.getD false), state.2)) |
| (.load (fun state => (state.1, none)) (.goto fun _ => .scan (.tailVariables 0))))) |
| | .scan phase => MachineInitialHeaders.prefixScan (copySource phase) .scratch .reversed |
| (copyScale phase) (.scan phase) (.restore phase) |
| | .restore phase => Reduction.MachineTransfer.loopAt .scratch (copySource phase) id false |
| (.restore phase) (some (copyNext phase)) |
| | .closeTail slot orientation => .push .reversed (fun _ => false) |
| (.goto fun _ => .scan (.reverseIndex slot orientation)) |
| | .closeReverse slot orientation => Reduction.MachineSubstitution.pushWord .reversed |
| (encodeWord (2 * slot.val + if orientation then 0 else 1)) |
| (.goto fun _ => .relation slot orientation) |
| | .relation slot orientation => MachineFiniteTable.emit .reversed |
| (relationOutput slot orientation) |
| stateKeys (.goto fun _ => relationNext slot orientation) |
| | .cleanupField slot => drain (.field slot) (.cleanupField slot) |
| (if h : slot.val + 1 < 6 then .cleanupField ⟨slot.val + 1, h⟩ else .incrementIndex) |
| | .incrementIndex => .push .index (fun _ => true) (.goto fun _ => .guard) |
| | .closeDummyTail => .push .reversed (fun _ => false) (.goto fun _ => .scan .dummyReverse) |
| | .closeDummyReverse => .push .reversed (fun _ => false) (.goto fun _ => .dummyRelation) |
| | .dummyRelation => Reduction.MachineSubstitution.pushWord .reversed |
| (encodeWords (GraphTables.relationWords (GraphTables.relationOf (fun _ _ => true)))) |
| (.goto fun _ => .cleanupFinal 0) |
| | .cleanupFinal slot => drain (finalTape slot) (.cleanupFinal slot) |
| (if h : slot.val + 1 < 3 then .cleanupFinal ⟨slot.val + 1, h⟩ else .reset) |
| | .reset => .load (fun _ => initialState) (.goto fun _ => .finalReverse) |
| | .finalReverse => Reduction.MachineTransfer.loopAt .reversed .output id false .finalReverse none |
|
|
| def machine : FinTM2 where |
| K := Tape |
| k₀ := .input |
| k₁ := .output |
| Γ := Alphabet |
| Λ := Label |
| main := .headerStart 0 |
| σ := State |
| initialState := initialState |
| m := program |
|
|
| end BinPackingGames.Foundations.PCP.RawInitialMachineModel |
|
|
| namespace BinPackingGames.Foundations.PCP.RawInitialMachineStart |
|
|
| open Turing Complexity Hastad RawInitialMachineModel |
|
|
| def inputTapes (bits : List Bool) : Tape → List Bool |
| | .input => bits |
| | _ => [] |
|
|
| private def firstTapes (n m : ℕ) (clauseBits : List Bool) : Tape → List Bool |
| | .input => encodeWord m ++ clauseBits |
| | .variables => encodeWord n |
| | _ => [] |
|
|
| def counterTapes (n m : ℕ) (clauseBits : List Bool) : Tape → List Bool |
| | .input => clauseBits |
| | .variables => encodeWord n |
| | .counter => encodeWord m |
| | _ => [] |
|
|
| private def headerTapes (n m : ℕ) (clauseBits : List Bool) : Tape → List Bool |
| | .input => clauseBits |
| | .variables => encodeWord n |
| | .counter => encodeWord m |
| | .reversed => (encodeWords [n + m + 1, 6 * m + 1]).reverse |
| | _ => [] |
|
|
| def startTapes (n m : ℕ) (clauseBits : List Bool) : Tape → List Bool |
| | .input => clauseBits |
| | .variables => encodeWord n |
| | .counter => encodeWord m |
| | .index => [false] |
| | .reversed => (encodeWords [n + m + 1, 6 * m + 1]).reverse |
| | _ => [] |
|
|
| theorem initList_eq (bits : List Bool) : |
| initList machine bits = |
| ⟨some (.headerStart 0), initialState, inputTapes bits⟩ := by |
| unfold initList |
| congr 1 |
| funext k |
| change Tape at k |
| cases k <;> rfl |
| |
| private theorem trace_trans {α : Type*} (f : α → α) {a b : ℕ} {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] |
|
|
| theorem readCountersTrace (n m : ℕ) (clauseBits : List Bool) : |
| (MachineComposition.advance (TM2.step program))^[n + m + 4] |
| (some (initList machine (encodeWords [n, m] ++ clauseBits))) = |
| some ⟨some .scanN, initialState, counterTapes n m clauseBits⟩ := by |
| let t0 := inputTapes (encodeWords [n, m] ++ clauseBits) |
| have first := (SourceMachine.fieldInTime .input .variables (by decide) |
| (.headerStart 0) (.headerLoop 0) (some (.headerStart 1)) program rfl rfl |
| t0 n (encodeWord m ++ clauseBits) |
| (by simp [t0, inputTapes, encodeWords, List.append_assoc]) |
| (false, false, false) none).evals_in_steps |
| change (MachineComposition.advance (TM2.step program))^[n + 2] |
| (some ⟨some (.headerStart 0), initialState, t0⟩) = _ at first |
| have firstFrame : SourceMachine.fieldTapes .input .variables t0 |
| (encodeWord m ++ clauseBits) (encodeWord n ++ t0 .variables) = |
| firstTapes n m clauseBits := by |
| funext k |
| cases k <;> simp [SourceMachine.fieldTapes, t0, inputTapes, firstTapes] |
| rw [firstFrame] at first |
| have second := (SourceMachine.fieldInTime .input .counter (by decide) |
| (.headerStart 1) (.headerLoop 1) (some .scanN) program rfl rfl |
| (firstTapes n m clauseBits) m clauseBits rfl (false, false, false) none).evals_in_steps |
| change (MachineComposition.advance (TM2.step program))^[m + 2] |
| (some ⟨some (.headerStart 1), initialState, firstTapes n m clauseBits⟩) = _ at second |
| have secondFrame : SourceMachine.fieldTapes .input .counter (firstTapes n m clauseBits) |
| clauseBits (encodeWord m ++ firstTapes n m clauseBits .counter) = |
| counterTapes n m clauseBits := by |
| funext k |
| cases k <;> simp [SourceMachine.fieldTapes, firstTapes, counterTapes] |
| rw [secondFrame] at second |
| have total := trace_trans _ first second |
| rw [show (n + 2) + (m + 2) = n + m + 4 by omega] at total |
| simpa only [initList_eq, t0, initialState] using! total |
|
|
| theorem headersTrace (n m : ℕ) (clauseBits : List Bool) : |
| (MachineComposition.advance (TM2.step program))^[2 * n + 4 * m + 8] |
| (some ⟨some .scanN, initialState, counterTapes n m clauseBits⟩) = |
| some ⟨some .initializeIndex, initialState, headerTapes n m clauseBits⟩ := by |
| have h := MachineInitialHeaders.headerTrace .variables .counter .scratch .reversed |
| (by decide) (by decide) (by decide) (by decide) (by decide) (by decide) |
| .scanN .restoreN .scanM1 .restoreM1 .closeFirst .scanM6 .restoreM6 .closeSecond |
| (some .initializeIndex) program rfl rfl rfl rfl rfl rfl rfl rfl |
| (counterTapes n m clauseBits) n m [] [] |
| (by simp [counterTapes]) (by simp [counterTapes]) rfl |
| (false, false, false) none |
| have frame : Function.update (counterTapes n m clauseBits) .reversed |
| ((encodeWords [n + m + 1, 6 * m + 1]).reverse ++ |
| counterTapes n m clauseBits .reversed) = headerTapes n m clauseBits := by |
| funext k |
| cases k <;> simp [counterTapes, headerTapes] |
| rw [frame] at h |
| exact h |
| |
| theorem initializeIndexTrace (n m : ℕ) (clauseBits : List Bool) : |
| (MachineComposition.advance (TM2.step program))^[1] |
| (some ⟨some .initializeIndex, initialState, headerTapes n m clauseBits⟩) = |
| some ⟨some .guard, initialState, startTapes n m clauseBits⟩ := by |
| simp only [Function.iterate_one, MachineComposition.advance_some] |
| change some (TM2.stepAux (program .initializeIndex) initialState |
| (headerTapes n m clauseBits)) = _ |
| simp only [program, TM2.stepAux] |
| congr 2 |
| funext k |
| cases k <;> simp [headerTapes, startTapes] |
| |
| theorem startTrace (n m : ℕ) (clauseBits : List Bool) : |
| (MachineComposition.advance (TM2.step program))^[3 * n + 5 * m + 13] |
| (some (initList machine (encodeWords [n, m] ++ clauseBits))) = |
| some ⟨some .guard, initialState, startTapes n m clauseBits⟩ := by |
| have total := trace_trans _ |
| (trace_trans _ (readCountersTrace n m clauseBits) (headersTrace n m clauseBits)) |
| (initializeIndexTrace n m clauseBits) |
| simpa only [show (n + m + 4) + (2 * n + 4 * m + 8) + 1 = |
| 3 * n + 5 * m + 13 by omega] using total |
|
|
| theorem formulaStartTrace (F : Target.Formula) : |
| (MachineComposition.advance (TM2.step program))^[ |
| 3 * F.variables + 5 * F.clauses.length + 13] |
| (some (initList machine (formulaBits F))) = |
| some ⟨some .guard, initialState, |
| startTapes F.variables F.clauses.length |
| (encodeWords (F.clauses.flatMap clauseWords))⟩ := by |
| simpa only [formulaBits, formulaWords, encodeWords_append] using |
| startTrace F.variables F.clauses.length (encodeWords (F.clauses.flatMap clauseWords)) |
|
|
| def startInTime (n m : ℕ) (clauseBits : List Bool) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| (initList machine (encodeWords [n, m] ++ clauseBits)) |
| (some ⟨some .guard, initialState, startTapes n m clauseBits⟩) |
| (3 * n + 5 * m + 13) where |
| steps := 3 * n + 5 * m + 13 |
| evals_in_steps := startTrace n m clauseBits |
| steps_le_m := Nat.le_refl _ |
|
|
| def formulaStartInTime (F : Target.Formula) : |
| StateTransition.EvalsToInTime (TM2.step program) (initList machine (formulaBits F)) |
| (some ⟨some .guard, initialState, |
| startTapes F.variables F.clauses.length |
| (encodeWords (F.clauses.flatMap clauseWords))⟩) |
| (3 * F.variables + 5 * F.clauses.length + 13) where |
| steps := 3 * F.variables + 5 * F.clauses.length + 13 |
| evals_in_steps := formulaStartTrace F |
| steps_le_m := Nat.le_refl _ |
|
|
| end BinPackingGames.Foundations.PCP.RawInitialMachineStart |
|
|
| namespace BinPackingGames.Foundations.PCP.RawInitialMachinePhases |
|
|
| open Turing Complexity RawInitialMachineModel |
|
|
| theorem copySource_ne_scratch (phase : CopyPhase) : copySource phase ≠ Tape.scratch := by |
| cases phase <;> simp [copySource] |
| |
| theorem copySource_ne_reversed (phase : CopyPhase) : copySource phase ≠ Tape.reversed := by |
| cases phase <;> simp [copySource] |
| |
| def copyInTime (phase : CopyPhase) (base : Tape → List Bool) |
| (n : Nat) (suffix : List Bool) |
| (hsource : base (copySource phase) = encodeWord n ++ suffix) |
| (hscratch : base .scratch = []) (state : State) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.scan phase), state, base⟩ |
| (some ⟨some (copyNext phase), (state.1, none), |
| Function.update base .reversed |
| (List.replicate (copyScale phase * n) true ++ base .reversed)⟩) |
| (2 * n + 2) := |
| MachineInitialHeaders.prefixInTime (copySource phase) Tape.scratch Tape.reversed |
| (copySource_ne_scratch phase) (copySource_ne_reversed phase) (by decide) |
| (copyScale phase) (.scan phase) (.restore phase) (some (copyNext phase)) |
| program rfl rfl base n suffix hsource hscratch state.1 state.2 |
|
|
| def relationInTime (slot : Fin 3) (orientation : Bool) |
| (base : Tape → List Bool) (state : State) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.relation slot orientation), state, base⟩ |
| (some ⟨some (relationNext slot orientation), state, |
| Function.update base .reversed |
| (relationOutput slot orientation state ++ base .reversed)⟩) 1 := |
| MachineFiniteTable.emitInTime (K := Tape) (Λ := Label) (σ := State) (Γ := Alphabet) |
| Tape.reversed |
| (relationOutput slot orientation) |
| stateKeys stateKeys_complete program (.relation slot orientation) |
| (relationNext slot orientation) rfl state base |
|
|
| private theorem bitWord_head (b : Bool) : |
| (encodeWord (if b then 1 else 0)).head? = some b := by |
| cases b <;> rfl |
| |
| theorem loadSigns_step (base : Tape → List Bool) (a b c : Bool) |
| (ha : base (.field 1) = encodeWord (if a then 1 else 0)) |
| (hb : base (.field 3) = encodeWord (if b then 1 else 0)) |
| (hc : base (.field 5) = encodeWord (if c then 1 else 0)) (state : State) : |
| (TM2.step program) ⟨some .loadSigns, state, base⟩ = |
| some ⟨some (.scan (.tailVariables 0)), ((a, b, c), none), base⟩ := by |
| change some (TM2.stepAux (program .loadSigns) state base) = _ |
| simp only [program, TM2.stepAux, ha, hb, hc, bitWord_head, Option.getD_some] |
|
|
| def loadSignsInTime (base : Tape → List Bool) (a b c : Bool) |
| (ha : base (.field 1) = encodeWord (if a then 1 else 0)) |
| (hb : base (.field 3) = encodeWord (if b then 1 else 0)) |
| (hc : base (.field 5) = encodeWord (if c then 1 else 0)) (state : State) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some .loadSigns, state, base⟩ |
| (some ⟨some (.scan (.tailVariables 0)), ((a, b, c), none), base⟩) 1 where |
| steps := 1 |
| evals_in_steps := loadSigns_step base a b c ha hb hc state |
| steps_le_m := Nat.le_refl _ |
|
|
| def cleanupFieldInTime (slot : Fin 6) (base : Tape → List Bool) (state : State) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.cleanupField slot), state, base⟩ |
| (some ⟨some (if h : slot.val + 1 < 6 then .cleanupField ⟨slot.val + 1, h⟩ |
| else .incrementIndex), (state.1, none), Function.update base (.field slot) []⟩) |
| ((base (.field slot)).length + 1) := |
| MachineDrain.drainInTime (.field slot) (.cleanupField slot) _ program rfl base state.1 state.2 |
|
|
| def cleanupFinalInTime (slot : Fin 3) (base : Tape → List Bool) (state : State) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (.cleanupFinal slot), state, base⟩ |
| (some ⟨some (if h : slot.val + 1 < 3 then .cleanupFinal ⟨slot.val + 1, h⟩ |
| else .reset), (state.1, none), Function.update base (finalTape slot) []⟩) |
| ((base (finalTape slot)).length + 1) := |
| MachineDrain.drainInTime (finalTape slot) (.cleanupFinal slot) _ program rfl base state.1 state.2 |
|
|
| end BinPackingGames.Foundations.PCP.RawInitialMachinePhases |
|
|
| namespace BinPackingGames.Foundations.PCP.RawInitialMachineLoopData |
|
|
| open Target Complexity RawInitialMachineModel |
|
|
| def clauseInput {n : Nat} (clauses : List (Clause n)) : List Bool := |
| encodeWords (clauses.flatMap Complexity.clauseWords) |
|
|
| @[simp] theorem clauseInput_nil (n : Nat) : clauseInput ([] : List (Clause n)) = [] := rfl |
|
|
| @[simp] theorem clauseInput_cons {n : Nat} (c : Clause n) (cs : List (Clause n)) : |
| clauseInput (c :: cs) = encodeWords (Complexity.clauseWords c) ++ clauseInput cs := by |
| simp only [clauseInput, List.flatMap_cons, encodeWords_append] |
|
|
| def clauseOutput (n i : Nat) (clauses : List (Clause n)) : List Nat := |
| (clauses.mapIdx fun offset c => RawInitialRows.clauseWords n (i + offset) |
| (RawInitialRows.clauseNames c) (RawInitialRows.clauseSigns c)).flatten |
|
|
| private theorem mapIdx_ofFn {α β : Type} (xs : List α) (f : Nat → α → β) : |
| xs.mapIdx f = List.ofFn (fun i : Fin xs.length => f i.val (xs.get i)) := by |
| induction xs generalizing f with |
| | nil => simp |
| | cons x xs ih => simp [ih] |
|
|
| @[simp] theorem clauseOutput_nil (n i : Nat) : clauseOutput n i [] = [] := rfl |
|
|
| @[simp] theorem clauseOutput_cons (n i : Nat) (c : Clause n) (cs : List (Clause n)) : |
| clauseOutput n i (c :: cs) = |
| RawInitialRows.clauseWords n i (RawInitialRows.clauseNames c) |
| (RawInitialRows.clauseSigns c) ++ clauseOutput n (i + 1) cs := by |
| simp only [clauseOutput, List.mapIdx_cons, Nat.add_zero, List.flatten_cons, |
| Nat.add_comm, Nat.add_left_comm] |
|
|
| theorem clauseOutput_numbered (F : Formula) : |
| clauseOutput F.variables 0 F.clauses = |
| (List.finRange F.clauses.length).flatMap (fun i => |
| RawInitialRows.clauseWords F.variables i.val |
| (RawInitialRows.clauseNames (clauseAt F i)) |
| (RawInitialRows.clauseSigns (clauseAt F i))) := by |
| simp only [clauseOutput, mapIdx_ofFn, List.ofFn_eq_map, |
| Nat.zero_add, clauseAt] |
| rfl |
|
|
| theorem tableWords_decomposition (F : Formula) : |
| GraphTables.tableWords (RawInitialTables.table F) = |
| [F.variables + F.clauses.length + 1, 6 * F.clauses.length + 1] ++ |
| clauseOutput F.variables 0 F.clauses ++ |
| RawInitialRows.dummyWords F.variables F.clauses.length := by |
| rw [RawInitialRows.tableWords_eq, clauseOutput_numbered] |
|
|
| def loopTapes (n i remaining : Nat) (input reversed : List Bool) : Tape → List Bool |
| | .input => input |
| | .variables => encodeWord n |
| | .counter => encodeWord remaining |
| | .index => encodeWord i |
| | .reversed => reversed |
| | _ => [] |
|
|
| theorem startTapes_eq (n m : Nat) (input : List Bool) : |
| RawInitialMachineStart.startTapes n m input = |
| loopTapes n 0 m input (encodeWords [n + m + 1, 6 * m + 1]).reverse := by |
| funext tape |
| cases tape <;> rfl |
| |
| theorem decrement_counter (n i remaining : Nat) (input reversed : List Bool) : |
| Function.update (loopTapes n i (remaining + 1) input reversed) |
| Tape.counter (encodeWord remaining) = loopTapes n i remaining input reversed := by |
| funext tape |
| cases tape <;> simp [loopTapes] |
| |
| theorem increment_index (n i remaining : Nat) (input reversed : List Bool) : |
| Function.update (loopTapes n i remaining input reversed) |
| Tape.index (true :: encodeWord i) = loopTapes n (i + 1) remaining input reversed := by |
| funext tape |
| cases tape <;> simp [loopTapes, encodeWord, List.replicate_succ] |
| |
| end BinPackingGames.Foundations.PCP.RawInitialMachineLoopData |
| |
| end OAI |
| |
