File size: 5,997 Bytes
92416a2 | 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 | import Mathlib.Data.List.FinRange
import OAI.Computability.UniqueGames.Machines.MachineCompositionLemmas
import OAI.Computability.UniqueGames.Machines.MachineSubroutineLemmas
namespace OAI
section
namespace UniqueGamesTheorem.Reduction.MachineRhsLoad
open Turing
open UniqueGamesTheorem.Foundations.Complexity
abbrev State (k : Nat) (σ : Type) := (((Fin k → Bool) × σ) × Unit) × Option Bool
abbrev Alphabet {K : Type} (_ : K) := Bool
def rhs {k σ} (state : State k σ) : Fin k → Bool := state.1.1.1
def setRhs {k σ} (state : State k σ) (values : Fin k → Bool) : State k σ :=
(((values, state.1.1.2), state.1.2), state.2)
@[simp] theorem rhs_setRhs {k σ} (state : State k σ) (values : Fin k → Bool) :
rhs (setRhs state values) = values := rfl
@[simp] theorem setRhs_setRhs {k σ} (state : State k σ)
(first second : Fin k → Bool) : setRhs (setRhs state first) second = setRhs state second := rfl
@[simp] theorem setRhs_same {k σ} (state : State k σ) : setRhs state (rhs state) = state := rfl
def fill {k : Nat} (values initial : Fin k → Bool) (cells : List (Fin k)) : Fin k → Bool :=
cells.foldl (fun current i => Function.update current i (values i)) initial
theorem fill_apply {k : Nat} (values initial : Fin k → Bool) (cells : List (Fin k))
(i : Fin k) : fill values initial cells i = if i ∈ cells then values i else initial i := by
induction cells generalizing initial with
| nil => simp [fill]
| cons j cells ih =>
change fill values (Function.update initial j (values j)) cells i = _
rw [ih]
by_cases hi : i ∈ cells
· simp [hi]
· by_cases hij : i = j
· subst j; simp [hi]
· simp [hi, hij]
theorem fill_all {k : Nat} (values initial : Fin k → Bool) :
fill values initial (List.finRange k) = values := by
funext i
rw [fill_apply]
simp only [List.mem_finRange, ↓reduceIte]
section Program
variable {k : Nat} {K Λ σ : Type} [DecidableEq K]
def finish (exit : Option Λ) : TM2.Stmt (Alphabet (K := K)) Λ (State k σ) :=
match exit with
| none => .halt
| some label => .goto fun _ => label
def peekChain (field : Fin k → K) (exit : Option Λ) :
List (Fin k) → TM2.Stmt (Alphabet (K := K)) Λ (State k σ)
| [] => finish exit
| i :: rest =>
.peek (field i) (fun state head =>
setRhs state (Function.update (rhs state) i (head.getD false)))
(peekChain field exit rest)
def statement (field : Fin k → K) (exit : Option Λ) :
TM2.Stmt (Alphabet (K := K)) Λ (State k σ) := peekChain field exit (List.finRange k)
def readRhs (field : Fin k → K) (tapes : K → List Bool) : Fin k → Bool :=
fun i => (tapes (field i)).head?.getD false
theorem stepAux_peekChain (field : Fin k → K) (exit : Option Λ)
(cells : List (Fin k)) (state : State k σ) (tapes : K → List Bool) :
TM2.stepAux (peekChain field exit cells) state tapes =
⟨exit, setRhs state (fill (readRhs field tapes) (rhs state) cells), tapes⟩ := by
induction cells generalizing state with
| nil => cases exit <;> rfl
| cons i rest ih =>
simp only [peekChain, TM2.stepAux]
rw [ih]
rfl
theorem stepAux_statement (field : Fin k → K) (exit : Option Λ)
(state : State k σ) (tapes : K → List Bool) :
TM2.stepAux (statement field exit) state tapes =
⟨exit, setRhs state (readRhs field tapes), tapes⟩ := by
rw [statement, stepAux_peekChain, fill_all]
omit [DecidableEq K] in
theorem readRhs_of_unary (field : Fin k → K) (tapes : K → List Bool)
(values : Fin k → Bool) (suffix : Fin k → List Bool)
(encoded : ∀ i, tapes (field i) = encodeWord (if values i then 1 else 0) ++ suffix i) :
readRhs field tapes = values := by
funext i
rw [readRhs, encoded]
cases values i <;> rfl
/-- One actual transition loads every RHS register while preserving all tapes,
caller registers, and the existing optional head register. -/
theorem loadStep (field : Fin k → K) (entry : Λ) (exit : Option Λ)
(program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State k σ))
(atEntry : program entry = statement field exit)
(state : State k σ) (tapes : K → List Bool) (values : Fin k → Bool)
(suffix : Fin k → List Bool)
(encoded : ∀ i, tapes (field i) = encodeWord (if values i then 1 else 0) ++ suffix i) :
TM2.step program ⟨some entry, state, tapes⟩ =
some ⟨exit, setRhs state values, tapes⟩ := by
change some (TM2.stepAux (program entry) state tapes) = _
rw [atEntry, stepAux_statement, readRhs_of_unary field tapes values suffix encoded]
def loadInTime (field : Fin k → K) (entry : Λ) (exit : Option Λ)
(program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State k σ))
(atEntry : program entry = statement field exit)
(state : State k σ) (tapes : K → List Bool) (values : Fin k → Bool)
(suffix : Fin k → List Bool)
(encoded : ∀ i, tapes (field i) = encodeWord (if values i then 1 else 0) ++ suffix i) :
StateTransition.EvalsToInTime (TM2.step program) ⟨some entry, state, tapes⟩
(some ⟨exit, setRhs state values, tapes⟩) 1 where
steps := 1
evals_in_steps := by
change (MachineComposition.advance (TM2.step program))^[1] _ = _
simpa only [Function.iterate_one, MachineComposition.advance_some] using
loadStep field entry exit program atEntry state tapes values suffix encoded
steps_le_m := Nat.le_refl _
omit [DecidableEq K] in
theorem peekChain_pushBound (field : Fin k → K) (exit : Option Λ) (cells : List (Fin k)) :
Runtime.statementPushBound (peekChain (σ := σ) field exit cells) = 0 := by
induction cells with
| nil => cases exit <;> rfl
| cons i rest ih => exact ih
omit [DecidableEq K] in
theorem statement_pushBound (field : Fin k → K) (exit : Option Λ) :
Runtime.statementPushBound (statement (σ := σ) field exit) = 0 :=
peekChain_pushBound field exit (List.finRange k)
end Program
end UniqueGamesTheorem.Reduction.MachineRhsLoad
end
end OAI
|