File size: 6,166 Bytes
e320e82 | 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 | import Mathlib
import OAI.Combinatorics.IndependentSets.PCP.Body
import OAI.Combinatorics.IndependentSets.Machines.Initialization
namespace OAI
namespace IndependentSetsGames.Foundations.PCP.AlphabetTable.LoopInitialization
open IndependentSetsGames.Foundations.Complexity
open RuntimeModel LoopState
theorem initialization_ready {q : Nat} (input : GenericGraphTables.Table q) :
Ready input 0 (Initialization.loopTapes input) where
le_darts := Nat.zero_le _
original := rfl
cursor := by
change Initialization.rowsBits input = cursorBits input 0
rw [cursorBits_zero]
rfl
vertices := rfl
darts := rfl
counter := by simp [Initialization.loopTapes]
edge := rfl
tail := rfl
reverseIndex := rfl
head := rfl
scratch := rfl
compareLeft := rfl
compareRight := rfl
output := rfl
reversed := by
change (Initialization.headerBits input).reverse = (prefixBits input 0).reverse
rw [prefixBits_zero]
rfl
end IndependentSetsGames.Foundations.PCP.AlphabetTable.LoopInitialization
namespace IndependentSetsGames.Foundations.PCP.AlphabetTable.Loop
open Turing
open IndependentSetsGames.Foundations.Complexity
open RuntimeModel
variable {q : Nat}
def zeroGuardInTime (input : GenericGraphTables.Table q) (base : Tape → List Bool)
(ready : LoopState.Ready input input.darts base)
(relation : GenericGraphTables.RelationTable q) (flag : Bool) :
StateTransition.EvalsToInTime (TM2.step (Driver.program q))
⟨some .guard, normal relation flag, base⟩
(some ⟨some .reverseOutput, normal relation flag, base⟩) 1 := by
have counterSelf : MachineUnaryCounter.counterTapes Tape.counter base 0 [] = base := by
simp only [MachineUnaryCounter.counterTapes, List.append_nil,
← ready.counter_at_end, Function.update_eq_self]
have run := MachineUnaryCounter.guardInTime_zero Tape.counter
(Driver.Label.guard : Driver.Label q) .tailStart .reverseOutput
(Driver.program q) (Driver.program_guard q) base [] (normal relation flag).1 none
simpa only [counterSelf, normal] using run
structure LoopResult (input : GenericGraphTables.Table q) (e remaining : Nat)
(base : Tape → List Bool) (oldRelation : GenericGraphTables.RelationTable q)
(oldFlag : Bool) where
tapes : Tape → List Bool
relation : GenericGraphTables.RelationTable q
flag : Bool
ready : LoopState.Ready input input.darts tapes
run : StateTransition.EvalsToInTime (TM2.step (Driver.program q))
⟨some .guard, normal oldRelation oldFlag, base⟩
(some ⟨some .reverseOutput, normal relation flag, tapes⟩)
(remaining * Body.bodyTime q (LoopState.inputBits input).length + 1)
def runRemaining (input : GenericGraphTables.Table q) :
(remaining e : Nat) → e + remaining = input.darts →
(base : Tape → List Bool) → LoopState.Ready input e base →
(oldRelation : GenericGraphTables.RelationTable q) → (oldFlag : Bool) →
LoopResult input e remaining base oldRelation oldFlag
| 0, e, finished, base, ready, oldRelation, oldFlag => by
have atEnd : e = input.darts := by omega
subst e
exact {
tapes := base
relation := oldRelation
flag := oldFlag
ready := ready
run := by
simpa only [Nat.zero_mul, Nat.zero_add] using
zeroGuardInTime input base ready oldRelation oldFlag }
| remaining + 1, e, finished, base, ready, oldRelation, oldFlag => by
have beforeEnd : e < input.darts := by omega
let edge : Fin input.darts := ⟨e, beforeEnd⟩
let one := Body.rowStep input edge base ready oldRelation oldFlag
let rest := runRemaining input remaining (e + 1) (by omega) one.tapes one.ready
input.rows[edge].relation (CompareLoop.rowLoop input edge)
let composed := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ one.run rest.run
refine {
tapes := rest.tapes
relation := rest.relation
flag := rest.flag
ready := rest.ready
run := { toEvalsTo := composed.toEvalsTo, steps_le_m := ?_ } }
have budget := composed.steps_le_m
simpa only [Nat.succ_mul, Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using budget
def prefixTime (q N : Nat) : Nat :=
Initialization.time N + N * Body.bodyTime q N + 1
structure PrefixResult (input : GenericGraphTables.Table q) where
tapes : Tape → List Bool
relation : GenericGraphTables.RelationTable q
flag : Bool
ready : LoopState.Ready input input.darts tapes
run : StateTransition.EvalsToInTime (TM2.step (Driver.program q))
(initList (Driver.machine q) (GenericGraphTables.tableBits input))
(some ⟨some .reverseOutput, normal relation flag, tapes⟩)
(prefixTime q (LoopState.inputBits input).length)
def runPrefix (input : GenericGraphTables.Table q) : PrefixResult input := by
let rows := runRemaining input input.darts 0 (by simp)
(Initialization.loopTapes input) (LoopInitialization.initialization_ready input)
(Vector.replicate (q * q) false) false
let composed := StateTransition.EvalsToInTime.trans _ _ _ _ _ _
(Initialization.initializeInTime input) rows.run
refine {
tapes := rows.tapes
relation := rows.relation
flag := rows.flag
ready := rows.ready
run := { toEvalsTo := composed.toEvalsTo, steps_le_m := ?_ } }
have budget := composed.steps_le_m
change composed.steps ≤
input.darts * Body.bodyTime q (LoopState.inputBits input).length + 1 +
Initialization.time (LoopState.inputBits input).length at budget
have rowCount : input.darts ≤ (LoopState.inputBits input).length :=
GenericGraphTables.darts_le_tableBits_length input
have rowBudget := Nat.mul_le_mul_right (Body.bodyTime q (LoopState.inputBits input).length)
rowCount
unfold prefixTime
omega
theorem PrefixResult.reversed {input : GenericGraphTables.Table q} (result : PrefixResult input) :
result.tapes .reversed = (GraphTables.tableBits (Table.build input)).reverse :=
result.ready.reversed_at_end
theorem PrefixResult.output {input : GenericGraphTables.Table q} (result : PrefixResult input) :
result.tapes .output = [] := result.ready.output
end IndependentSetsGames.Foundations.PCP.AlphabetTable.Loop
end OAI
|