math / data /lean /OAI /Computability /Logspace /TransitionTables.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
6.26 kB
import OAI.Computability.Logspace.Deterministic
namespace OAI
/-!
Finite transition tables, configuration semantics, and reindexing into finite machines.
From OpenAI, *Exact Derandomization of Logarithmic Space: L = RL = BPL*.
-/
set_option autoImplicit true
section
/-!
A notational convenience: transition tables whose finite index sets
are not necessarily written as Fin k. Reindex back to Machine without
changing any run.
-/
namespace ExactDerandomization.Table
variable (S W H : Type)
structure Act where
next : S
write : W β†’ Bool
workMove : W β†’ Direction
inputMove : H β†’ Direction
structure TM where
start : S
out : S β†’ Option Bool
go : S β†’ (H β†’ InputSymbol) β†’ (W β†’ Bool) β†’ Bool β†’ Act S W H
@[ext]
structure Conf (n : β„•) where
state : S
inputPos : H β†’ Fin (n + 2)
workPos : W β†’ β„€
work : W β†’ β„€ β†’ Bool
namespace TM
variable {S W H} (P : TM S W H)
def init (n : β„•) : Conf S W H n :=
⟨P.start, fun _ => ⟨0, by omega⟩, fun _ => 0, fun _ _ => false⟩
def applyAct {n : β„•} (c : Conf S W H n) (a : Act S W H) : Conf S W H n :=
{ state := a.next
inputPos := fun j => (a.inputMove j).moveInput (c.inputPos j)
workPos := fun k => (a.workMove k).move (c.workPos k)
work := fun k => Function.update (c.work k) (c.workPos k) (a.write k) }
def step (x : Word) (coin : Bool) (c : Conf S W H x.length) : Conf S W H x.length :=
match P.out c.state with
| some _ => c
| none =>
applyAct c (P.go c.state (fun j => readInput x (c.inputPos j))
(fun k => c.work k (c.workPos k)) coin)
def run (x : Word) (coins : CoinTape) :
β„• β†’ Conf S W H x.length
| 0 => P.init x.length
| t+1 => P.step x (coins t) (run x coins t)
def det : Prop :=
βˆ€ s i v, P.go s i v false = P.go s i v true
def spaceThrough [Fintype W] (x : Word) (coins : CoinTape) (t : β„•) : β„• :=
βˆ‘ k : W, ((Finset.range (t+1)).image (fun s => (P.run x coins s).workPos k)).card
def halts (x : Word) (t : β„•) : Prop :=
βˆ€ coins : CoinTape, βˆƒ b : Bool, P.out (P.run x coins t).state = some b
def prob (x : Word) (t : β„•) : β„š :=
((Finset.univ.filter (fun bits : Fin t β†’ Bool =>
P.out (P.run x (Machine.extendCoins bits) t).state = some true)).card : β„š) / 2 ^ t
def idle (s : S) (v : W β†’ Bool) : Act S W H := ⟨s, v, fun _ => .stay, fun _ => .stay⟩
theorem applyAct_idle {n : β„•} (c : Conf S W H n) :
applyAct c (idle c.state (fun k => c.work k (c.workPos k))) = c := by
ext <;> simp [applyAct, idle, Direction.moveInput, Direction.move]
/-- Uniform form of step: give halting states self-loop actions writing
the scanned bits back. -/
def goStutter (s : S) (i : H β†’ InputSymbol) (v : W β†’ Bool) (coin : Bool) :
Act S W H :=
if P.out s = none then P.go s i v coin else idle s v
theorem step_eq_apply (x : Word) (coin : Bool) (c : Conf S W H x.length) :
P.step x coin c = applyAct c (P.goStutter c.state
(fun j => readInput x (c.inputPos j)) (fun k => c.work k (c.workPos k)) coin) := by
cases h : P.out c.state <;> simp [step, goStutter, h, applyAct_idle]
variable {q w h : β„•}
def reindex (e : S ≃ Fin (q+1)) (f : W ≃ Fin w) (g : H ≃ Fin h) :
Machine q w h :=
{ initialState := e P.start
output := fun a => P.out (e.symm a)
transition := fun s i v coin =>
let a := P.go (e.symm s) (fun j => i (g j)) (fun k => v (f k)) coin
{ nextState := e a.next
write := fun k => a.write (f.symm k)
workMove := fun k => a.workMove (f.symm k)
inputMove := fun j => a.inputMove (g.symm j) } }
def mapConf (e : S ≃ Fin (q+1)) (f : W ≃ Fin w) (g : H ≃ Fin h)
{n : β„•} (c : Conf S W H n) : Configuration q w h n :=
⟨e c.state, fun j => c.inputPos (g.symm j), fun k => c.workPos (f.symm k),
fun k => c.work (f.symm k)⟩
theorem step_reindex (e : S ≃ Fin (q+1)) (f : W ≃ Fin w) (g : H ≃ Fin h)
(x : Word) (coin : Bool) (c : Conf S W H x.length) :
(P.reindex e f g).step x coin (mapConf e f g c) =
mapConf e f g (P.step x coin c) := by
cases hout : P.out c.state <;>
simp [Machine.step, reindex, mapConf, step, applyAct, hout]
theorem run_reindex (e : S ≃ Fin (q+1)) (f : W ≃ Fin w) (g : H ≃ Fin h)
(x : Word) (coins : CoinTape) (t : β„•) :
(P.reindex e f g).run x coins t = mapConf e f g (P.run x coins t) := by
induction t with
| zero => rfl
| succ t ih =>
rw [Machine.run_succ, ih]
exact P.step_reindex _ _ _ _ _ _
theorem out_reindex (e : S ≃ Fin (q+1)) (f : W ≃ Fin w) (g : H ≃ Fin h)
(x : Word) (coins : CoinTape) (t : β„•) :
(P.reindex e f g).output ((P.reindex e f g).run x coins t).state =
P.out (P.run x coins t).state := by
rw [run_reindex]
simp [reindex, mapConf]
theorem prob_reindex (e : S ≃ Fin (q+1)) (f : W ≃ Fin w) (g : H ≃ Fin h)
(x : Word) (t : β„•) :
(P.reindex e f g).acceptanceProbability x t = P.prob x t := by
simp only [Machine.acceptanceProbability, prob, out_reindex]
theorem space_reindex [Fintype W] (e : S ≃ Fin (q+1)) (f : W ≃ Fin w) (g : H ≃ Fin h)
(x : Word) (coins : CoinTape) (t : β„•) :
(P.reindex e f g).spaceThrough x coins t = P.spaceThrough x coins t := by
simp only [Machine.spaceThrough, spaceThrough, run_reindex, mapConf]
exact Fintype.sum_equiv f.symm _ _ fun k => rfl
theorem det_reindex (e : S ≃ Fin (q+1)) (f : W ≃ Fin w) (g : H ≃ Fin h)
(hp : P.det) : (P.reindex e f g).Deterministic := by
intro s i v
simp only [reindex, hp _ _ _]
/-- Regard a Machine as a table (no reindexing). -/
def ofMachine (M : Machine q w h) : TM (Fin (q+1)) (Fin w) (Fin h) :=
⟨M.initialState, M.output, fun s i v coin =>
let a := M.transition s i v coin
⟨a.nextState, a.write, a.workMove, a.inputMove⟩⟩
@[simp] theorem reindex_refl (M : Machine q w h) :
(ofMachine M).reindex (.refl _) (.refl _) (.refl _) = M := rfl
/-- The index equivalence is routine, but we record it to compile a nonempty-state
table to the concrete Machine class. -/
noncomputable def number [Fintype S] [Nonempty S] :
S ≃ Fin (Fintype.card S - 1 + 1) :=
(Fintype.equivFin S).trans (finCongr (by have := Fintype.card_pos (Ξ±:=S); omega))
end TM
end ExactDerandomization.Table
end
end OAI