math / data /lean /OAI /Computability /WeisfeilerLeman /SparseStore.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
25.1 kB
import OAI.Computability.WeisfeilerLeman.SparseSearch
namespace OAI
universe uA uB
namespace WLTime.SparseLookup
open TypedStack
def answer (w : ℕ) (q : List Bool) (l : List Entry) : List Bool :=
if found q l=[] then List.replicate w false else found q l
def supplyZero (w : ℕ) : Code Reg Bool :=
.branch (Code.nonempty 2) .skip (.pushList 2 (List.replicate w false))
def program (w : ℕ) : Code Reg Bool :=
.seq (search w) (.seq (.transfer 3 0 false) (supplyZero w))
theorem supplyZero_exec (w : ℕ) (log q out : List Bool) :
∃u ≤ 2*w+2,
(supplyZero w).Exec (state log q out [] [] [] [] []) u
(state log q (if out=[] then List.replicate w false else out) [] [] [] [] []) := by
let s := state log q out [] [] [] [] []
by_cases ho : out=[]
· have hp := Code.pushList_exec (2 : Reg) (List.replicate w false) s
have he := Code.Exec.branch_false (a:=Code.skip) (p:=Code.nonempty 2) (by simp [Code.nonempty,tops,s,state,ho]) hp
refine ⟨1+(2*w+1),by omega,?_⟩
have hh : Function.update s 2 (List.replicate w false++s 2)=state log q (if out=[] then List.replicate w false else out) [] [] [] [] [] := by
funext i; fin_cases i <;> simp [s,state,ho]
rw [hh] at he
simpa only [supplyZero,s,List.length_replicate,Nat.add_comm] using he
· have he := Code.Exec.branch_true (b:=Code.pushList 2 (List.replicate w false)) (p:=Code.nonempty 2)
(by simp [Code.nonempty,tops,s,state,ho]) (Code.Exec.skip s)
exact ⟨2,by omega,by simpa only [supplyZero,s,ite_eq_right ho] using he⟩
theorem program_exec (q : List Bool) (l : List Entry) (hq : 0<q.length) (hw : WellFormed q.length l) :
∃u ≤ 60*(q.length+1)*(l.length+1),
(program q.length).Exec (state (flatten l) q [] [] [] [] [] []) u
(state (flatten l) q (answer q.length q l) [] [] [] [] []) := by
obtain ⟨a,ha,he⟩ := search_exec q l [] hq hw
simp only [List.append_nil] at he
let mid := state (flatten (remaining q l)) q (found q l) (flatten (consumed q l)).reverse [] [] [] []
have ht := Code.transfer_exec (3 : Reg) 0 (by decide) false mid
have hs : Function.update (Function.update mid 3 []) 0 ((mid 3).reverse++mid 0)=
state (flatten l) q (found q l) [] [] [] [] [] := by
have hsplit : flatten (consumed q l)++flatten (remaining q l)=flatten l := by rw [←flatten_append,split_log]
funext i; fin_cases i <;> simp [mid,state,hsplit]
rw [hs] at ht
obtain ⟨b,hb,hf⟩ := supplyZero_exec q.length (flatten l) q (found q l)
refine ⟨_,?_,Code.Exec.seq he (Code.Exec.seq ht hf)⟩
change a+(5*(flatten (consumed q l)).reverse.length+1+b) ≤ _
rw [List.length_reverse]
have hpre := consumed_length q l
rw [flatten_length q.length l hw] at hpre
nlinarith
theorem program_size (w : ℕ) : (program w).controlSize ≤ 30*w+100 := by
simp only [program,search,one,first,finish,supplyZero,Code.controlSize,Code.relabel_controlSize,
SparseMatch.program_size,SparseTake.program_size,Code.copy,Code.transfer,Code.distribute,Code.clear,
Code.pushList_size,List.length_replicate]
omega
end WLTime.SparseLookup
namespace WLTime.WordMemory
open TypedStack
abbrev Log (w : ℕ) := List (Word w × Word w)
def read {w : ℕ} (q : Word w) : Log w → Word w
| [] => ⟨0,by positivity⟩
| e::l => if e.1=q then e.2 else read q l
def entries {w : ℕ} (l : Log w) : List SparseLookup.Entry :=
l.map (fun e => (wordBits e.1,wordBits e.2))
theorem entries_wellFormed {w : ℕ} (l : Log w) : SparseLookup.WellFormed w (entries l) := by
intro e he
obtain ⟨a,ha,rfl⟩ := List.mem_map.mp he
simp [wordBits]
theorem entries_length {w : ℕ} (l : Log w) : (entries l).length=l.length := by simp [entries]
theorem word_zero (w : ℕ) : wordBits (⟨0,by positivity⟩ : Word w)=List.replicate w false := by
simp [wordBits,List.ofFn_const]
theorem answer_read {w : ℕ} (hw : 0<w) (q : Word w) (l : Log w) :
SparseLookup.answer w (wordBits q) (entries l)=wordBits (read q l) := by
induction l with
| nil => simp [SparseLookup.answer,SparseLookup.found,entries,read,wordBits,List.ofFn_const]
| cons e l ih =>
by_cases he : e.1=q
· have hne : wordBits e.2≠[] := by intro h; have hh := congrArg List.length h; simp [wordBits] at hh; omega
simp [entries,SparseLookup.answer,SparseLookup.found,he,hne,read]
· have hb : wordBits e.1≠wordBits q := fun h => he (BitWords.word_injective h)
change SparseLookup.answer w (wordBits q) ((wordBits e.1,wordBits e.2)::entries l)=wordBits (if e.1=q then e.2 else read q l)
rw [ite_eq_right he]
unfold SparseLookup.answer
rw [SparseLookup.found,ite_eq_right hb]
exact ih
theorem lookup_exec {w : ℕ} (hw : 0<w) (q : Word w) (l : Log w) :
∃u ≤ 60*(w+1)*(l.length+1),
(SparseLookup.program w).Exec
(SparseLookup.state (SparseLookup.flatten (entries l)) (wordBits q) [] [] [] [] [] []) u
(SparseLookup.state (SparseLookup.flatten (entries l)) (wordBits q) (wordBits (read q l)) [] [] [] [] []) := by
have hq : (wordBits q).length=w := by simp [wordBits]
have he := SparseLookup.program_exec (wordBits q) (entries l) (by simpa [hq] using hw)
(by rw [hq]; exact entries_wellFormed l)
simpa only [hq,entries_length,answer_read hw] using he
theorem read_prepend {w : ℕ} (l : Log w) (a v : Word w) :
(fun q => read q ((a,v)::l))=Function.update (fun q => read q l) a v := by
funext q
by_cases h : a=q <;> simp [read,h,eq_comm]
end WLTime.WordMemory
namespace WLTime.SparseStore
open TypedStack
abbrev Reg := Fin 4
def state (log key value tmp : List Bool) : Stacks Reg Bool := ![log,key,value,tmp]
def program : Code Reg Bool := .seq (.copy 2 0 3 false) (.copy 1 0 3 false)
theorem program_exec (log key value : List Bool) :
program.Exec (state log key value []) (12*(key.length+value.length)+4)
(state (key++value++log) key value []) := by
let s := state log key value []
let mid := state (value++log) key value []
have h₁ : (Code.copy 2 0 3 false).Exec s (12*value.length+2) mid := by
have h := Code.copy_exec (2 : Reg) 0 3 (by decide) (by decide) (by decide) false s rfl
convert h using 1
· rfl
· funext i; fin_cases i <;> simp [s,mid,state]
have h₂ : (Code.copy 1 0 3 false).Exec mid (12*key.length+2) (state (key++value++log) key value []) := by
have h := Code.copy_exec (1 : Reg) 0 3 (by decide) (by decide) (by decide) false mid rfl
convert h using 1
· rfl
· funext i; fin_cases i <;> simp [mid,state,List.append_assoc]
have he := Code.Exec.seq h₁ h₂
convert he using 1
· rfl
· omega
end WLTime.SparseStore
namespace WLTime.BitWords
theorem value_sum (n : ℕ) (f : ℕ → Bool) :
value (List.ofFn (fun i : Fin n => f i.val))=∑i∈Finset.range n, if f i then 2^i else 0 := by
induction n generalizing f with
| zero => simp [value]
| succ n ih =>
rw [List.ofFn_succ,value_cons]
simp only [Fin.val_zero,Fin.val_succ]
rw [ih (fun i => f (i+1))]
rw [Finset.sum_range_succ']
simp only [pow_succ]
have hsum : (∑i∈Finset.range n,if f (i+1) then 2^i*2 else 0)=
2*(∑i∈Finset.range n,if f (i+1) then 2^i else 0) := by
rw [Finset.mul_sum]
apply Finset.sum_congr rfl
intro i hi
cases f (i+1) <;> simp [Nat.mul_comm]
rw [hsum]
cases f 0 <;> simp [Bool.toNat,Nat.add_comm]
end WLTime.BitWords
namespace WLTime.WordMemory
open TypedStack
def chunk (w : ℕ) (input : List Bool) (a : ℕ) : List Bool :=
Code.readN false (input.drop (w*a)) w
theorem chunk_length (w : ℕ) (input : List Bool) (a : ℕ) : (chunk w input a).length=w := by simp [chunk,Code.readN]
theorem chunk_value (w : ℕ) (input : List Bool) (a : ℕ) :
BitWords.value (chunk w input a)=
∑i∈Finset.range w,if input.getD (w*a+i) false then 2^i else 0 := by
unfold chunk Code.readN
rw [BitWords.value_sum w (fun i => (input.drop (w*a)).getD i false)]
apply Finset.sum_congr rfl
intro i hi
simp only [List.getD_eq_getElem?_getD,List.getElem?_drop]
theorem packed_bits (w : ℕ) (input : List Bool) (a : Word w) :
wordBits (RAM.packedWord w input a)=chunk w input a.val := by
have hv := BitWords.value_lt (chunk w input a.val)
rw [chunk_length] at hv
have he : (RAM.packedWord w input a).val=BitWords.value (chunk w input a.val) := by
change _ % (2^w)=_
rw [←chunk_value,Nat.mod_eq_of_lt hv]
apply List.ext_getElem
· simp [wordBits,chunk_length]
· intro i hi hj
simp only [wordBits,List.getElem_ofFn,he,BitWords.testBit_value]
exact List.getD_eq_getElem _ _ hj
theorem chunk_zero (w : ℕ) (input : List Bool) (a : ℕ) (ha : input.length ≤ w*a) :
chunk w input a=List.replicate w false := by
simp [chunk,Code.readN,List.drop_eq_nil_of_le ha,List.ofFn_const]
end WLTime.WordMemory
namespace WLTime.WordMemory
def address (w a : ℕ) : Word w := ⟨a%(2^w),Nat.mod_lt _ (by positivity)⟩
theorem address_val (w a : ℕ) (ha : a<2^w) : (address w a).val=a := Nat.mod_eq_of_lt ha
theorem address_eq (w a : ℕ) (q : Word w) (ha : a<2^w) : address w a=q ↔ a=q.val := by
rw [Fin.ext_iff,address_val w a ha]
def initialLog (w : ℕ) (input : List Bool) : ℕ → Log w
| 0 => []
| a+1 => (address w a,RAM.packedWord w input (address w a))::initialLog w input a
theorem initialLog_length (w : ℕ) (input : List Bool) (a : ℕ) : (initialLog w input a).length=a := by
induction a with
| zero => rfl
| succ a ih => simp [initialLog,ih]
theorem read_initialLog (w : ℕ) (input : List Bool) (a : ℕ) (q : Word w) (ha : a ≤ 2^w) :
read q (initialLog w input a)=if q.val<a then RAM.packedWord w input q else ⟨0,by positivity⟩ := by
induction a with
| zero => simp [initialLog,read]
| succ a ih =>
have hal : a<2^w := by omega
have hh := ih (by omega)
simp only [initialLog,read]
by_cases he : address w a=q
· rw [ite_eq_left he,he,ite_eq_left (by have := (address_eq w a q hal).mp he; omega)]
· rw [ite_eq_right he,hh]
have hne : a≠q.val := fun h => he ((address_eq w a q hal).mpr h)
have heq : (q.val<a) ↔ (q.val<a+1) := by omega
simp only [heq]
theorem initialLog_correct (w : ℕ) (input : List Bool) (a : ℕ) (ha : a ≤ 2^w) (hl : input.length ≤ w*a) :
(fun q => read q (initialLog w input a))=RAM.packedWord w input := by
funext q
rw [read_initialLog w input a q ha]
split_ifs with hq
· rfl
· apply BitWords.word_injective
rw [word_zero,packed_bits,chunk_zero w input q.val (hl.trans (Nat.mul_le_mul_left w (by omega)))]
theorem number_of_chunks (w : ℕ) (hw : 0<w) (input : List Bool) :
∃n ≤ input.length, input.length ≤ w*n ∧ ∀ a < n, w*a < input.length := by
have hex : ∃n,input.length ≤ w*n := ⟨input.length,by nlinarith⟩
let n := Nat.find hex
refine ⟨n,Nat.find_min' hex (by nlinarith),Nat.find_spec hex,?_⟩
intro a ha
exact Nat.lt_of_not_ge (Nat.find_min hex ha)
end WLTime.WordMemory
namespace WLTime.BitWords
theorem eq_word {w : ℕ} (xs : List Bool) (a : Word w) (hl : xs.length=w) (hv : value xs=a.val) : xs=wordBits a := by
apply List.ext_getElem
· simpa [wordBits] using hl
· intro i hi hj
simp only [wordBits,List.getElem_ofFn,←hv,testBit_value]
exact (List.getD_eq_getElem _ _ hi).symm
theorem inc_address (w a : ℕ) : inc (wordBits (WordMemory.address w a))=wordBits (WordMemory.address w (a+1)) := by
apply eq_word
· simp [wordBits]
· rw [inc_value,value_word]
simp only [wordBits,List.length_ofFn,WordMemory.address]
simp only [Nat.add_mod,Nat.mod_mod]
end WLTime.BitWords
namespace WLTime.RAMInput
open TypedStack WordMemory
abbrev Reg := Fin 6
def state (input log addr value temp scratch : List Bool) : Stacks Reg Bool :=
![input,log,addr,value,temp,scratch]
def storeMap : SparseStore.Reg → Reg := ![1,2,3,5]
theorem storeMap_inj : Function.Injective storeMap := by decide
noncomputable def body (w : ℕ) : Code Reg Bool :=
.seq (.takeN 0 4 id false w) (.seq (.transfer 4 3 false)
(.seq (SparseStore.program.relabel storeMap) (.seq (.clear 3) (.increment 2 5))))
def running (v : Tops Reg Bool) : Bool := Code.nonempty 0 v
noncomputable def loopCode (w : ℕ) : Code Reg Bool := .loop running (body w)
noncomputable def program (w : ℕ) : Code Reg Bool :=
.seq (.pushList 2 (List.replicate w false)) (.seq (loopCode w) (.clear 2))
theorem body_exec (w : ℕ) (input log addr : List Bool) (ha : addr.length=w) :
∃ u ≤ 50*(w+1), (body w).Exec (state input log addr [] [] []) u
(state (input.drop w) (addr++Code.readN false input w++log) (BitWords.inc addr) [] [] []) := by
let value := Code.readN false input w
have hv : value.length=w := by simp [value,Code.readN]
let s₀ := state input log addr [] [] []
let s₁ := state (input.drop w) log addr [] value.reverse []
let s₂ := state (input.drop w) log addr value [] []
let s₃ := state (input.drop w) (addr++value++log) addr value [] []
let s₄ := state (input.drop w) (addr++value++log) addr [] [] []
have h₁ : (Code.takeN 0 4 id false w).Exec s₀ (4*w+1) s₁ := by
have he := Code.takeN_exec (0 : Reg) 4 (by decide) id false w s₀
convert he using 1
funext i; fin_cases i <;> simp [s₀,s₁,state,value]
have h₂ : (Code.transfer 4 3 false).Exec s₁ (5*w+1) s₂ := by
have he := Code.transfer_exec (4 : Reg) 3 (by decide) false s₁
convert he using 1
· simp [s₁,state,hv]
· funext i; fin_cases i <;> simp [s₁,s₂,state]
have h₃ : (SparseStore.program.relabel storeMap).Exec s₂ (24*w+4) s₃ := by
have he := SparseStore.program_exec log addr value
have hc : 12*(addr.length+value.length)+4=24*w+4 := by rw [ha,hv]; omega
rw [hc] at he
apply Code.relabel_exec_of_maps storeMap storeMap_inj he
· intro i; fin_cases i <;> simp [s₂,state,storeMap,SparseStore.state]
· intro i; fin_cases i <;> simp [s₃,state,storeMap,SparseStore.state]
· intro i hi; fin_cases i <;> simp_all [state,s₂,s₃,storeMap]
exact False.elim (hi 0 rfl)
have h₄ : (Code.clear 3).Exec s₃ (3*w+1) s₄ := by
have he := Code.clear_exec (3 : Reg) s₃
convert he using 1
· simp [s₃,state,hv]
· funext i; fin_cases i <;> simp [s₃,s₄,state]
obtain ⟨u,hu,he⟩ := Code.increment_exec (2 : Reg) 5 (by decide) s₄ rfl
have h₅ : (Code.increment 2 5).Exec s₄ u
(state (input.drop w) (addr++value++log) (BitWords.inc addr) [] [] []) := by
convert he using 1
funext i; fin_cases i <;> simp [s₄,state]
refine ⟨_,?_,Code.Exec.seq h₁ (Code.Exec.seq h₂ (Code.Exec.seq h₃ (Code.Exec.seq h₄ h₅)))⟩
change u ≤ 10*addr.length+7 at hu
rw [ha] at hu
omega
def packedState (w : ℕ) (input : List Bool) (a : ℕ) : Stacks Reg Bool :=
state (input.drop (w*a)) (SparseLookup.flatten (entries (initialLog w input a)))
(wordBits (address w a)) [] [] []
theorem body_packed (w : ℕ) (input : List Bool) (a : ℕ) (ha : a<2^w) :
∃ u ≤ 50*(w+1), (body w).Exec (packedState w input a) u (packedState w input (a+1)) := by
obtain ⟨u,hu,he⟩ := body_exec w (input.drop (w*a))
(SparseLookup.flatten (entries (initialLog w input a))) (wordBits (address w a)) (by simp [wordBits])
refine ⟨u,hu,?_⟩
convert he using 1 <;> try rfl
unfold packedState
rw [BitWords.inc_address]
have hdrop : (input.drop (w*a)).drop w=input.drop (w*(a+1)) := by simp [List.drop_drop,Nat.mul_add,Nat.add_comm]
rw [hdrop]
rw [show initialLog w input (a+1)=(address w a,RAM.packedWord w input (address w a))::initialLog w input a from rfl]
simp only [entries,SparseLookup.flatten,List.map_cons,List.flatMap_cons]
rw [packed_bits,address_val w a ha]
simp only [chunk,List.append_assoc]
theorem loop_packed (w : ℕ) (input : List Bool) (n : ℕ) (hn : n ≤ 2^w)
(hfinal : input.length ≤ w*n) (hmin : ∀ a < n, w*a < input.length) (t a : ℕ) (hat : a+t=n) :
∃ u ≤ 51*(w+1)*t+1, (loopCode w).Exec (packedState w input a) u (packedState w input n) := by
induction t generalizing a with
| zero =>
have han : a=n := by omega
subst a
refine ⟨1,by omega,Code.Exec.loop_false ?_⟩
simp [running,Code.nonempty,tops,packedState,state,List.drop_eq_nil_of_le hfinal]
| succ t ih =>
have han : a<n := by omega
obtain ⟨u,hu,he⟩ := body_packed w input a (by omega)
obtain ⟨v,hv,hh⟩ := ih (a+1) (by omega)
have hp : running (tops (packedState w input a))=true := by
simpa [running,Code.nonempty,tops,packedState,state,Option.isSome_iff_ne_none] using hmin a han
refine ⟨_,?_,Code.Exec.loop_true hp he hh⟩
nlinarith
theorem program_exec (w : ℕ) (hw : 0<w) (input : List Bool) (hfit : input.length ≤ w*2^w) :
∃ n ≤ input.length, (fun q => read q (initialLog w input n))=RAM.packedWord w input ∧
∃ u ≤ 60*(w+1)*(input.length+1), (program w).Exec (state input [] [] [] [] []) u
(state [] (SparseLookup.flatten (entries (initialLog w input n))) [] [] [] []) := by
obtain ⟨n,hn,hfinal,hmin⟩ := number_of_chunks w hw input
have hlimit : n ≤ 2^w := by
by_contra h
have ht := hmin (2^w) (by omega)
omega
refine ⟨n,hn,initialLog_correct w input n hlimit hfinal,?_⟩
have hinit : (Code.pushList 2 (List.replicate w false)).Exec (state input [] [] [] [] []) (2*w+1) (packedState w input 0) := by
have he := Code.pushList_exec (2 : Reg) (List.replicate w false) (state input [] [] [] [] [])
convert he using 1
· simp
· funext i; fin_cases i <;> simp [packedState,state,initialLog,entries,SparseLookup.flatten,address,wordBits,List.ofFn_const]
obtain ⟨u,hu,he⟩ := loop_packed w input n hlimit hfinal hmin n 0 (by omega)
have hclear : (Code.clear 2).Exec (packedState w input n) (3*w+1)
(state [] (SparseLookup.flatten (entries (initialLog w input n))) [] [] [] []) := by
have hh := Code.clear_exec (2 : Reg) (packedState w input n)
convert hh using 1
· simp [packedState,state,wordBits]
· funext i; fin_cases i <;> simp [packedState,state,List.drop_eq_nil_of_le hfinal]
refine ⟨_,?_,Code.Exec.seq hinit (Code.Exec.seq he hclear)⟩
nlinarith
theorem body_size (w : ℕ) : (body w).controlSize ≤ 4*w+100 := by
simp [body,Code.controlSize,Code.takeN_size,Code.relabel_controlSize,SparseStore.program,
Code.copy,Code.transfer,Code.distribute,Code.clear,Code.increment,Code.carryCode,Code.raiseCode]
theorem program_size (w : ℕ) : (program w).controlSize ≤ 6*w+110 := by
have hb := body_size w
simp only [program,loopCode,Code.controlSize,Code.pushList_size,List.length_replicate,Code.clear]
omega
end WLTime.RAMInput
namespace WLTime.TypedStack.Code
variable {A : Type uA} {B : Type uB}
theorem readN_all (z : A) (xs : List A) : readN z xs xs.length=xs := by
apply List.ext_getElem
· simp [readN]
· intro i hi hj
simp only [readN,List.getElem_ofFn]
exact List.getD_eq_getElem _ _ hj
theorem readN_map (z : A) (f : A → B) (xs : List A) (n : ℕ) :
readN (f z) (xs.map f) n=(readN z xs n).map f := by
apply List.ext_getElem
· simp [readN]
· intro i hi hj
simp only [readN,List.getElem_ofFn,List.getElem_map]
exact List.getD_map _ _ _
end WLTime.TypedStack.Code
namespace WLTime.TMPort
open TypedStack
variable (M : TM)
abbrev Letter := Bool ⊕ TMTransducer.Letter M
abbrev Reg := Fin 3 ⊕ TMTransducer.Reg M
def port : Reg M := .inl 0
def temp : Reg M := .inl 1
def result : Reg M := .inl 2
def tapeIn : Reg M := .inr (.inr (TMTransducer.zeroTape M,true))
def inputSymbol : Letter M → Letter M
| .inl b => .inr (.inl (M.symbol b))
| _ => .inr (.inl (TMStack.blank M))
def outputSymbol : Letter M → Letter M
| .inr (.inl a) => .inl (decide (a.val=2))
| _ => .inl false
def unletter : Letter M → TMTransducer.Letter M
| .inr a => a
| _ => .inl (TMStack.blank M)
def inputState (xs : List Bool) : Stacks (Reg M) (Letter M) :=
fun k => if k=port M then xs.map Sum.inl else []
def innerState (q : Fin M.states) (s : Fin M.tapes → TapePair.Tape (Fin M.symbols)) (ds : List Move) : Stacks (Reg M) (Letter M) :=
Sum.elim (fun _ => []) (Code.listMap Sum.inr (TMTransducer.store M q s ds))
def load (n : ℕ) : Code (Reg M) (Letter M) :=
.seq (.takeN (port M) (temp M) (inputSymbol M) (.inl false) n)
(.seq (.transfer (temp M) (tapeIn M) (.inl false))
(.push (.inr (TMTransducer.stateReg M)) (.inr (.inr (.inl ⟨0,by have := M.states_ge; omega⟩)))))
noncomputable def runCode : Code (Reg M) (Letter M) :=
((TMTransducer.runCode M).mapLetters Sum.inr (unletter M)).relabel Sum.inr
noncomputable def rewindCode : Code (Reg M) (Letter M) :=
((TMTransducer.rewindCode M).mapLetters Sum.inr (unletter M)).relabel Sum.inr
def extract (n : ℕ) : Code (Reg M) (Letter M) :=
.seq (.takeN (tapeIn M) (result M) (outputSymbol M) (.inr (.inl (TMStack.blank M))) n)
(.transfer (result M) (port M) (.inl false))
theorem load_exec (xs : List Bool) : (load M xs.length).Exec (inputState M xs) (9*xs.length+4)
(innerState M (M.initial xs).state (TMStack.initialTapes M xs) []) := by
have he := Code.takeN_exec (port M) (temp M) (by simp [port,temp]) (inputSymbol M) (.inl false) xs.length (inputState M xs)
have hr : Code.readN (.inl false) (inputState M xs (port M)) xs.length=xs.map Sum.inl := by
rw [inputState,ite_eq_left rfl]
rw [←List.length_map (f:=Sum.inl) (as:=xs)]
exact Code.readN_all _ _
have hm : (xs.map Sum.inl).map (inputSymbol M)=(xs.map M.symbol).map (fun a => Sum.inr (Sum.inl a)) := by
simp only [List.map_map]; rfl
rw [hr,hm] at he
let mid := Function.update (Function.update (inputState M xs) (port M) []) (temp M)
(((xs.map M.symbol).map (fun a => Sum.inr (Sum.inl a))).reverse)
have he' : (Code.takeN (port M) (temp M) (inputSymbol M) (.inl false) xs.length).Exec (inputState M xs) (4*xs.length+1) mid := by
simpa [mid,inputState,port,temp,←List.map_drop] using he
have ht := Code.transfer_exec (temp M) (tapeIn M) (by simp [temp,tapeIn]) (.inl false) mid
let after := Function.update (Function.update mid (temp M) []) (tapeIn M) ((mid (temp M)).reverse++mid (tapeIn M))
have hp := Code.Exec.push after (.inr (TMTransducer.stateReg M)) (.inr (.inr (.inl (M.initial xs).state)))
have hex := Code.Exec.seq he' (Code.Exec.seq ht hp)
have hout : Function.update after (.inr (TMTransducer.stateReg M))
(.inr (.inr (.inl (M.initial xs).state))::after (.inr (TMTransducer.stateReg M)))=
innerState M (M.initial xs).state (TMStack.initialTapes M xs) [] := by
funext k
cases k with
| inl i => fin_cases i <;> simp [after,mid,inputState,innerState,port,temp,tapeIn,TMTransducer.stateReg]
| inr k => cases k with
| inl i => fin_cases i <;> simp [after,mid,inputState,innerState,port,temp,tapeIn,TMTransducer.stateReg,TMTransducer.store,Code.listMap]
| inr k =>
rcases k with ⟨a,b⟩
by_cases ha : a=TMTransducer.zeroTape M
· subst a
cases b <;> simp [after,mid,inputState,innerState,port,temp,tapeIn,TMTransducer.stateReg,TMTransducer.store,Code.listMap,TMStack.store,TMStack.initialTapes,TMTransducer.zeroTape,List.map_map,Function.comp_def]
· have hv : a.val≠0 := fun h => ha (Fin.ext h)
cases b <;> simp [after,mid,inputState,innerState,port,temp,tapeIn,TMTransducer.stateReg,TMTransducer.store,Code.listMap,TMStack.store,TMStack.initialTapes,hv,TMTransducer.zeroTape,Function.update_apply]
; simp_all [Fin.ext_iff]
rw [hout] at hex
convert hex using 1
· rfl
· simp [mid]; omega
theorem run_exec (input output : List Bool) (ho : M.outputs input output) :
∃u ≤ TMTransducer.stepFactor M*M.time input+1,∃s ds,
(runCode M).Exec (innerState M (M.initial input).state (TMStack.initialTapes M input) []) u
(innerState M (M.run input (M.time input)).state s ds) ∧
TMStack.Relative M (M.run input (M.time input)) s ∧ ds.length ≤ M.time input ∧
(M.run input (M.time input)).head (TMTransducer.zeroTape M)=(ds.map Move.displacement).sum := by
obtain ⟨u,hu,s,ds,he,hr,hlen,hh⟩ := TMTransducer.run_exec M (M.initial input)
(TMStack.initialTapes M input) [] (M.time input) (TMStack.initial_relative M input)
(M.time_halted input ho.1)
refine ⟨u,hu,s,ds,?_,hr,by simpa using hlen,by simpa only [TM.initial,List.map_nil,List.sum_nil,sub_zero,zero_add,TM.run,TMTransducer.zeroTape] using hh⟩
exact Code.relabel_inr_exec (Code.mapLetters_exec Sum.inr (unletter M) (by intro a; rfl) he) (fun _ : Fin 3 => [])
theorem rewind_exec (q : Fin M.states) (s : Fin M.tapes → TapePair.Tape (Fin M.symbols)) (ds : List Move) :
∃u ≤ TMTransducer.rewindFactor M*ds.length+1,(rewindCode M).Exec (innerState M q s ds) u
(innerState M q (TMTransducer.rewindTapes M s ds) []) := by
obtain ⟨u,hu,he⟩ := TMTransducer.rewind_exec M q s ds
exact ⟨u,hu,Code.relabel_inr_exec (Code.mapLetters_exec Sum.inr (unletter M) (by intro a; rfl) he) (fun _ : Fin 3 => [])⟩
end WLTime.TMPort
end OAI