Download data/lean/OAI/Computability/MinUncut/Machines/MachineLookup.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 63.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/MinUncut/Machines/MachineLookup.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/MinUncut/Machines/MachineLookup.lean
-
curl -L -o MachineLookup.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/MinUncut/Machines/MachineLookup.lean
63.5 kB
import Mathlib
import OAI.Computability.MinUncut.Machines.Input
namespace OAI
section
namespace MinUncutGames.Foundations.Complexity.MachineLookup
open Turing
open MachineComposition
variable {K σ : Type} [DecidableEq K]
theorem guard_step_succ (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination)
(base : K → List Bool) (i : Nat) (indexSuffix input output : List Bool)
(ambient : σ) (register : Option Bool) :
TM2.step (program index source destination)
⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord (i + 1) ++ indexSuffix) input output⟩ =
some ⟨some .skip, (ambient, none), tapes index source destination base
(encodeWord i ++ indexSuffix) input output⟩ := by
change some (TM2.stepAux (program index source destination .guard) _ _) = _
simp [program, MachineUnaryCounter.guard, TM2.stepAux,
tapes_index, his, hid, encodeWord, List.replicate_succ, update_index]
theorem guard_step_zero (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination)
(base : K → List Bool) (indexSuffix input output : List Bool)
(ambient : σ) (register : Option Bool) :
TM2.step (program index source destination)
⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord 0 ++ indexSuffix) input output⟩ =
some ⟨some .select, (ambient, none), tapes index source destination base
(encodeWord 0 ++ indexSuffix) input output⟩ := by
change some (TM2.stepAux (program index source destination .guard) _ _) = _
simp [program, MachineUnaryCounter.guard, TM2.stepAux,
tapes_index, his, hid, encodeWord]
theorem select_step_nonempty (index source destination : K)
(hsd : source ≠ destination) (base : K → List Bool)
(counter input output : List Bool) (hinput : input ≠ [])
(ambient : σ) (register : Option Bool) :
TM2.step (program index source destination)
⟨some .select, (ambient, register),
tapes index source destination base counter input output⟩ =
some ⟨some .copy, (ambient, input.head?),
tapes index source destination base counter input (false :: output)⟩ := by
change some (TM2.stepAux (program index source destination .select) _ _) = _
cases input with
| nil => exact (hinput rfl).elim
| cons head tail =>
simp [program, select, Hastad.SourceMachine.fieldStart, TM2.stepAux,
tapes_source, hsd, update_destination]
theorem select_step_empty (index source destination : K)
(hsd : source ≠ destination) (base : K → List Bool)
(counter output : List Bool) (ambient : σ) (register : Option Bool) :
TM2.step (program index source destination)
⟨some .select, (ambient, register),
tapes index source destination base counter [] output⟩ =
some ⟨some .rejected, (ambient, none),
tapes index source destination base counter [] output⟩ := by
change some (TM2.stepAux (program index source destination .select) _ _) = _
simp [program, select, TM2.stepAux, tapes_source, hsd]
theorem copyTrace (index source destination : K)
(hsd : source ≠ destination) (base : K → List Bool)
(counter : List Bool) (n : Nat) (suffix output : List Bool)
(ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[n + 1]
(some ⟨some .copy, (ambient, register), tapes index source destination base
counter (encodeWord n ++ suffix) (false :: output)⟩) =
some ⟨some .accepted, (ambient, none), tapes index source destination base
counter suffix (encodeWord n ++ output)⟩ := by
have h := Hastad.SourceMachine.fieldLoopTrace source destination hsd
Label.copy (some Label.accepted) (program index source destination) rfl
(Function.update base index counter) n suffix (false :: output) ambient register
simpa only [Hastad.SourceMachine.fieldTapes, tapes, encodeWord,
List.append_assoc, List.singleton_append] using h
theorem selectTrace (index source destination : K)
(hsd : source ≠ destination) (base : K → List Bool)
(counter : List Bool) (n : Nat) (suffix output : List Bool)
(ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[n + 2]
(some ⟨some .select, (ambient, register), tapes index source destination base
counter (encodeWord n ++ suffix) output⟩) =
some ⟨some .accepted, (ambient, none), tapes index source destination base
counter suffix (encodeWord n ++ output)⟩ := by
rw [show n + 2 = (n + 1) + 1 by omega, Function.iterate_succ_apply]
simp only [advance_some]
rw [select_step_nonempty index source destination hsd base counter
(encodeWord n ++ suffix) output (by simp [encodeWord]) ambient register]
exact copyTrace index source destination hsd base counter n suffix output ambient _
theorem skipCycleTrace (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (i n : Nat) (indexSuffix suffix output : List Bool)
(ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[n + 2]
(some ⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord (i + 1) ++ indexSuffix) (encodeWord n ++ suffix) output⟩) =
some ⟨some .guard, (ambient, none), tapes index source destination base
(encodeWord i ++ indexSuffix) suffix output⟩ := by
rw [show n + 2 = (n + 1) + 1 by omega, Function.iterate_succ_apply]
simp only [advance_some]
rw [guard_step_succ index source destination his hid]
have h := discardTrace source Label.skip Label.guard
(program index source destination) rfl
(tapes index source destination base (encodeWord i ++ indexSuffix)
(encodeWord n ++ suffix) output) n suffix (by simp [hsd]) ambient none
simpa only [update_source index source destination hsd] using h
theorem emptyCycleTrace (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (i : Nat) (indexSuffix output : List Bool)
(ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[2]
(some ⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord (i + 1) ++ indexSuffix) [] output⟩) =
some ⟨some .guard, (ambient, none), tapes index source destination base
(encodeWord i ++ indexSuffix) [] output⟩ := by
rw [show 2 = 1 + 1 from rfl, Function.iterate_succ_apply]
simp only [Function.iterate_one, advance_some]
rw [guard_step_succ index source destination his hid]
exact discard_empty_step source Label.skip Label.guard (program index source destination)
rfl (tapes index source destination base (encodeWord i ++ indexSuffix) [] output)
(by simp [hsd]) ambient none
theorem successPrefixTrace (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (prior : List Nat) (value : Nat)
(indexSuffix suffix output : List Bool) (ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[
(encodeWords prior).length + prior.length + value + 3]
(some ⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord prior.length ++ indexSuffix)
(encodeWords prior ++ (encodeWord value ++ suffix)) output⟩) =
some ⟨some .accepted, (ambient, none), tapes index source destination base
(encodeWord 0 ++ indexSuffix) suffix (encodeWord value ++ output)⟩ := by
induction prior generalizing register with
| nil =>
simp only [encodeWords, List.length_nil, Nat.zero_add, List.nil_append]
rw [show value + 3 = (value + 2) + 1 by omega, Function.iterate_succ_apply]
simp only [advance_some]
rw [guard_step_zero index source destination his hid]
exact selectTrace index source destination hsd base _ value suffix output ambient none
| cons n prior ih =>
simp only [encodeWords, List.length_cons, List.length_append, encodeWord_length]
rw [show n + 1 + (encodeWords prior).length + (prior.length + 1) + value + 3 =
((encodeWords prior).length + prior.length + value + 3) + (n + 2) by omega,
Function.iterate_add_apply]
rw [List.append_assoc,
skipCycleTrace index source destination his hid hsd base prior.length n]
exact ih none
theorem lookupTrace_some (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (values : List Nat) (i value : Nat)
(selected : values[i]? = some value)
(indexSuffix suffix output : List Bool) (ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[MachineLookupSpec.steps values i]
(some ⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord i ++ indexSuffix) (encodeWords values ++ suffix) output⟩) =
some ⟨some .accepted, (ambient, none), tapes index source destination base
(encodeWord 0 ++ indexSuffix) (encodeWords (values.drop (i + 1)) ++ suffix)
(encodeWord value ++ output)⟩ := by
have hi := (List.getElem?_eq_some_iff.mp selected).1
have hlength : (values.take i).length = i := by
simp [List.length_take, Nat.min_eq_left (Nat.le_of_lt hi)]
have hsource : encodeWords (values.take i) ++
(encodeWord value ++ (encodeWords (values.drop (i + 1)) ++ suffix)) =
encodeWords values ++ suffix := by
rw [MachineLookupSpec.encoded_selected_split values i value selected]
simp only [List.append_assoc]
have htime : MachineLookupSpec.steps values i =
(encodeWords (values.take i)).length + i + value + 3 := by
rw [MachineLookupSpec.steps_eq_scannedBits_of_some values i value selected,
MachineLookupSpec.scannedBits_of_some values i value selected]
omega
have h := successPrefixTrace index source destination his hid hsd base (values.take i)
value indexSuffix (encodeWords (values.drop (i + 1)) ++ suffix) output ambient register
rw [hlength, hsource] at h
simpa only [htime] using h
theorem emptyTrace (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (i : Nat) (indexSuffix output : List Bool)
(ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[2 * i + 2]
(some ⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord i ++ indexSuffix) [] output⟩) =
some ⟨some .rejected, (ambient, none), tapes index source destination base
(encodeWord 0 ++ indexSuffix) [] output⟩ := by
induction i generalizing register with
| zero =>
simp only [Nat.mul_zero, Nat.zero_add]
rw [show 2 = 1 + 1 from rfl, Function.iterate_succ_apply]
simp only [Function.iterate_one, advance_some]
rw [guard_step_zero index source destination his hid]
exact select_step_empty index source destination hsd base _ output ambient none
| succ i ih =>
rw [show 2 * (i + 1) + 2 = (2 * i + 2) + 2 by omega,
Function.iterate_add_apply, emptyCycleTrace index source destination his hid hsd]
exact ih none
theorem lookupTrace_invalid (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (values : List Nat) (i : Nat) (invalid : values.length ≤ i)
(indexSuffix output : List Bool) (ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[MachineLookupSpec.steps values i]
(some ⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord i ++ indexSuffix) (encodeWords values) output⟩) =
some ⟨some .rejected, (ambient, none), tapes index source destination base
(encodeWord 0 ++ indexSuffix) [] output⟩ := by
induction values generalizing i register with
| nil =>
simpa only [MachineLookupSpec.steps, encodeWords] using
emptyTrace index source destination his hid hsd base i indexSuffix output ambient register
| cons n values ih =>
cases i with
| zero => simp at invalid
| succ i =>
simp only [MachineLookupSpec.steps, encodeWords]
rw [Nat.add_comm (n + 2), Function.iterate_add_apply,
skipCycleTrace index source destination his hid hsd]
exact ih i (by simpa using invalid) none
def resultLabel (values : List Nat) (i : Nat) : Label :=
match values[i]? with
| some _ => .accepted
| none => .rejected
def resultOutput (values : List Nat) (i : Nat) (output : List Bool) : List Bool :=
match values[i]? with
| some value => encodeWord value ++ output
| none => output
theorem lookupTrace (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (values : List Nat) (i : Nat)
(indexSuffix output : List Bool) (ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[MachineLookupSpec.steps values i]
(some ⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord i ++ indexSuffix) (encodeWords values) output⟩) =
some ⟨some (resultLabel values i), (ambient, none), tapes index source destination base
(encodeWord 0 ++ indexSuffix) (encodeWords (values.drop (i + 1)))
(resultOutput values i output)⟩ := by
cases selected : values[i]? with
| some value =>
simpa only [List.append_nil, resultLabel, resultOutput, selected] using
lookupTrace_some index source destination his hid hsd base values i value selected
indexSuffix [] output ambient register
| none =>
have invalid : values.length ≤ i := List.getElem?_eq_none_iff.mp selected
have hdrop : values.drop (i + 1) = [] := List.drop_eq_nil_of_le (by omega)
simpa only [resultLabel, resultOutput, selected, hdrop, encodeWords] using
lookupTrace_invalid index source destination his hid hsd base values i invalid
indexSuffix output ambient register
def lookupInTime (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (values : List Nat) (i : Nat)
(indexSuffix output : List Bool) (ambient : σ) (register : Option Bool) :
StateTransition.EvalsToInTime (TM2.step (program index source destination))
⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord i ++ indexSuffix) (encodeWords values) output⟩
(some ⟨some (resultLabel values i), (ambient, none), tapes index source destination base
(encodeWord 0 ++ indexSuffix) (encodeWords (values.drop (i + 1)))
(resultOutput values i output)⟩)
((encodeWords values).length + 2 * (encodeWord i).length) where
steps := MachineLookupSpec.steps values i
evals_in_steps := lookupTrace index source destination his hid hsd base values i
indexSuffix output ambient register
steps_le_m := MachineLookupSpec.steps_le_input_encoding_size values i
theorem lookupHaltTrace (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (values : List Nat) (i : Nat)
(indexSuffix output : List Bool) (ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[MachineLookupSpec.steps values i + 1]
(some ⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord i ++ indexSuffix) (encodeWords values) output⟩) =
some ⟨none, (ambient, none), tapes index source destination base
(encodeWord 0 ++ indexSuffix) (encodeWords (values.drop (i + 1)))
(resultOutput values i output)⟩ := by
rw [Function.iterate_succ_apply', lookupTrace index source destination his hid hsd]
simp only [advance_some]
cases selected : values[i]? <;> simp [resultLabel, selected, TM2.step, program, TM2.stepAux]
noncomputable def timePolynomial : Polynomial Nat := Polynomial.C 2 * Polynomial.X + 1
theorem timePolynomial_bounds (values : List Nat) (i : Nat) :
MachineLookupSpec.steps values i + 1 ≤
timePolynomial.eval ((encodeWords values).length + (encodeWord i).length) := by
have h := MachineLookupSpec.steps_le_input_encoding_size values i
simp only [timePolynomial, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C,
Polynomial.eval_X, Polynomial.eval_one]
omega
def machineInTime (base : Fin 3 → List Bool) (values : List Nat) (i : Nat)
(indexSuffix output : List Bool) (register : Option Bool) :
StateTransition.EvalsToInTime machine.step
⟨some .guard, ((), register), tapes (K := Fin 3) 0 1 2 base
(encodeWord i ++ indexSuffix) (encodeWords values) output⟩
(some ⟨none, ((), none), tapes (K := Fin 3) 0 1 2 base
(encodeWord 0 ++ indexSuffix) (encodeWords (values.drop (i + 1)))
(resultOutput values i output)⟩)
(timePolynomial.eval ((encodeWords values).length + (encodeWord i).length)) where
steps := MachineLookupSpec.steps values i + 1
evals_in_steps := lookupHaltTrace (0 : Fin 3) 1 2 (by decide) (by decide) (by decide)
base values i indexSuffix output () register
steps_le_m := timePolynomial_bounds values i
end MinUncutGames.Foundations.Complexity.MachineLookup
end
section
namespace MinUncutGames.Foundations.Complexity.MachineFixedBlockMap
open Turing
abbrev Buffer (N : Nat) := Fin N → Bool
def emptyBuffer (N : Nat) : Buffer N := fun _ => false
section Chains
variable {K Λ σ : Type} {N : Nat}
def readSlots (src : K) : List (Fin N) →
TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N) →
TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N)
| [], next => next
| i :: slots, next =>
.pop src (fun state head =>
(state.1, Function.update state.2 i (head.getD false)))
(readSlots src slots next)
def fill (slots : List (Fin N)) (bits buffer : Buffer N) : Buffer N :=
slots.foldl (fun buffer i => Function.update buffer i (bits i)) buffer
theorem fill_apply (slots : List (Fin N)) (bits buffer : Buffer N) (i : Fin N) :
fill slots bits buffer i = if i ∈ slots then bits i else buffer i := by
induction slots generalizing buffer with
| nil => simp [fill]
| cons j slots ih =>
change fill slots bits (Function.update buffer j (bits j)) i = _
rw [ih]
by_cases hm : i ∈ slots
· simp [hm]
· by_cases he : i = j <;> simp [hm, he]
@[simp] theorem fill_all (bits buffer : Buffer N) :
fill (List.ofFn id) bits buffer = bits := by
funext i
simp [fill_apply, List.mem_ofFn]
variable [DecidableEq K]
theorem stepAux_readSlots (src : K) (slots : List (Fin N))
(next : TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N))
(ambient : σ) (bits buffer : Buffer N) (tapes : K → List Bool)
(suffix : List Bool) :
TM2.stepAux (readSlots src slots next) (ambient, buffer)
(Function.update tapes src (slots.map bits ++ suffix)) =
TM2.stepAux next (ambient, fill slots bits buffer)
(Function.update tapes src suffix) := by
induction slots generalizing buffer tapes with
| nil => simp [readSlots, fill]
| cons i slots ih =>
simpa only [readSlots, List.map_cons, List.cons_append, TM2.stepAux,
Function.update_self, List.head?_cons, Option.getD_some, List.tail_cons,
Function.update_idem, fill, List.foldl_cons] using
ih (Function.update buffer i (bits i)) tapes
theorem stepAux_readAll (src : K)
(next : TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N))
(state : σ × Buffer N) (bits : Buffer N) (tapes : K → List Bool)
(suffix : List Bool) (hinput : tapes src = List.ofFn bits ++ suffix) :
TM2.stepAux (readSlots src (List.ofFn id) next) state tapes =
TM2.stepAux next (state.1, bits) (Function.update tapes src suffix) := by
have h := stepAux_readSlots src (List.ofFn id) next state.1 bits state.2 tapes suffix
have hin : Function.update tapes src ((List.ofFn id).map bits ++ suffix) = tapes := by
simpa only [List.map_ofFn, Function.comp_id, ← hinput] using
Function.update_eq_self src tapes
rw [hin, fill_all] at h
exact h
omit [DecidableEq K] in
theorem statementPushBound_readSlots (src : K) (slots : List (Fin N))
(next : TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N)) :
Runtime.statementPushBound (readSlots src slots next) =
Runtime.statementPushBound next := by
induction slots with
| nil => rfl
| cons i slots ih => exact ih
def writeSlots {M : Nat} (dst : K) (emit : σ → Buffer M) : List (Fin M) →
TM2.Stmt (fun _ : K => Bool) Λ σ → TM2.Stmt (fun _ : K => Bool) Λ σ
| [], next => next
| i :: slots, next => .push dst (fun state => emit state i) (writeSlots dst emit slots next)
theorem stepAux_writeSlots {M : Nat} (dst : K) (emit : σ → Buffer M)
(slots : List (Fin M)) (next : TM2.Stmt (fun _ : K => Bool) Λ σ)
(state : σ) (tapes : K → List Bool) :
TM2.stepAux (writeSlots dst emit slots next) state tapes =
TM2.stepAux next state
(Function.update tapes dst ((slots.map (emit state)).reverse ++ tapes dst)) := by
induction slots generalizing tapes with
| nil => simp [writeSlots]
| cons i slots ih =>
simp only [writeSlots, TM2.stepAux]
rw [ih]
simp only [Function.update_self, Function.update_idem, List.map_cons,
List.reverse_cons, List.append_assoc, List.singleton_append]
omit [DecidableEq K] in
theorem statementPushBound_writeSlots {M : Nat} (dst : K) (emit : σ → Buffer M)
(slots : List (Fin M)) (next : TM2.Stmt (fun _ : K => Bool) Λ σ) :
Runtime.statementPushBound (writeSlots dst emit slots next) =
slots.length + Runtime.statementPushBound next := by
induction slots with
| nil => simp [writeSlots]
| cons i slots ih =>
simp only [writeSlots, Runtime.statementPushBound, ih, List.length_cons]
omega
end Chains
section Block
variable {K Λ σ : Type} {N M : Nat}
def blockStmt (src dst : K) (F : Buffer N → Buffer M)
(next : TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N)) :
TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N) :=
readSlots src (List.ofFn id)
(writeSlots dst (fun state => F state.2) (List.ofFn id).reverse
(.load (fun state => (state.1, emptyBuffer N)) next))
def finishAt (exit : Option Λ) : TM2.Stmt (fun _ : K => Bool) Λ σ :=
match exit with
| none => .halt
| some label => .goto fun _ => label
def blockMapAt (src dst : K) (F : Buffer N → Buffer M) (exit : Option Λ) :
TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N) :=
blockStmt src dst F (finishAt exit)
theorem statementPushBound_blockStmt (src dst : K) (F : Buffer N → Buffer M)
(next : TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N)) :
Runtime.statementPushBound (blockStmt src dst F next) =
M + Runtime.statementPushBound next := by
simp only [blockStmt, statementPushBound_readSlots, statementPushBound_writeSlots,
Runtime.statementPushBound, List.length_reverse, List.length_ofFn]
theorem statementPushBound_blockMapAt (src dst : K) (F : Buffer N → Buffer M)
(exit : Option Λ) :
Runtime.statementPushBound (blockMapAt (σ := σ) src dst F exit) = M := by
cases exit <;> simp [blockMapAt, statementPushBound_blockStmt, finishAt,
Runtime.statementPushBound]
variable [DecidableEq K]
theorem stepAux_blockStmt (src dst : K) (F : Buffer N → Buffer M)
(next : TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N))
(hne : src ≠ dst) (bits : Buffer N) (suffix : List Bool)
(state : σ × Buffer N) (tapes : K → List Bool)
(hinput : tapes src = List.ofFn bits ++ suffix) :
TM2.stepAux (blockStmt src dst F next) state tapes =
TM2.stepAux next (state.1, emptyBuffer N)
(Function.update (Function.update tapes src suffix) dst
(List.ofFn (F bits) ++ tapes dst)) := by
unfold blockStmt
rw [stepAux_readAll src _ state bits tapes suffix hinput, stepAux_writeSlots]
simp only [List.map_reverse, List.map_ofFn, Function.comp_id, List.reverse_reverse,
Function.update_of_ne (Ne.symm hne), TM2.stepAux]
theorem stepAux_blockMapAt (src dst : K) (F : Buffer N → Buffer M)
(exit : Option Λ) (hne : src ≠ dst) (bits : Buffer N) (suffix : List Bool)
(state : σ × Buffer N) (tapes : K → List Bool)
(hinput : tapes src = List.ofFn bits ++ suffix) :
TM2.stepAux (blockMapAt src dst F exit) state tapes =
{ l := exit, var := (state.1, emptyBuffer N),
stk := Function.update (Function.update tapes src suffix) dst
(List.ofFn (F bits) ++ tapes dst) } := by
rw [blockMapAt, stepAux_blockStmt src dst F _ hne bits suffix state tapes hinput]
cases exit <;> rfl
theorem step_blockMapAt (src dst : K) (F : Buffer N → Buffer M)
(exit : Option Λ)
(program : Λ → TM2.Stmt (fun _ : K => Bool) Λ (σ × Buffer N))
(label : Λ) (hprogram : program label = blockMapAt src dst F exit)
(hne : src ≠ dst) (bits : Buffer N) (suffix : List Bool)
(state : σ × Buffer N) (tapes : K → List Bool)
(hinput : tapes src = List.ofFn bits ++ suffix) :
TM2.step program { l := some label, var := state, stk := tapes } =
some { l := exit
var := (state.1, emptyBuffer N)
stk := Function.update (Function.update tapes src suffix) dst
(List.ofFn (F bits) ++ tapes dst) } := by
simp only [TM2.step, hprogram,
stepAux_blockMapAt src dst F exit hne bits suffix state tapes hinput]
end Block
def machine {N M : Nat} (F : Buffer N → Buffer M) : FinTM2 where
K := Bool
k₀ := false
k₁ := true
Γ _ := Bool
Λ := Unit
main := ()
σ := Unit × Buffer N
initialState := ((), emptyBuffer N)
m _ := blockMapAt false true F none
theorem machine_statementPushBound {N M : Nat} (F : Buffer N → Buffer M) :
Runtime.statementPushBound ((machine F).m ()) = M :=
statementPushBound_blockMapAt false true F none
end MinUncutGames.Foundations.Complexity.MachineFixedBlockMap
end
section
namespace MinUncutGames.Foundations.PCP.AlphabetTable.Lookup
open Turing
open MinUncutGames.Foundations.Complexity
open MachineComposition GenericGraphTables
variable {K Λ σ : Type} [DecidableEq K]
abbrev Alphabet (_ : K) := Bool
def skipBits (source : K) : Nat →
TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool) →
TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool)
| 0, next => .load (fun state => (state.1, none)) next
| count + 1, next =>
let rest := skipBits source count next
.pop source (fun state head => (state.1, head))
(.branch (fun state => state.2.getD false)
(.pop source (fun state _ => (state.1, none)) rest)
(.load (fun state => (state.1, none)) rest))
theorem stepAux_skipBits (source : K) (bits : List Bool)
(next : TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
(base : K → List Bool) (suffix : List Bool) (ambient : σ) (register : Option Bool) :
TM2.stepAux (skipBits source bits.length next) (ambient, register)
(Function.update base source (encodeWords (bits.map bitWord) ++ suffix)) =
TM2.stepAux next (ambient, none) (Function.update base source suffix) := by
induction bits generalizing register with
| nil => simp [skipBits, encodeWords, TM2.stepAux]
| cons bit bits ih =>
cases bit <;>
simpa only [List.length_cons, skipBits, List.map_cons, bitWord, Bool.false_eq_true,
ite_false, ite_true, encodeWords, encodeWord, List.replicate_zero,
List.replicate_succ, List.nil_append, List.cons_append, List.singleton_append,
TM2.stepAux, Function.update_self, List.head?_cons, List.tail_cons,
Option.getD_some, Bool.cond_false, Bool.cond_true, Function.update_idem] using
ih none
theorem stepAux_skipBits_fromTapes (source : K) (bits : List Bool)
(next : TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
(base : K → List Bool) (suffix : List Bool)
(hinput : base source = encodeWords (bits.map bitWord) ++ suffix)
(ambient : σ) (register : Option Bool) :
TM2.stepAux (skipBits source bits.length next) (ambient, register) base =
TM2.stepAux next (ambient, none) (Function.update base source suffix) := by
have h := stepAux_skipBits source bits next base suffix ambient register
have hbase : Function.update base source (encodeWords (bits.map bitWord) ++ suffix) =
base := by rw [← hinput]; exact Function.update_eq_self source base
rw [hbase] at h
exact h
omit [DecidableEq K] in
theorem skipBits_pushBound (source : K) (count : Nat)
(next : TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool)) :
Runtime.statementPushBound (skipBits source count next) =
Runtime.statementPushBound next := by
induction count with
| zero => rfl
| succ count ih => simp only [skipBits, Runtime.statementPushBound, ih, max_self]
inductive Label
| guard | skipTail | skipReverse | skipPredicate | select | copy
deriving DecidableEq
protected abbrev Label.enumList : List Label := [.guard, .skipTail, .skipReverse, .skipPredicate,
.select, .copy]
protected theorem Label.enumList_getElem?_ctorIdx_eq (x : Label) :
Label.enumList[x.ctorIdx]? = some x := by
cases x <;> rfl
protected theorem Label.enumList_nodup : Label.enumList.Nodup := by decide
instance : Fintype Label where
elems := ⟨Label.enumList, Label.enumList_nodup⟩
complete x := by cases x <;> decide
def statement (q : Nat) (counter source destination : K) (labels : Label → Λ)
(exit : Option Λ) : Label → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool)
| .guard => MachineUnaryCounter.guard counter (labels .skipTail) (labels .select)
| .skipTail => MachineLookup.discard source (labels .skipTail) (labels .skipReverse)
| .skipReverse => MachineLookup.discard source (labels .skipReverse) (labels .skipPredicate)
| .skipPredicate => skipBits source (q * q) (.goto fun _ => labels .guard)
| .select => Hastad.SourceMachine.fieldStart destination (labels .copy)
| .copy => Hastad.SourceMachine.fieldLoop source destination (labels .copy) exit
def program (q : Nat) (counter source destination : K) :
Label → TM2.Stmt (Alphabet (K := K)) Label (σ × Option Bool) :=
statement q counter source destination id none
def rowBits {q n m : Nat} (row : DartRow q n m) : List Bool := encodeWords (rowWords row)
theorem rowBits_eq {q n m : Nat} (row : DartRow q n m) :
rowBits row = encodeWord row.tail.val ++
(encodeWord row.reverseIndex.val ++ encodeWords (relationWords row.relation)) := by
simp [rowBits, rowWords, encodeWords]
def rowsBits {q n m : Nat} (rows : List (DartRow q n m)) : List Bool :=
encodeWords (rows.flatMap rowWords)
@[simp] theorem rowsBits_nil {q n m : Nat} : rowsBits ([] : List (DartRow q n m)) = [] := rfl
@[simp] theorem rowsBits_cons {q n m : Nat} (row : DartRow q n m)
(rows : List (DartRow q n m)) : rowsBits (row :: rows) = rowBits row ++ rowsBits rows := by
simp only [rowsBits, List.flatMap_cons, encodeWords_append, rowBits]
def skipCost {q n m : Nat} (row : DartRow q n m) : Nat :=
row.tail.val + row.reverseIndex.val + 4
def prefixCost {q n m : Nat} (rows : List (DartRow q n m)) : Nat :=
(rows.map skipCost).sum
def lookupCost {q n m : Nat} (prior : List (DartRow q n m)) (row : DartRow q n m) : Nat :=
prefixCost prior + row.tail.val + 3
section Ambient
variable {q n m : Nat} (counter source destination : K) (labels : Label → Λ)
(exit : Option Λ)
(P : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
(atStatement : ∀ label, P (labels label) = statement q counter source destination labels exit label)
include atStatement
theorem skipRowTrace (base : K → List Bool) (row : DartRow q n m) (suffix : List Bool)
(ambient : σ) (register : Option Bool) :
(advance (TM2.step P))^[row.tail.val + row.reverseIndex.val + 3]
(some ⟨some (labels .skipTail), (ambient, register),
Function.update base source (rowBits row ++ suffix)⟩) =
some ⟨some (labels .guard), (ambient, none), Function.update base source suffix⟩ := by
have ht := MachineLookup.discardTrace_update source (labels .skipTail) (labels .skipReverse)
P (atStatement .skipTail) base row.tail.val
(encodeWord row.reverseIndex.val ++ (encodeWords (relationWords row.relation) ++ suffix))
ambient register
have hr := MachineLookup.discardTrace_update source (labels .skipReverse) (labels .skipPredicate)
P (atStatement .skipReverse) base row.reverseIndex.val
(encodeWords (relationWords row.relation) ++ suffix) ambient none
have hp : TM2.step P
⟨some (labels .skipPredicate), (ambient, none), Function.update base source
(encodeWords (relationWords row.relation) ++ suffix)⟩ =
some ⟨some (labels .guard), (ambient, none), Function.update base source suffix⟩ := by
change some (TM2.stepAux (P (labels .skipPredicate)) _ _) = _
rw [atStatement .skipPredicate]
have h := congrArg some (stepAux_skipBits source row.relation.toList
(.goto fun _ => labels .guard) base suffix ambient none)
simpa only [statement, Vector.length_toList, relationWords, TM2.stepAux] using h
rw [rowBits_eq]
simp only [List.append_assoc]
rw [show row.tail.val + row.reverseIndex.val + 3 =
1 + ((row.reverseIndex.val + 1) + (row.tail.val + 1)) by omega,
Function.iterate_add_apply, Function.iterate_add_apply, ht, hr,
Function.iterate_one, advance_some, hp]
theorem skipRowTrace_fromTapes (base : K → List Bool) (row : DartRow q n m)
(suffix : List Bool) (hinput : base source = rowBits row ++ suffix)
(ambient : σ) (register : Option Bool) :
(advance (TM2.step P))^[row.tail.val + row.reverseIndex.val + 3]
(some ⟨some (labels .skipTail), (ambient, register), base⟩) =
some ⟨some (labels .guard), (ambient, none), Function.update base source suffix⟩ := by
have h := skipRowTrace counter source destination labels exit P atStatement
base row suffix ambient register
have hb : Function.update base source (rowBits row ++ suffix) = base := by
rw [← hinput]
exact Function.update_eq_self source base
rw [hb] at h
exact h
theorem selectTrace (hsd : source ≠ destination) (base : K → List Bool)
(row : DartRow q n m) (suffix : List Bool)
(hinput : base source = rowBits row ++ suffix) (ambient : σ) (register : Option Bool) :
(advance (TM2.step P))^[row.tail.val + 2]
(some ⟨some (labels .select), (ambient, register), base⟩) =
some ⟨exit, (ambient, none), Hastad.SourceMachine.fieldTapes source destination base
(encodeWord row.reverseIndex.val ++ (encodeWords (relationWords row.relation) ++ suffix))
(encodeWord row.tail.val ++ base destination)⟩ := by
let ht := Hastad.SourceMachine.fieldInTime source destination hsd
(labels .select) (labels .copy) exit P (atStatement .select) (atStatement .copy)
base row.tail.val
(encodeWord row.reverseIndex.val ++ (encodeWords (relationWords row.relation) ++ suffix))
(by simpa only [rowBits_eq, List.append_assoc] using hinput) ambient register
have hsteps : ht.steps = row.tail.val + 2 := rfl
have htrace := ht.evals_in_steps
rw [hsteps] at htrace
exact htrace
theorem lookupTailTrace
(hcs : counter ≠ source) (hcd : counter ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (prior : List (DartRow q n m)) (row : DartRow q n m)
(counterSuffix suffix output : List Bool) (ambient : σ) (register : Option Bool) :
(advance (TM2.step P))^[lookupCost prior row]
(some ⟨some (labels .guard), (ambient, register),
MachineLookup.tapes counter source destination base
(encodeWord prior.length ++ counterSuffix)
(rowsBits prior ++ (rowBits row ++ suffix)) output⟩) =
some ⟨exit, (ambient, none),
MachineLookup.tapes counter source destination base
(encodeWord 0 ++ counterSuffix)
(encodeWord row.reverseIndex.val ++ (encodeWords (relationWords row.relation) ++ suffix))
(encodeWord row.tail.val ++ output)⟩ := by
induction prior generalizing register with
| nil =>
simp only [lookupCost, prefixCost, List.map_nil, List.sum_nil, Nat.zero_add,
List.length_nil, rowsBits_nil, List.nil_append]
rw [show row.tail.val + 3 = (row.tail.val + 2) + 1 by omega,
Function.iterate_succ_apply]
have hg := MachineUnaryCounter.guardStep_zero counter (labels .guard)
(labels .skipTail) (labels .select) P (atStatement .guard)
(MachineLookup.tapes counter source destination base
(encodeWord 0 ++ counterSuffix) (rowBits row ++ suffix) output)
counterSuffix ambient register
have hcounter : MachineUnaryCounter.counterTapes counter
(MachineLookup.tapes counter source destination base
(encodeWord 0 ++ counterSuffix) (rowBits row ++ suffix) output) 0 counterSuffix =
MachineLookup.tapes counter source destination base
(encodeWord 0 ++ counterSuffix) (rowBits row ++ suffix) output := by
simp only [MachineUnaryCounter.counterTapes, MachineLookup.update_index _ _ _ hcs hcd]
rw [hcounter] at hg
simp only [advance_some]
rw [hg]
have hs := selectTrace counter source destination labels exit P atStatement hsd
(MachineLookup.tapes counter source destination base
(encodeWord 0 ++ counterSuffix) (rowBits row ++ suffix) output)
row suffix (by simp [hsd]) ambient none
simpa only [MachineLookup.tapes_destination,
MachineLookup.fieldTapes_eq _ _ _ hsd] using hs
| cons first prior ih =>
simp only [lookupCost, prefixCost, List.map_cons, List.sum_cons, List.length_cons,
rowsBits_cons, List.append_assoc]
rw [show skipCost first + (prior.map skipCost).sum + row.tail.val + 3 =
((prior.map skipCost).sum + row.tail.val + 3) +
(first.tail.val + first.reverseIndex.val + 3) + 1 by simp only [skipCost]; omega,
Function.iterate_succ_apply]
have hg := MachineUnaryCounter.guardStep_succ counter (labels .guard)
(labels .skipTail) (labels .select) P (atStatement .guard)
(MachineLookup.tapes counter source destination base
(encodeWord prior.length ++ counterSuffix)
(rowBits first ++ (rowsBits prior ++ (rowBits row ++ suffix))) output)
prior.length counterSuffix ambient register
simp only [MachineUnaryCounter.counterTapes,
MachineLookup.update_index _ _ _ hcs hcd] at hg
simp only [advance_some]
rw [hg, Function.iterate_add_apply]
have hs := skipRowTrace_fromTapes counter source destination labels exit P atStatement
(MachineLookup.tapes counter source destination base
(encodeWord prior.length ++ counterSuffix)
(rowBits first ++ (rowsBits prior ++ (rowBits row ++ suffix))) output)
first (rowsBits prior ++ (rowBits row ++ suffix)) (by simp [hsd]) ambient none
rw [hs]
simp only [MachineLookup.update_source _ _ _ hsd]
exact ih none
end Ambient
theorem lookupCost_le {q n m : Nat} (prior : List (DartRow q n m)) (row : DartRow q n m) :
lookupCost prior row ≤ (rowsBits prior ++ rowBits row).length +
2 * (encodeWord prior.length).length + 1 := by
have hp : prefixCost prior ≤ (rowsBits prior).length + 2 * prior.length := by
induction prior with
| nil => simp [prefixCost]
| cons first prior ih =>
have hb : skipCost first ≤ (rowBits first).length + 2 := by
simp only [skipCost, rowBits_eq, List.length_append, encodeWord_length]
omega
simp only [prefixCost, List.map_cons, List.sum_cons, rowsBits_cons,
List.length_append, List.length_cons] at *
omega
have hr : row.tail.val + 1 ≤ (rowBits row).length := by
simp only [rowBits_eq, List.length_append, encodeWord_length]
omega
simp only [lookupCost, List.length_append, encodeWord_length]
omega
def lookupTailInTime {q n m : Nat}
(counter source destination : K) (labels : Label → Λ) (exit : Option Λ)
(P : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
(atStatement : ∀ label, P (labels label) = statement q counter source destination labels exit label)
(hcs : counter ≠ source) (hcd : counter ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (prior : List (DartRow q n m)) (row : DartRow q n m)
(counterSuffix suffix output : List Bool) (ambient : σ) (register : Option Bool) :
StateTransition.EvalsToInTime (TM2.step P)
⟨some (labels .guard), (ambient, register),
MachineLookup.tapes counter source destination base
(encodeWord prior.length ++ counterSuffix)
(rowsBits prior ++ (rowBits row ++ suffix)) output⟩
(some ⟨exit, (ambient, none),
MachineLookup.tapes counter source destination base
(encodeWord 0 ++ counterSuffix)
(encodeWord row.reverseIndex.val ++ (encodeWords (relationWords row.relation) ++ suffix))
(encodeWord row.tail.val ++ output)⟩)
((rowsBits prior ++ rowBits row).length + 2 * (encodeWord prior.length).length + 1) where
steps := lookupCost prior row
evals_in_steps := lookupTailTrace counter source destination labels exit P atStatement
hcs hcd hsd base prior row counterSuffix suffix output ambient register
steps_le_m := lookupCost_le prior row
theorem tableTailTrace {q : Nat}
(counter source destination : K) (labels : Label → Λ) (exit : Option Λ)
(P : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
(atStatement : ∀ label, P (labels label) = statement q counter source destination labels exit label)
(hcs : counter ≠ source) (hcd : counter ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (table : Table q) (e : Fin table.darts)
(counterSuffix suffix output : List Bool) (ambient : σ) (register : Option Bool) :
(advance (TM2.step P))^[lookupCost ((rowList table).take e.val) table.rows[e]]
(some ⟨some (labels .guard), (ambient, register),
MachineLookup.tapes counter source destination base
(encodeWord e.val ++ counterSuffix) (rowsBits (rowList table) ++ suffix) output⟩) =
some ⟨exit, (ambient, none),
MachineLookup.tapes counter source destination base
(encodeWord 0 ++ counterSuffix)
(encodeWord table.rows[e].reverseIndex.val ++
(encodeWords (relationWords table.rows[e].relation) ++
(rowsBits ((rowList table).drop (e.val + 1)) ++ suffix)))
(encodeWord table.rows[e].tail.val ++ output)⟩ := by
have h := lookupTailTrace counter source destination labels exit P atStatement
hcs hcd hsd base ((rowList table).take e.val) table.rows[e] counterSuffix
(rowsBits ((rowList table).drop (e.val + 1)) ++ suffix) output ambient register
have hlength : ((rowList table).take e.val).length = e.val := by
simp only [List.length_take, rowList_length, Nat.min_eq_left (Nat.le_of_lt e.isLt)]
have hsplit : rowsBits (rowList table) ++ suffix =
rowsBits ((rowList table).take e.val) ++
(rowBits table.rows[e] ++ (rowsBits ((rowList table).drop (e.val + 1)) ++ suffix)) := by
have hrow : table.rows[e.val] = table.rows[e] := rfl
simpa only [rowsBits, rowBits, rowList, Vector.getElem_toList, hrow] using
Input.rowsBits_append_split (rowList table) e.val (by simp) suffix
rw [hlength, ← hsplit] at h
exact h
theorem fullTableTailTrace {q : Nat}
(counter source destination : K) (labels : Label → Λ) (exit : Option Λ)
(headerVertices headerDarts : Λ)
(P : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
(atStatement : ∀ label, P (labels label) = statement q counter source destination labels exit label)
(atVertices : P headerVertices = MachineLookup.discard source headerVertices headerDarts)
(atDarts : P headerDarts = MachineLookup.discard source headerDarts (labels .guard))
(hcs : counter ≠ source) (hcd : counter ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (table : Table q) (e : Fin table.darts)
(counterSuffix suffix output : List Bool) (ambient : σ) (register : Option Bool) :
(advance (TM2.step P))^[lookupCost ((rowList table).take e.val) table.rows[e] +
(table.darts + 1) + (table.vertices + 1)]
(some ⟨some headerVertices, (ambient, register),
MachineLookup.tapes counter source destination base
(encodeWord e.val ++ counterSuffix) (tableBits table ++ suffix) output⟩) =
some ⟨exit, (ambient, none),
MachineLookup.tapes counter source destination base
(encodeWord 0 ++ counterSuffix)
(encodeWord table.rows[e].reverseIndex.val ++
(encodeWords (relationWords table.rows[e].relation) ++
(rowsBits ((rowList table).drop (e.val + 1)) ++ suffix)))
(encodeWord table.rows[e].tail.val ++ output)⟩ := by
have hv := MachineLookup.discardTrace source headerVertices headerDarts P atVertices
(MachineLookup.tapes counter source destination base
(encodeWord e.val ++ counterSuffix) (tableBits table ++ suffix) output)
table.vertices (encodeWord table.darts ++ (rowsBits (rowList table) ++ suffix))
(by simp only [MachineLookup.tapes_source _ _ _ hsd, Input.tableBits_header,
rowsBits, List.append_assoc]) ambient register
rw [Function.iterate_add_apply, hv]
simp only [MachineLookup.update_source _ _ _ hsd]
have hd := MachineLookup.discardTrace source headerDarts (labels .guard) P atDarts
(MachineLookup.tapes counter source destination base
(encodeWord e.val ++ counterSuffix)
(encodeWord table.darts ++ (rowsBits (rowList table) ++ suffix)) output)
table.darts (rowsBits (rowList table) ++ suffix) (by simp [hsd]) ambient none
rw [Function.iterate_add_apply, hd]
simp only [MachineLookup.update_source _ _ _ hsd]
exact tableTailTrace counter source destination labels exit P atStatement hcs hcd hsd
base table e counterSuffix suffix output ambient none
theorem lookup_frame (counter source destination other : K)
(hc : other ≠ counter) (hs : other ≠ source) (hd : other ≠ destination)
(base : K → List Bool) (counterBits input output : List Bool) :
MachineLookup.tapes counter source destination base counterBits input output other = base other :=
MachineLookup.tapes_other counter source destination other hc hs hd base counterBits input output
def tableTailCost {q : Nat} (table : Table q) (e : Fin table.darts) : Nat :=
lookupCost ((rowList table).take e.val) table.rows[e] +
(table.darts + 1) + (table.vertices + 1)
theorem tableTailCost_le {q : Nat} (table : Table q) (e : Fin table.darts) :
tableTailCost table e ≤ (tableBits table).length + 2 * (encodeWord e.val).length + 1 := by
have htake : ((rowList table).take e.val).length = e.val := by
simp only [List.length_take, rowList_length, Nat.min_eq_left (Nat.le_of_lt e.isLt)]
have hrow : table.rows[e.val] = table.rows[e] := rfl
have hsplit : rowsBits (rowList table) = rowsBits ((rowList table).take e.val) ++
(rowBits table.rows[e] ++ rowsBits ((rowList table).drop (e.val + 1))) := by
simpa only [rowsBits, rowBits, rowList, Vector.getElem_toList, hrow] using
Input.rowsBits_split (rowList table) e.val (by simp)
have hp : (rowsBits ((rowList table).take e.val) ++ rowBits table.rows[e]).length ≤
(rowsBits (rowList table)).length := by
rw [hsplit]
simp only [List.length_append]
omega
have hb := lookupCost_le ((rowList table).take e.val) table.rows[e]
rw [htake] at hb
have hh := congrArg List.length (Input.tableBits_header table)
change (tableBits table).length =
(encodeWord table.vertices ++ (encodeWord table.darts ++ rowsBits (rowList table))).length at hh
simp only [List.length_append, encodeWord_length] at hh
unfold tableTailCost
omega
def headIndex {q : Nat} (table : Table q) (e : Fin table.darts) : Fin table.darts :=
table.rows[e].reverseIndex
def headValue {q : Nat} (table : Table q) (e : Fin table.darts) : Nat :=
table.rows[headIndex table e].tail.val
theorem headValue_eq_semantics {q : Nat} (table : Table q) (e : Fin table.darts) :
headValue table e = ((semantics table).head e).val := rfl
abbrev HeadTapes (K : Type) := Fin 6 → K
def headLookupTapes {q : Nat} (tape : HeadTapes K) (base : K → List Bool)
(table : Table q) (e : Fin table.darts) : K → List Bool :=
MachineLookup.tapes (tape 3) (tape 2) (tape 4) base
(encodeWord 0 ++ base (tape 3))
(encodeWord table.rows[headIndex table e].reverseIndex.val ++
(encodeWords (relationWords table.rows[headIndex table e].relation) ++
(rowsBits ((rowList table).drop ((headIndex table e).val + 1)) ++ base (tape 2))))
(encodeWord (headValue table e))
def headLookupCost {q : Nat} (table : Table q) (e : Fin table.darts) : Nat :=
2 * ((tableBits table).length + 1) +
2 * ((encodeWord (headIndex table e).val).length + 1) + tableTailCost table (headIndex table e)
theorem headLookupCost_le {q : Nat} (table : Table q) (e : Fin table.darts) :
headLookupCost table e ≤ 7 * (tableBits table).length + 5 := by
have hi : (encodeWord (headIndex table e).val).length ≤ (tableBits table).length := by
rw [encodeWord_length]
exact (Nat.succ_le_of_lt (headIndex table e).isLt).trans (darts_le_tableBits_length table)
have hl := tableTailCost_le table (headIndex table e)
unfold headLookupCost
omega
noncomputable def headTimePolynomial : Polynomial Nat :=
Polynomial.C 7 * Polynomial.X + Polynomial.C 5
def headLookupInTime {q : Nat}
(tape : HeadTapes K) (hinj : Function.Injective tape)
(tableFirst tableSecond indexFirst indexSecond headerVertices headerDarts : Λ)
(labels : Label → Λ) (exit : Option Λ)
(P : Λ → TM2.Stmt (Alphabet (K := K)) Λ (σ × Option Bool))
(atTableFirst : P tableFirst = Reduction.MachineTransfer.loopAt
(tape 0) (tape 5) id false tableFirst (some tableSecond))
(atTableSecond : P tableSecond = MachineCopy.forkLoop
(tape 5) (tape 0) (tape 2) false tableSecond (some indexFirst))
(atIndexFirst : P indexFirst = Reduction.MachineTransfer.loopAt
(tape 1) (tape 5) id false indexFirst (some indexSecond))
(atIndexSecond : P indexSecond = MachineCopy.forkLoop
(tape 5) (tape 1) (tape 3) false indexSecond (some headerVertices))
(atVertices : P headerVertices = MachineLookup.discard (tape 2) headerVertices headerDarts)
(atDarts : P headerDarts = MachineLookup.discard (tape 2) headerDarts (labels .guard))
(atStatement : ∀ label,
P (labels label) = statement q (tape 3) (tape 2) (tape 4) labels exit label)
(base : K → List Bool) (table : Table q) (e : Fin table.darts)
(hTable : base (tape 0) = tableBits table)
(hReverse : base (tape 1) = encodeWord (headIndex table e).val)
(hHead : base (tape 4) = []) (hScratch : base (tape 5) = [])
(ambient : σ) (register : Option Bool) :
StateTransition.EvalsToInTime (TM2.step P)
⟨some tableFirst, (ambient, register), base⟩
(some ⟨exit, (ambient, none), headLookupTapes tape base table e⟩)
(headTimePolynomial.eval (tableBits table).length) := by
have hne (i j : Fin 6) (h : i ≠ j) : tape i ≠ tape j := fun heq => h (hinj heq)
let t₁ := Function.update base (tape 2) (tableBits table ++ base (tape 2))
let t₂ := Function.update t₁ (tape 3) (encodeWord (headIndex table e).val ++ base (tape 3))
have run₁ : StateTransition.EvalsToInTime (TM2.step P)
⟨some tableFirst, (ambient, register), base⟩
(some ⟨some indexFirst, (ambient, none), t₁⟩)
(2 * ((tableBits table).length + 1)) := by
simpa only [hTable, t₁] using MachineCopy.copyInTime (tape 0) (tape 2) (tape 5)
(hne 0 2 (by decide)) (hne 0 5 (by decide)) (hne 2 5 (by decide)) false
tableFirst tableSecond (some indexFirst) P atTableFirst atTableSecond
base hScratch ambient register
have hsrc : t₁ (tape 1) = encodeWord (headIndex table e).val := by
simp only [t₁, Function.update_of_ne (hne 1 2 (by decide)), hReverse]
have hdst : t₁ (tape 3) = base (tape 3) := by
simp only [t₁, Function.update_of_ne (hne 3 2 (by decide))]
have hscratch₁ : t₁ (tape 5) = [] := by
simp only [t₁, Function.update_of_ne (hne 5 2 (by decide)), hScratch]
have run₂ : StateTransition.EvalsToInTime (TM2.step P)
⟨some indexFirst, (ambient, none), t₁⟩
(some ⟨some headerVertices, (ambient, none), t₂⟩)
(2 * ((encodeWord (headIndex table e).val).length + 1)) := by
simpa only [hsrc, hdst, t₂] using MachineCopy.copyInTime (tape 1) (tape 3) (tape 5)
(hne 1 3 (by decide)) (hne 1 5 (by decide)) (hne 3 5 (by decide)) false
indexFirst indexSecond (some headerVertices) P atIndexFirst atIndexSecond
t₁ hscratch₁ ambient none
have ht₂ : t₂ = MachineLookup.tapes (tape 3) (tape 2) (tape 4) base
(encodeWord (headIndex table e).val ++ base (tape 3))
(tableBits table ++ base (tape 2)) [] := by
funext k
by_cases hi : k = tape 3
· subst k
simp [t₂, MachineLookup.tapes, hne 3 2 (by decide), hne 3 4 (by decide)]
· by_cases hs : k = tape 2
· subst k
simp [t₂, t₁, MachineLookup.tapes, hne 2 3 (by decide), hne 2 4 (by decide)]
· by_cases hh : k = tape 4
· subst k
simp [t₂, t₁, MachineLookup.tapes, hne 4 3 (by decide),
hne 4 2 (by decide), hHead]
· simp [t₂, t₁, MachineLookup.tapes, hi, hs, hh]
let run₃ : StateTransition.EvalsToInTime (TM2.step P)
⟨some headerVertices, (ambient, none), t₂⟩
(some ⟨exit, (ambient, none), headLookupTapes tape base table e⟩)
(tableTailCost table (headIndex table e)) := {
steps := tableTailCost table (headIndex table e)
evals_in_steps := by
change (advance (TM2.step P))^[tableTailCost table (headIndex table e)]
(some ⟨some headerVertices, (ambient, none), t₂⟩) =
some ⟨exit, (ambient, none), headLookupTapes tape base table e⟩
rw [ht₂]
simpa only [headLookupTapes, headValue, tableTailCost, List.append_nil] using
fullTableTailTrace (tape 3) (tape 2) (tape 4) labels exit
headerVertices headerDarts P atStatement atVertices atDarts
(hne 3 2 (by decide)) (hne 3 4 (by decide)) (hne 2 4 (by decide))
base table (headIndex table e) (base (tape 3)) (base (tape 2)) [] ambient none
steps_le_m := Nat.le_refl _ }
let run₁₂ := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ run₁ run₂
let run := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ run₁₂ run₃
refine { toEvalsTo := run.toEvalsTo, steps_le_m := ?_ }
have ht := run.steps_le_m
have hb := headLookupCost_le table e
simp only [headTimePolynomial, Polynomial.eval_add, Polynomial.eval_mul,
Polynomial.eval_C, Polynomial.eval_X]
unfold headLookupCost at hb
omega
theorem headLookupTapes_head {q : Nat} (tape : HeadTapes K) (base : K → List Bool)
(table : Table q) (e : Fin table.darts) :
headLookupTapes tape base table e (tape 4) = encodeWord (headValue table e) := by
simp [headLookupTapes]
theorem headLookupTapes_frame {q : Nat} (tape : HeadTapes K) (base : K → List Bool)
(table : Table q) (e : Fin table.darts) (other : K)
(hc : other ≠ tape 3) (hs : other ≠ tape 2) (hh : other ≠ tape 4) :
headLookupTapes tape base table e other = base other :=
lookup_frame (tape 3) (tape 2) (tape 4) other hc hs hh base _ _ _
def readRowTapes {q n m : Nat} (source tail reverse : K) (base : K → List Bool)
(row : DartRow q n m) (suffix : List Bool) : K → List Bool :=
Function.update (Function.update (Function.update base source suffix)
tail (encodeWord row.tail.val)) reverse (encodeWord row.reverseIndex.val)
theorem readRowTapes_source {q n m : Nat} (source tail reverse : K)
(hst : source ≠ tail) (hsr : source ≠ reverse)
(base : K → List Bool) (row : DartRow q n m) (suffix : List Bool) :
readRowTapes source tail reverse base row suffix source = suffix := by
simp [readRowTapes, hst, hsr]
theorem readRowTapes_tail {q n m : Nat} (source tail reverse : K)
(htr : tail ≠ reverse) (base : K → List Bool)
(row : DartRow q n m) (suffix : List Bool) :
readRowTapes source tail reverse base row suffix tail = encodeWord row.tail.val := by
simp [readRowTapes, htr]
theorem readRowTapes_reverse {q n m : Nat} (source tail reverse : K)
(base : K → List Bool) (row : DartRow q n m) (suffix : List Bool) :
readRowTapes source tail reverse base row suffix reverse =
encodeWord row.reverseIndex.val := by
simp [readRowTapes]
theorem readRowTapes_frame {q n m : Nat} (source tail reverse other : K)
(hs : other ≠ source) (ht : other ≠ tail) (hr : other ≠ reverse)
(base : K → List Bool) (row : DartRow q n m) (suffix : List Bool) :
readRowTapes source tail reverse base row suffix other = base other := by
simp [readRowTapes, hs, ht, hr]
def readRowCost {q n m : Nat} (row : DartRow q n m) : Nat :=
row.tail.val + row.reverseIndex.val + 5
theorem readRowCost_le {q n m : Nat} (row : DartRow q n m) :
readRowCost row ≤ (rowBits row).length + 3 := by
rw [rowBits_eq]
simp only [List.length_append, encodeWord_length]
unfold readRowCost
omega
theorem readRowCost_table_le {q : Nat} (table : Table q) (e : Fin table.darts) :
readRowCost table.rows[e] ≤ 2 * (tableBits table).length + 5 := by
have ht := (Nat.le_of_lt table.rows[e].tail.isLt).trans
(vertices_le_tableBits_length table)
have hr := (Nat.le_of_lt table.rows[e].reverseIndex.isLt).trans
(darts_le_tableBits_length table)
unfold readRowCost
omega
def readRowInTime {q n m : Nat} (source tail reverse : K)
(hst : source ≠ tail) (hsr : source ≠ reverse) (htr : tail ≠ reverse)
(tailStart tailLoop reverseStart reverseLoop readLabel exitLabel : Λ)
(P : Λ → TM2.Stmt (Alphabet (K := K)) Λ (ReadRelation.State σ q))
(atTailStart : P tailStart = Hastad.SourceMachine.fieldStart tail tailLoop)
(atTailLoop : P tailLoop =
Hastad.SourceMachine.fieldLoop source tail tailLoop (some reverseStart))
(atReverseStart : P reverseStart = Hastad.SourceMachine.fieldStart reverse reverseLoop)
(atReverseLoop : P reverseLoop =
Hastad.SourceMachine.fieldLoop source reverse reverseLoop (some readLabel))
(atRead : P readLabel = ReadRelation.parser source exitLabel)
(base : K → List Bool) (row : DartRow q n m) (suffix : List Bool)
(hinput : base source = rowBits row ++ suffix)
(hTail : base tail = []) (hReverse : base reverse = [])
(ambient : σ) (initial : RelationTable q) (register : Option Bool) :
StateTransition.EvalsToInTime (TM2.step P)
⟨some tailStart, ((ambient, initial), register), base⟩
(some ⟨some exitLabel, ((ambient, row.relation), none),
readRowTapes source tail reverse base row suffix⟩)
(readRowCost row) := by
let relationInput := encodeWords (relationWords row.relation) ++ suffix
let reverseInput := encodeWord row.reverseIndex.val ++ relationInput
let t₁ := Hastad.SourceMachine.fieldTapes source tail base reverseInput
(encodeWord row.tail.val)
let t₂ := Hastad.SourceMachine.fieldTapes source reverse t₁ relationInput
(encodeWord row.reverseIndex.val)
have hinput₁ : base source = encodeWord row.tail.val ++ reverseInput := by
simpa only [rowBits_eq, List.append_assoc, reverseInput, relationInput] using hinput
have run₁ : StateTransition.EvalsToInTime (TM2.step P)
⟨some tailStart, ((ambient, initial), register), base⟩
(some ⟨some reverseStart, ((ambient, initial), none), t₁⟩)
(row.tail.val + 2) := by
simpa only [hTail, List.append_nil, t₁] using
Hastad.SourceMachine.fieldInTime source tail hst tailStart tailLoop
(some reverseStart) P atTailStart atTailLoop base row.tail.val reverseInput
hinput₁ (ambient, initial) register
have hinput₂ : t₁ source = encodeWord row.reverseIndex.val ++ relationInput := by
simp only [t₁, Hastad.SourceMachine.fieldTapes_source source tail hst, reverseInput]
have hreverse₁ : t₁ reverse = [] := by
simp [t₁, Hastad.SourceMachine.fieldTapes, Ne.symm hsr, Ne.symm htr, hReverse]
have run₂ : StateTransition.EvalsToInTime (TM2.step P)
⟨some reverseStart, ((ambient, initial), none), t₁⟩
(some ⟨some readLabel, ((ambient, initial), none), t₂⟩)
(row.reverseIndex.val + 2) := by
simpa only [hreverse₁, List.append_nil, t₂] using
Hastad.SourceMachine.fieldInTime source reverse hsr reverseStart reverseLoop
(some readLabel) P atReverseStart atReverseLoop t₁ row.reverseIndex.val relationInput
hinput₂ (ambient, initial) none
have hinput₃ : t₂ source = encodeWords (relationWords row.relation) ++ suffix := by
simp only [t₂, Hastad.SourceMachine.fieldTapes_source source reverse hsr, relationInput]
have hrestore : Function.update t₂ source
(encodeWords (relationWords row.relation) ++ suffix) = t₂ := by
rw [← hinput₃]
exact Function.update_eq_self source t₂
have hfinal : Function.update t₂ source suffix =
readRowTapes source tail reverse base row suffix := by
funext k
by_cases hs : k = source
· subst k
simp [readRowTapes, hst, hsr]
· by_cases ht : k = tail
· subst k
simp [t₂, t₁, Hastad.SourceMachine.fieldTapes, readRowTapes, hs, htr]
· by_cases hr : k = reverse
· subst k
simp [t₂, Hastad.SourceMachine.fieldTapes, readRowTapes, hs]
· simp [t₂, t₁, Hastad.SourceMachine.fieldTapes, readRowTapes, hs, ht, hr]
have run₃ : StateTransition.EvalsToInTime (TM2.step P)
⟨some readLabel, ((ambient, initial), none), t₂⟩
(some ⟨some exitLabel, ((ambient, row.relation), none),
readRowTapes source tail reverse base row suffix⟩) 1 := {
steps := 1
evals_in_steps := by
change (advance (TM2.step P))^[1] _ = _
simpa only [hrestore, hfinal] using ReadRelation.parserTrace source readLabel exitLabel
P atRead t₂ row.relation suffix ambient initial none
steps_le_m := Nat.le_refl _ }
let run₁₂ := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ run₁ run₂
let run := StateTransition.EvalsToInTime.trans _ _ _ _ _ _ run₁₂ run₃
refine { toEvalsTo := run.toEvalsTo, steps_le_m := ?_ }
have ht := run.steps_le_m
unfold readRowCost
omega
def machine (q : Nat) : FinTM2 where
K := Fin 3
k₀ := 1
k₁ := 2
Γ _ := Bool
Λ := Label
main := .guard
σ := Unit × Option Bool
initialState := ((), none)
m := program q 0 1 2
end MinUncutGames.Foundations.PCP.AlphabetTable.Lookup
end
end OAI
import Mathlib
import OAI.Computability.MinUncut.Machines.Input
namespace OAI
section
namespace MinUncutGames.Foundations.Complexity.MachineLookup
open Turing
open MachineComposition
variable {K σ : Type} [DecidableEq K]
theorem guard_step_succ (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination)
(base : K → List Bool) (i : Nat) (indexSuffix input output : List Bool)
(ambient : σ) (register : Option Bool) :
TM2.step (program index source destination)
⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord (i + 1) ++ indexSuffix) input output⟩ =
some ⟨some .skip, (ambient, none), tapes index source destination base
(encodeWord i ++ indexSuffix) input output⟩ := by
change some (TM2.stepAux (program index source destination .guard) _ _) = _
simp [program, MachineUnaryCounter.guard, TM2.stepAux,
tapes_index, his, hid, encodeWord, List.replicate_succ, update_index]
theorem guard_step_zero (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination)
(base : K → List Bool) (indexSuffix input output : List Bool)
(ambient : σ) (register : Option Bool) :
TM2.step (program index source destination)
⟨some .guard, (ambient, register), tapes index source destination base
(encodeWord 0 ++ indexSuffix) input output⟩ =
some ⟨some .select, (ambient, none), tapes index source destination base
(encodeWord 0 ++ indexSuffix) input output⟩ := by
change some (TM2.stepAux (program index source destination .guard) _ _) = _
simp [program, MachineUnaryCounter.guard, TM2.stepAux,
tapes_index, his, hid, encodeWord]
theorem select_step_nonempty (index source destination : K)
(hsd : source ≠ destination) (base : K → List Bool)
(counter input output : List Bool) (hinput : input ≠ [])
(ambient : σ) (register : Option Bool) :
TM2.step (program index source destination)
⟨some .select, (ambient, register),
tapes index source destination base counter input output⟩ =
some ⟨some .copy, (ambient, input.head?),
tapes index source destination base counter input (false :: output)⟩ := by
change some (TM2.stepAux (program index source destination .select) _ _) = _
cases input with
| nil => exact (hinput rfl).elim
| cons head tail =>
simp [program, select, Hastad.SourceMachine.fieldStart, TM2.stepAux,
tapes_source, hsd, update_destination]
theorem select_step_empty (index source destination : K)
(hsd : source ≠ destination) (base : K → List Bool)
(counter output : List Bool) (ambient : σ) (register : Option Bool) :
TM2.step (program index source destination)
⟨some .select, (ambient, register),
tapes index source destination base counter [] output⟩ =
some ⟨some .rejected, (ambient, none),
tapes index source destination base counter [] output⟩ := by
change some (TM2.stepAux (program index source destination .select) _ _) = _
simp [program, select, TM2.stepAux, tapes_source, hsd]
theorem copyTrace (index source destination : K)
(hsd : source ≠ destination) (base : K → List Bool)
(counter : List Bool) (n : Nat) (suffix output : List Bool)
(ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[n + 1]
(some ⟨some .copy, (ambient, register), tapes index source destination base
counter (encodeWord n ++ suffix) (false :: output)⟩) =
some ⟨some .accepted, (ambient, none), tapes index source destination base
counter suffix (encodeWord n ++ output)⟩ := by
have h := Hastad.SourceMachine.fieldLoopTrace source destination hsd
Label.copy (some Label.accepted) (program index source destination) rfl
(Function.update base index counter) n suffix (false :: output) ambient register
simpa only [Hastad.SourceMachine.fieldTapes, tapes, encodeWord,
List.append_assoc, List.singleton_append] using h
theorem selectTrace (index source destination : K)
(hsd : source ≠ destination) (base : K → List Bool)
(counter : List Bool) (n : Nat) (suffix output : List Bool)
(ambient : σ) (register : Option Bool) :
(advance (TM2.step (program index source destination)))^[n + 2]
(some ⟨some .select, (ambient, register), tapes index source destination base
counter (encodeWord n ++ suffix) output⟩) =
some ⟨some .accepted, (ambient, none), tapes index source destination base
counter suffix (encodeWord n ++ output)⟩ := by
rw [show n + 2 = (n + 1) + 1 by omega, Function.iterate_succ_apply]
simp only [advance_some]
rw [select_step_nonempty index source destination hsd base counter
(encodeWord n ++ suffix) output (by simp [encodeWord]) ambient register]
exact copyTrace index source destination hsd base counter n suffix output ambient _
theorem skipCycleTrace (index source destination : K)
(his : index ≠ source) (hid : index ≠ destination) (hsd : source ≠ destination)
(base : K → List Bool) (i n : Nat) (indexSuffix suffix output : List Bool)
(ambient : σ) (register : Option Bool) :