File size: 7,829 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 166 167 168 169 170 171 172 | import OAI.Computability.UniqueGames.Machines.MachineCopy
import OAI.Computability.UniqueGames.Machines.MachineDrain
import OAI.Computability.UniqueGames.Machines.MachineLogCounter
namespace OAI
/-! A fixed Boolean-stack program prepending the logarithmic round count to
a graph table. It copies the original word, adds its two unary header values,
runs the actual logarithm machine, then emits the counter and original word. -/
namespace UniqueGamesTheorem.Foundations.Complexity.GraphCounterModel
open Turing
inductive ExtraTape where
| input | archive | scratch | output
deriving DecidableEq
protected abbrev ExtraTape.enumList : List ExtraTape := [.input, .archive, .scratch, .output]
protected theorem ExtraTape.enumList_getElem?_ctorIdx_eq (x : ExtraTape) :
ExtraTape.enumList[x.ctorIdx]? = some x := by
cases x <;> rfl
protected theorem ExtraTape.enumList_nodup : ExtraTape.enumList.Nodup := by decide
instance : Fintype ExtraTape where
elems := ⟨ExtraTape.enumList, ExtraTape.enumList_nodup⟩
complete x := by cases x <;> decide
inductive ExtraLabel where
| copyFirst | copySecond | seed | headerFirst | headerSecond
| clearInput | clockCopy | archiveCopy | finalReverse
deriving DecidableEq
protected abbrev ExtraLabel.enumList : List ExtraLabel := [.copyFirst, .copySecond, .seed,
.headerFirst, .headerSecond, .clearInput, .clockCopy, .archiveCopy, .finalReverse]
protected theorem ExtraLabel.enumList_getElem?_ctorIdx_eq (x : ExtraLabel) :
ExtraLabel.enumList[x.ctorIdx]? = some x := by
cases x <;> rfl
protected theorem ExtraLabel.enumList_nodup : ExtraLabel.enumList.Nodup := by decide
instance : Fintype ExtraLabel where
elems := ⟨ExtraLabel.enumList, ExtraLabel.enumList_nodup⟩
complete x := by cases x <;> decide
abbrev Tape := Fin 3 ⊕ ExtraTape
abbrev Label := Fin 5 ⊕ ExtraLabel
abbrev Alphabet (_ : Tape) := Bool
abbrev State := MachineLogCounter.State × Option Bool
def initialState : State := (MachineLogCounter.initialState, none)
def clockLabel : Option (Fin 5) → Option Label
| none => some (.inr .clearInput)
| some l => some (.inl l)
/-- Homogeneous Boolean embedding of the fixed logarithm program. -/
def clockStatement : TM2.Stmt MachineLogCounter.Alphabet (Fin 5) MachineLogCounter.State →
TM2.Stmt Alphabet Label State
| .push k f next => .push (.inl k) (fun state => f state.1) (clockStatement next)
| .peek k f next => .peek (.inl k) (fun state x => (f state.1 x, state.2)) (clockStatement next)
| .pop k f next => .pop (.inl k) (fun state x => (f state.1 x, state.2)) (clockStatement next)
| .load f next => .load (fun state => (f state.1, state.2)) (clockStatement next)
| .branch f yes no => .branch (fun state => f state.1) (clockStatement yes) (clockStatement no)
| .goto f => .goto (fun state => .inl (f state.1))
| .halt => .goto (fun _ => .inr .clearInput)
def readHeader (again next : Label) : TM2.Stmt Alphabet Label State :=
.pop (.inr .input) (fun state head => (state.1, head))
(.branch (fun state => state.2.getD false)
(.push (.inl 0) (fun _ => true) (.goto fun _ => again))
(.load (fun state => (state.1, none)) (.goto fun _ => next)))
def program : Label → TM2.Stmt Alphabet Label State
| .inl l => clockStatement (MachineLogCounter.program l)
| .inr .copyFirst => Reduction.MachineTransfer.loopAt (.inr .input) (.inr .scratch)
id false (.inr .copyFirst) (some (.inr .copySecond))
| .inr .copySecond => MachineCopy.forkLoop (.inr .scratch) (.inr .input) (.inr .archive)
false (.inr .copySecond) (some (.inr .seed))
| .inr .seed => .push (.inl 0) (fun _ => false) (.goto fun _ => .inr .headerFirst)
| .inr .headerFirst => readHeader (.inr .headerFirst) (.inr .headerSecond)
| .inr .headerSecond => readHeader (.inr .headerSecond) (.inl 0)
| .inr .clearInput => MachineDrain.drain (.inr .input) (.inr .clearInput)
(some (.inr .clockCopy))
| .inr .clockCopy => Reduction.MachineTransfer.loopAt (.inl 2) (.inr .scratch)
id false (.inr .clockCopy) (some (.inr .archiveCopy))
| .inr .archiveCopy => Reduction.MachineTransfer.loopAt (.inr .archive) (.inr .scratch)
id false (.inr .archiveCopy) (some (.inr .finalReverse))
| .inr .finalReverse => Reduction.MachineTransfer.loopAt (.inr .scratch) (.inr .output)
id false (.inr .finalReverse) none
def machine : FinTM2 where
K := Tape
k₀ := .inr .input
k₁ := .inr .output
Γ := Alphabet
Λ := Label
main := .inr .copyFirst
σ := State
initialState := initialState
m := program
def clockTapes (tapes : Fin 3 → List Bool) (extra : ExtraTape → List Bool) : Tape → List Bool
| .inl k => tapes k
| .inr k => extra k
def clockConfiguration (extra : ExtraTape → List Bool) (register : Option Bool)
(c : TM2.Cfg MachineLogCounter.Alphabet (Fin 5) MachineLogCounter.State) :
TM2.Cfg Alphabet Label State := ⟨clockLabel c.l, (c.var, register), clockTapes c.stk extra⟩
theorem clockTapes_update (tapes : Fin 3 → List Bool) (extra : ExtraTape → List Bool)
(k : Fin 3) (word : List Bool) :
clockTapes (Function.update tapes k word) extra =
Function.update (clockTapes tapes extra) (.inl k) word := by
funext tape
cases tape <;> simp [clockTapes, Function.comp_def]
theorem clockStatement_simulation (extra : ExtraTape → List Bool) (register : Option Bool)
(statement : TM2.Stmt MachineLogCounter.Alphabet (Fin 5) MachineLogCounter.State)
(state : MachineLogCounter.State) (tapes : Fin 3 → List Bool) :
TM2.stepAux (clockStatement statement) (state, register) (clockTapes tapes extra) =
clockConfiguration extra register (TM2.stepAux statement state tapes) := by
induction statement generalizing state tapes with
| push k f next ih =>
simp only [clockStatement, TM2.stepAux, clockTapes]
rw [← clockTapes_update]
exact ih state (Function.update tapes k (f state :: tapes k))
| peek k f next ih =>
simpa only [clockStatement, TM2.stepAux, clockTapes] using ih (f state (tapes k).head?) tapes
| pop k f next ih =>
simp only [clockStatement, TM2.stepAux, clockTapes]
rw [← clockTapes_update]
exact ih (f state (tapes k).head?) (Function.update tapes k (tapes k).tail)
| load f next ih =>
simpa only [clockStatement, TM2.stepAux] using ih (f state) tapes
| branch f yes no ihYes ihNo =>
cases h : f state with
| false => simpa only [clockStatement, TM2.stepAux, h, Bool.cond_false] using ihNo state tapes
| true => simpa only [clockStatement, TM2.stepAux, h, Bool.cond_true] using ihYes state tapes
| goto f => rfl
| halt => rfl
theorem clockStep (extra : ExtraTape → List Bool) (register : Option Bool)
(a b : MachineLogCounter.machine.Cfg)
(h : MachineLogCounter.machine.step a = some b) :
TM2.step program (clockConfiguration extra register a) =
some (clockConfiguration extra register b) := by
cases a with
| mk label state tapes =>
cases label with
| none => cases h
| some label =>
have hb := Option.some.inj h
subst b
exact congrArg some (clockStatement_simulation extra register
(MachineLogCounter.program label) state tapes)
def clockInTime (extra : ExtraTape → List Bool) (register : Option Bool) (n : Nat) :
StateTransition.EvalsToInTime (TM2.step program)
(clockConfiguration extra register (initList MachineLogCounter.machine (encodeWord n)))
(some (clockConfiguration extra register
(haltList MachineLogCounter.machine (encodeWord (n.log2 + 1))))) (8 * n + 4) :=
MachineComposition.liftExecutionInTime _ _ (clockConfiguration extra register)
(clockStep extra register) (MachineLogCounter.outputsInTime n)
end UniqueGamesTheorem.Foundations.Complexity.GraphCounterModel
end OAI
|