File size: 7,390 Bytes
760f90e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 | import OAI.Computability.UniqueGames.PCP.DriverLemmas
namespace OAI
/-!
Actual setup-to-guard execution of the alphabet-table driver. The preserved
input is parsed by Setup; the finite header template runs through an explicit
state equivalence. The resulting loop invariant is a complete tape equation.
-/
namespace UniqueGamesTheorem.Foundations.PCP.AlphabetTable.Initialization
open Turing
open UniqueGamesTheorem.Foundations.Complexity
open RuntimeModel
variable {q : Nat}
def inputTapes (input : GenericGraphTables.Table q) : Tape → List Bool
| .original => GenericGraphTables.tableBits input
| _ => []
def rowsBits (input : GenericGraphTables.Table q) : List Bool :=
encodeWords ((GenericGraphTables.rowList input).flatMap GenericGraphTables.rowWords)
def headerBits (input : GenericGraphTables.Table q) : List Bool :=
encodeWords [Enumeration.vertexCount input.vertices input.darts q,
Enumeration.dartCount input.darts q]
def setupTapes (input : GenericGraphTables.Table q) : Tape → List Bool
| .original => GenericGraphTables.tableBits input
| .cursor => rowsBits input
| .vertices => encodeWord input.vertices
| .darts | .counter => encodeWord input.darts
| .edge => encodeWord 0
| _ => []
/-- Complete initial loop state. Every auxiliary tape not listed here is empty. -/
def loopTapes (input : GenericGraphTables.Table q) : Tape → List Bool
| .original => GenericGraphTables.tableBits input
| .cursor => rowsBits input
| .vertices => encodeWord input.vertices
| .darts | .counter => encodeWord input.darts
| .edge => encodeWord 0
| .reversed => (headerBits input).reverse
| _ => []
def loopStart (input : GenericGraphTables.Table q) :
TM2.Cfg Alphabet (Driver.Label q) (State q) :=
⟨some .guard, initial q, loopTapes input⟩
theorem setupResult_eq (input : GenericGraphTables.Table q) :
Setup.resultTapes setupPorts (inputTapes input) input.vertices input.darts (rowsBits input) =
setupTapes input := by
funext tape
cases tape <;> simp [Setup.resultTapes, setupPorts, inputTapes, setupTapes]
theorem headerResult_eq (input : GenericGraphTables.Table q) :
Emitter.resultTapes Tape.reversed (setupTapes input) (headerBits input) = loopTapes input := by
funext tape
cases tape <;> simp [Emitter.resultTapes, setupTapes, loopTapes]
theorem machineInitial_eq (input : GenericGraphTables.Table q) :
initList (Driver.machine q) (GenericGraphTables.tableBits input) =
(⟨some (.setup .copyFirst), initial q, inputTapes input⟩ :
TM2.Cfg Alphabet (Driver.Label q) (State q)) := by
change (⟨some (.setup .copyFirst), initial q, _⟩ :
TM2.Cfg Alphabet (Driver.Label q) (State q)) = _
congr 1
funext tape
cases tape <;> rfl
/-- The driver executes its actual setup statements from its actual input configuration. -/
def setupInTime (input : GenericGraphTables.Table q) :
StateTransition.EvalsToInTime (TM2.step (Driver.program q))
(initList (Driver.machine q) (GenericGraphTables.tableBits input))
(some ⟨some (Driver.headerEntry q), initial q, setupTapes input⟩)
(6 * (GenericGraphTables.tableBits input).length + 11) := by
have initialized : ∀ i : Fin 7, inputTapes input (setupPorts i) =
if i = 0 then GenericGraphTables.tableBits input else [] := by
intro i
fin_cases i <;> rfl
have run := Setup.tableSetupInTime setupPorts setupPorts_injective Driver.Label.setup
(some (Driver.headerEntry q)) (Driver.program q) (Driver.program_setup q)
(inputTapes input) input initialized (initial q).1 none
have initialState : ((initial q).1, (none : Option Bool)) = initial q := rfl
have result := setupResult_eq input
unfold rowsBits at result
rw [initialState, result] at run
rw [machineInitial_eq]
exact run
private theorem headerView_at (label : Emitter.Label (Driver.headerPlan q).length
(Addresses.fieldBound q)) :
(MachineControl.program (Equiv.refl (Driver.Label q)) (emitterEquiv q).symm
(Driver.program q)) (.header label) =
Emitter.statement (Emitter.listCommands (Driver.headerPlan q)) headerSources
Tape.scratch Tape.reversed Driver.Label.header (some .guard) label := by
change MachineControl.statement id (emitterEquiv q).symm
(MachineControl.statement id (emitterEquiv q) _) = _
exact MachineFieldProfile.statement_roundtrip (emitterEquiv q).symm _
/-- No header execution is assumed: the checked template is instantiated at
the concrete driver labels and transported through the finite state layout. -/
def headerInTime (input : GenericGraphTables.Table q) :
StateTransition.EvalsToInTime (TM2.step (Driver.program q))
⟨some (Driver.headerEntry q), initial q, setupTapes input⟩
(some (loopStart input))
(7 * (3 * ((GenericGraphTables.tableBits input).length + 1) + 3) + 1) := by
let view := MachineControl.program (Equiv.refl (Driver.Label q)) (emitterEquiv q).symm
(Driver.program q)
have sourceScratch : ∀ i : Fin 2, headerSources i ≠ Tape.scratch := by
intro i
fin_cases i <;> decide
have sourceOutput : ∀ i : Fin 2, headerSources i ≠ Tape.reversed := by
intro i
fin_cases i <;> decide
have operands : ∀ i : Fin 2, setupTapes input (headerSources i) =
encodeWord (![input.vertices, input.darts] i) := by
intro i
fin_cases i <;> rfl
have run := EmitRows.headerInTime q input.vertices input.darts headerSources
Tape.scratch Tape.reversed sourceScratch sourceOutput (by decide)
Driver.Label.header (some .guard) view headerView_at
(setupTapes input) operands (by rfl) (initial q).1
(GenericGraphTables.tableBits input).length
(GenericGraphTables.vertices_le_tableBits_length input)
(GenericGraphTables.darts_le_tableBits_length input)
have restored : MachineControl.program (Equiv.refl (Driver.Label q)) (emitterEquiv q) view =
Driver.program q := by
funext label
exact MachineFieldProfile.statement_roundtrip (emitterEquiv q) (Driver.program q label)
have transported := transportInTime (emitterEquiv q) view run
rw [restored] at transported
change StateTransition.EvalsToInTime (TM2.step (Driver.program q))
⟨some (Driver.headerEntry q), initial q, setupTapes input⟩
(some ⟨some .guard, initial q,
Emitter.resultTapes Tape.reversed (setupTapes input) (headerBits input)⟩)
(7 * (3 * ((GenericGraphTables.tableBits input).length + 1) + 3) + 1) at transported
rw [headerResult_eq] at transported
exact transported
def time (N : Nat) : Nat := (6 * N + 11) + (7 * (3 * (N + 1) + 3) + 1)
theorem time_eq (N : Nat) : time N = 27 * N + 54 := by
unfold time
omega
/-- Actual initialization of the complete finite driver, ending at its first
guard with the exact input, counter, cursor, index, and reversed headers. -/
def initializeInTime (input : GenericGraphTables.Table q) :
StateTransition.EvalsToInTime (TM2.step (Driver.program q))
(initList (Driver.machine q) (GenericGraphTables.tableBits input))
(some (loopStart input)) (time (GenericGraphTables.tableBits input).length) := by
let run := StateTransition.EvalsToInTime.trans _ _ _ _ _ _
(setupInTime input) (headerInTime input)
refine { toEvalsTo := run.toEvalsTo, steps_le_m := ?_ }
have bound := run.steps_le_m
unfold time
omega
end UniqueGamesTheorem.Foundations.PCP.AlphabetTable.Initialization
end OAI
|