import OAI.Computability.WeisfeilerLeman.SparseStore namespace OAI universe uA namespace WLTime.TMPort open TypedStack variable (M : TM) theorem output_symbol (b : Bool) : outputSymbol M (.inr (.inl (M.symbol b)))=.inl b := by cases b <;> simp [outputSymbol,TM.symbol] theorem extract_exec (s : Stacks (Reg M) (Letter M)) (ys : List Bool) (hp : s (port M)=[]) (hr : s (result M)=[]) (hout : Code.readN (.inr (.inl (TMStack.blank M))) (s (tapeIn M)) ys.length= ys.map (fun b => .inr (.inl (M.symbol b)))) : (extract M ys.length).Exec s (9*ys.length+2) (Function.update (Function.update s (tapeIn M) ((s (tapeIn M)).drop ys.length)) (port M) (ys.map Sum.inl)) := by have he := Code.takeN_exec (tapeIn M) (result M) (by simp [tapeIn,result]) (outputSymbol M) (.inr (.inl (TMStack.blank M))) ys.length s have hm : (ys.map (fun b => Sum.inr (Sum.inl (M.symbol b)))).map (outputSymbol M)=ys.map Sum.inl := by simp only [List.map_map] congr 1 funext b exact output_symbol M b rw [hout,hm,hr,List.append_nil] at he let mid := Function.update (Function.update s (tapeIn M) ((s (tapeIn M)).drop ys.length)) (result M) (ys.map Sum.inl).reverse have ht := Code.transfer_exec (result M) (port M) (by simp [result,port]) (.inl false) mid have hh := Code.Exec.seq he ht have hf : Function.update (Function.update mid (result M) []) (port M) ((mid (result M)).reverse++mid (port M))= Function.update (Function.update s (tapeIn M) ((s (tapeIn M)).drop ys.length)) (port M) (ys.map Sum.inl) := by funext k by_cases hkp : k=port M · subst k; simp [mid,port,result,tapeIn,show s (.inl 0)=[] from hp] · by_cases hkr : k=result M · subst k; simp [mid,port,result,tapeIn,show s (.inl 2)=[] from hr] · simp [mid,hkp,hkr] rw [hf] at hh convert hh using 1 · rfl · simp [mid]; omega theorem extract_inner (input output : List Bool) (ho : M.outputs input output) (s : Fin M.tapes → TapePair.Tape (Fin M.symbols)) (ds : List Move) (hr : TMStack.Relative M (M.run input (M.time input)) s) (hh : (M.run input (M.time input)).head (TMTransducer.zeroTape M)=(ds.map Move.displacement).sum) : Code.readN (.inr (.inl (TMStack.blank M))) (innerState M (M.run input (M.time input)).state (TMTransducer.rewindTapes M s ds) [] (tapeIn M)) output.length= output.map (fun b => .inr (.inl (M.symbol b))) := by have h := TMTransducer.output_prefix M input output ho s ds hr hh change Code.readN _ (((TMTransducer.rewindTapes M s ds (TMTransducer.zeroTape M)).right.map Sum.inl).map Sum.inr) _=_ rw [Code.readN_map,Code.readN_map,h] simp only [List.map_map] rfl end WLTime.TMPort namespace WLTime.TMPort open TypedStack open scoped Classical variable (M : TM) noncomputable def privateRegs : List (Reg M) := (Finset.univ : Finset (TMTransducer.Reg M)).toList.map Sum.inr noncomputable def program (n o : ℕ) : Code (Reg M) (Letter M) := .seq (load M n) (.seq (runCode M) (.seq (rewindCode M) (.seq (extract M o) (.clearList (privateRegs M))))) noncomputable def factor : ℕ := 50+4*(TMTransducer.stepFactor M+TMTransducer.rewindFactor M)+Fintype.card (TMTransducer.Reg M) theorem input_mass (xs : List Bool) : Code.mass (inputState M xs)=xs.length := by unfold Code.mass inputState rw [Finset.sum_eq_single (port M)] · simp · intro b hb hne; simp [hne] · simp theorem private_nodup : (privateRegs M).Nodup := by exact (Finset.nodup_toList (Finset.univ : Finset (TMTransducer.Reg M))).map Sum.inr_injective theorem private_mem (k : Reg M) : k∈privateRegs M ↔ ∃r,k=Sum.inr r := by simp [privateRegs,eq_comm] theorem cleanup (q : Fin M.states) (s : Fin M.tapes → TapePair.Tape (Fin M.symbols)) (ds : List Move) (ys : List Bool) : Code.cleared (privateRegs M) (Function.update (Function.update (innerState M q s ds) (tapeIn M) ((innerState M q s ds (tapeIn M)).drop ys.length)) (port M) (ys.map Sum.inl))=inputState M ys := by funext k cases k with | inl i => have hn : (Sum.inl i : Reg M)∉privateRegs M := by rw [private_mem]; simp simp only [Code.cleared,ite_eq_right hn,inputState] by_cases h : (Sum.inl i : Reg M)=port M · rw [ite_eq_left h,h,Function.update_self] · rw [ite_eq_right h,Function.update_of_ne h,Function.update_of_ne (show (Sum.inl i : Reg M)≠tapeIn M from Sum.inl_ne_inr)] rfl | inr r => have hn : (Sum.inr r : Reg M)∈privateRegs M := by rw [private_mem]; exact ⟨r,rfl⟩ simp only [Code.cleared,ite_eq_left hn,inputState,port,Sum.inr_ne_inl,ite_false] theorem program_exec (input output : List Bool) (ho : M.outputs input output) : ∃u ≤ factor M*(input.length+M.time input+output.length+1), (program M input.length output.length).Exec (inputState M input) u (inputState M output) := by have hl := load_exec M input obtain ⟨a,ha,s,ds,he,hr,hd,hh⟩ := run_exec M input output ho obtain ⟨b,hb,hf⟩ := rewind_exec M (M.run input (M.time input)).state s ds let z := innerState M (M.run input (M.time input)).state (TMTransducer.rewindTapes M s ds) [] have hg := extract_exec M z output rfl rfl (extract_inner M input output ho s ds hr hh) let out := Function.update (Function.update z (tapeIn M) ((z (tapeIn M)).drop output.length)) (port M) (output.map Sum.inl) have hpre := Code.Exec.seq hl (Code.Exec.seq he (Code.Exec.seq hf hg)) have hmass := Code.mass_exec hpre rw [input_mass] at hmass have hs := Code.clearList_cost (privateRegs M) out (private_nodup M) have hc := Code.clearList_exec (privateRegs M) out (private_nodup M) rw [cleanup] at hc have hfull := Code.Exec.seq hl (Code.Exec.seq he (Code.Exec.seq hf (Code.Exec.seq hg hc))) refine ⟨_,?_,hfull⟩ have hlen : (privateRegs M).length=Fintype.card (TMTransducer.Reg M) := by simp [privateRegs] rw [hlen] have hbb := (Nat.mul_le_mul_left (TMTransducer.rewindFactor M) hd) have hbound : a+b ≤ (TMTransducer.stepFactor M+TMTransducer.rewindFactor M)*M.time input+2 := by nlinarith only [ha,hb,hbb] change Code.mass out ≤ input.length+(9*input.length+4+(a+(b+(9*output.length+2)))) at hmass dsimp only [factor] nlinarith only [hmass,hs,hbound,Nat.zero_le ((TMTransducer.stepFactor M+TMTransducer.rewindFactor M)*(input.length+output.length+1)), Nat.zero_le (Fintype.card (TMTransducer.Reg M)*(input.length+M.time input+output.length))] theorem size_load (n : ℕ) : (load M n).controlSize=4*n+8 := by simp only [load,Code.controlSize,Code.takeN_size,Code.transfer] theorem size_extract (n : ℕ) : (extract M n).controlSize=4*n+6 := by simp only [extract,Code.controlSize,Code.takeN_size,Code.transfer] noncomputable def sizeFactor : ℕ := 14+(runCode M).controlSize+(rewindCode M).controlSize+(Code.clearList (privateRegs M) : Code (Reg M) (Letter M)).controlSize theorem program_size (n o : ℕ) : (program M n o).controlSize ≤ sizeFactor M*(n+o+1) := by simp only [program,Code.controlSize,size_load,size_extract,sizeFactor] nlinarith end WLTime.TMPort namespace WLTime.TypedStack.Code variable {A : Type uA} theorem readN_prefix (z : A) (xs tail : List A) : readN z (xs++tail) xs.length=xs := by apply List.ext_getElem · simp [readN] · intro i hi hj simp only [readN,List.getElem_ofFn,List.getD_eq_getElem?_getD] rw [List.getElem?_append_left hj,List.getElem?_eq_getElem hj] rfl end WLTime.TypedStack.Code namespace WLTime.RAMSlices open TypedStack abbrev Reg := Fin 4 def state (file value pre tmp : List Bool) : Stacks Reg Bool := ![file,value,pre,tmp] def read (offset len : ℕ) : Code Reg Bool := .seq (.copy 0 2 3 false) (.seq (.takeN 2 3 id false offset) (.seq (.clear 3) (.seq (.takeN 2 3 id false len) (.seq (.clear 2) (.transfer 3 1 false))))) def write (offset len : ℕ) : Code Reg Bool := .seq (.takeN 0 2 id false offset) (.seq (.takeN 0 3 id false len) (.seq (.clear 3) (.seq (.moveList 1 0 3 false) (.transfer 2 0 false)))) theorem read_exec (pre value post : List Bool) : ∃ u ≤ 60*((pre++value++post).length+1), (read pre.length value.length).Exec (state (pre++value++post) [] [] []) u (state (pre++value++post) value [] []) := by let file := pre++value++post let s₀ := state file [] [] [] let s₁ := state file [] file [] let s₂ := state file [] (value++post) pre.reverse let s₃ := state file [] (value++post) [] let s₄ := state file [] post value.reverse let s₅ := state file [] [] value.reverse have h₁ : (Code.copy 0 2 3 false).Exec s₀ (12*file.length+2) s₁ := by have he := Code.copy_exec (0 : Reg) 2 3 (by decide) (by decide) (by decide) false s₀ rfl convert he using 1 <;> try rfl funext i; fin_cases i <;> simp [s₀,s₁,state] have h₂ : (Code.takeN 2 3 id false pre.length).Exec s₁ (4*pre.length+1) s₂ := by have he := Code.takeN_exec (2 : Reg) 3 (by decide) id false pre.length s₁ convert he using 1 funext i; fin_cases i <;> simp [s₁,s₂,state,file,List.append_assoc,Code.readN_prefix] have h₃ : (Code.clear 3).Exec s₂ (3*pre.length+1) s₃ := by have he := Code.clear_exec (3 : Reg) s₂ convert he using 1 · simp [s₂,state] · funext i; fin_cases i <;> simp [s₂,s₃,state] have h₄ : (Code.takeN 2 3 id false value.length).Exec s₃ (4*value.length+1) s₄ := by have he := Code.takeN_exec (2 : Reg) 3 (by decide) id false value.length s₃ convert he using 1 funext i; fin_cases i <;> simp [s₃,s₄,state,Code.readN_prefix] have h₅ : (Code.clear 2).Exec s₄ (3*post.length+1) s₅ := by have he := Code.clear_exec (2 : Reg) s₄ convert he using 1 · rfl · funext i; fin_cases i <;> simp [s₄,s₅,state] have h₆ : (Code.transfer 3 1 false).Exec s₅ (5*value.length+1) (state file value [] []) := by have he := Code.transfer_exec (3 : Reg) 1 (by decide) false s₅ convert he using 1 · simp [s₅,state] · 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₄ (Code.Exec.seq h₅ h₆))))⟩ simp only [file,List.length_append] omega theorem write_exec (pre old post value : List Bool) (hlen : value.length=old.length) : ∃ u ≤ 30*((pre++old++post).length+1), (write pre.length old.length).Exec (state (pre++old++post) value [] []) u (state (pre++value++post) [] [] []) := by let s₀ := state (pre++old++post) value [] [] let s₁ := state (old++post) value pre.reverse [] let s₂ := state post value pre.reverse old.reverse let s₃ := state post value pre.reverse [] let s₄ := state (value++post) [] pre.reverse [] have h₁ : (Code.takeN 0 2 id false pre.length).Exec s₀ (4*pre.length+1) s₁ := by have he := Code.takeN_exec (0 : Reg) 2 (by decide) id false pre.length s₀ convert he using 1 funext i; fin_cases i <;> simp [s₀,s₁,state,List.append_assoc,Code.readN_prefix] have h₂ : (Code.takeN 0 3 id false old.length).Exec s₁ (4*old.length+1) s₂ := by have he := Code.takeN_exec (0 : Reg) 3 (by decide) id false old.length s₁ convert he using 1 funext i; fin_cases i <;> simp [s₁,s₂,state,Code.readN_prefix] have h₃ : (Code.clear 3).Exec s₂ (3*old.length+1) s₃ := by have he := Code.clear_exec (3 : Reg) s₂ convert he using 1 · simp [s₂,state] · funext i; fin_cases i <;> simp [s₂,s₃,state] have h₄ : (Code.moveList 1 0 3 false).Exec s₃ (10*value.length+2) s₄ := by have he := Code.moveList_exec (1 : Reg) 0 3 (by decide) (by decide) (by decide) false s₃ rfl convert he using 1 <;> try rfl funext i; fin_cases i <;> simp [s₃,s₄,state] have h₅ : (Code.transfer 2 0 false).Exec s₄ (5*pre.length+1) (state (pre++value++post) [] [] []) := by have he := Code.transfer_exec (2 : Reg) 0 (by decide) false s₄ convert he using 1 · simp [s₄,state] · funext i; fin_cases i <;> simp [s₄,state,List.append_assoc] refine ⟨_,?_,Code.Exec.seq h₁ (Code.Exec.seq h₂ (Code.Exec.seq h₃ (Code.Exec.seq h₄ h₅)))⟩ simp only [List.length_append] omega theorem read_size (offset len : ℕ) : (read offset len).controlSize ≤ 4*(offset+len)+40 := by simp [read,Code.controlSize,Code.takeN_size,Code.copy,Code.transfer,Code.distribute,Code.clear] omega theorem write_size (offset len : ℕ) : (write offset len).controlSize ≤ 4*(offset+len)+30 := by simp [write,Code.controlSize,Code.takeN_size,Code.moveList,Code.transfer,Code.clear] omega end WLTime.RAMSlices namespace WLTime.RegisterFile theorem flatten_length {A : Type uA} (w : ℕ) (xs : List (List A)) (hx : ∀ x ∈ xs,x.length=w) : xs.flatten.length=w*xs.length := by induction xs with | nil => simp | cons x xs ih => have hh := hx x (by simp) have ht := ih (fun a ha => hx a (by simp [ha])) simp only [List.flatten_cons,List.length_append,List.length_cons,hh,ht] ring theorem length {R w : ℕ} (a : Fin R → Word w) : (registerBits a).length=R*w := by unfold registerBits rw [flatten_length w _ (by intro xs hx; obtain ⟨i,rfl⟩ := List.mem_ofFn.mp hx; simp [wordBits])] simp [Nat.mul_comm] theorem zero (R w : ℕ) : registerBits (fun _ : Fin R => (⟨0,by positivity⟩ : Word w))=List.replicate (R*w) false := by simp [registerBits,wordBits,List.ofFn_const] theorem update_list {R w : ℕ} (a : Fin R → Word w) (i : Fin R) (v : Word w) : (List.ofFn (fun j => wordBits (Function.update a i v j)))= (List.ofFn (fun j => wordBits (a j))).set i.val (wordBits v) := by apply List.ext_getElem · simp · intro j hj hj' simp only [List.getElem_ofFn,List.getElem_set] by_cases h : j=i.val · subst j simp · have hh : (⟨j,by simpa using hj⟩ : Fin R)≠i := by simpa [Fin.ext_iff] using h simp [Ne.symm h,hh] theorem split {R w : ℕ} (a : Fin R → Word w) (i : Fin R) : ∃ pre post : List Bool, pre.length=w*i.val ∧ registerBits a=pre++wordBits (a i)++post ∧ ∀ v : Word w,registerBits (Function.update a i v)=pre++wordBits v++post := by let xs := List.ofFn (fun j => wordBits (a j)) have hi : i.val hw x (List.mem_of_mem_take hx)),List.length_take] rw [Nat.min_eq_left (Nat.le_of_lt hi)] · change xs.flatten=_ conv_lhs => rw [hs] simp only [List.flatten_append,List.flatten_cons,List.append_assoc] simp only [xs,List.getElem_ofFn] · intro v unfold registerBits rw [update_list,List.set_eq_take_append_cons_drop,ite_eq_left (by simp)] simp only [List.flatten_append,List.flatten_cons,List.append_assoc] rfl end WLTime.RegisterFile namespace WLTime.RAMMemory open TypedStack WordMemory abbrev Reg := Fin 12 def state (file log key value : List Bool) : Stacks Reg Bool := ![file,log,key,value,[],[],[],[],[],[],[],[]] def keyMap : RAMSlices.Reg → Reg := ![0,2,4,5] def valueMap : RAMSlices.Reg → Reg := ![0,3,4,5] def lookupMap : SparseLookup.Reg → Reg := ![1,2,3,6,7,8,9,10] def storeMap : SparseStore.Reg → Reg := ![1,2,3,5] theorem keyMap_inj : Function.Injective keyMap := by decide theorem valueMap_inj : Function.Injective valueMap := by decide theorem lookupMap_inj : Function.Injective lookupMap := by decide theorem storeMap_inj : Function.Injective storeMap := by decide noncomputable def readKey (w i : ℕ) : Code Reg Bool := (RAMSlices.read (w*i) w).relabel keyMap noncomputable def readValue (w i : ℕ) : Code Reg Bool := (RAMSlices.read (w*i) w).relabel valueMap noncomputable def writeValue (w i : ℕ) : Code Reg Bool := (RAMSlices.write (w*i) w).relabel valueMap noncomputable def lookup (w : ℕ) : Code Reg Bool := (SparseLookup.program w).relabel lookupMap noncomputable def store : Code Reg Bool := SparseStore.program.relabel storeMap noncomputable def load (w dest addr : ℕ) : Code Reg Bool := .seq (readKey w addr) (.seq (lookup w) (.seq (writeValue w dest) (.clear 2))) noncomputable def save (w addr src : ℕ) : Code Reg Bool := .seq (readKey w addr) (.seq (readValue w src) (.seq store (.seq (.clear 2) (.clear 3)))) theorem readKey_exec {R w : ℕ} (a : Fin R → Word w) (i : Fin R) (log value : List Bool) : ∃ u ≤ 60*(R*w+1), (readKey w i.val).Exec (state (registerBits a) log [] value) u (state (registerBits a) log (wordBits (a i)) value) := by obtain ⟨pre,post,hpre,hs,_⟩ := RegisterFile.split a i obtain ⟨u,hu,he⟩ := RAMSlices.read_exec pre (wordBits (a i)) post rw [←hs,RegisterFile.length] at hu rw [hpre,show (wordBits (a i)).length=w from by simp [wordBits]] at he refine ⟨u,hu,?_⟩ apply Code.relabel_exec_of_maps keyMap keyMap_inj he · intro k; fin_cases k <;> simp [state,keyMap,RAMSlices.state,hs] · intro k; fin_cases k <;> simp [state,keyMap,RAMSlices.state,hs] · intro k hk; fin_cases k <;> simp_all [state,keyMap,Fin.forall_fin_succ] theorem readValue_exec {R w : ℕ} (a : Fin R → Word w) (i : Fin R) (log key : List Bool) : ∃ u ≤ 60*(R*w+1), (readValue w i.val).Exec (state (registerBits a) log key []) u (state (registerBits a) log key (wordBits (a i))) := by obtain ⟨pre,post,hpre,hs,_⟩ := RegisterFile.split a i obtain ⟨u,hu,he⟩ := RAMSlices.read_exec pre (wordBits (a i)) post rw [←hs,RegisterFile.length] at hu rw [hpre,show (wordBits (a i)).length=w from by simp [wordBits]] at he refine ⟨u,hu,?_⟩ apply Code.relabel_exec_of_maps valueMap valueMap_inj he · intro k; fin_cases k <;> simp [state,valueMap,RAMSlices.state,hs] · intro k; fin_cases k <;> simp [state,valueMap,RAMSlices.state,hs] · intro k hk; fin_cases k <;> simp_all [state,valueMap,Fin.forall_fin_succ] theorem writeValue_exec {R w : ℕ} (a : Fin R → Word w) (i : Fin R) (v : Word w) (log key : List Bool) : ∃ u ≤ 30*(R*w+1), (writeValue w i.val).Exec (state (registerBits a) log key (wordBits v)) u (state (registerBits (Function.update a i v)) log key []) := by obtain ⟨pre,post,hpre,hs,ht⟩ := RegisterFile.split a i obtain ⟨u,hu,he⟩ := RAMSlices.write_exec pre (wordBits (a i)) post (wordBits v) (by simp [wordBits]) rw [←hs,RegisterFile.length] at hu rw [hpre,show (wordBits (a i)).length=w from by simp [wordBits]] at he refine ⟨u,hu,?_⟩ apply Code.relabel_exec_of_maps valueMap valueMap_inj he · intro k; fin_cases k <;> simp [state,valueMap,RAMSlices.state,hs] · intro k; fin_cases k <;> simp [state,valueMap,RAMSlices.state,ht] · intro k hk; fin_cases k <;> simp_all [state,valueMap,Fin.forall_fin_succ] theorem lookup_exec {w : ℕ} (hw : 0 simp [state,lookupMap,SparseLookup.state] · intro k; fin_cases k <;> simp [state,lookupMap,SparseLookup.state] · intro k hk; fin_cases k <;> simp_all [state,lookupMap,Fin.forall_fin_succ] theorem store_exec {w : ℕ} (q v : Word w) (l : Log w) (file : List Bool) : store.Exec (state file (SparseLookup.flatten (entries l)) (wordBits q) (wordBits v)) (24*w+4) (state file (SparseLookup.flatten (entries ((q,v)::l))) (wordBits q) (wordBits v)) := by have he := SparseStore.program_exec (SparseLookup.flatten (entries l)) (wordBits q) (wordBits v) have hc : 12*((wordBits q).length+(wordBits v).length)+4=24*w+4 := by simp [wordBits]; omega rw [hc] at he apply Code.relabel_exec_of_maps storeMap storeMap_inj he · intro k; fin_cases k <;> simp [state,storeMap,SparseStore.state] · intro k; fin_cases k <;> simp [state,storeMap,SparseStore.state,entries,SparseLookup.flatten,List.append_assoc] · intro k hk; fin_cases k <;> simp_all [state,storeMap,Fin.forall_fin_succ] theorem clear_key (file log key value : List Bool) : (Code.clear 2).Exec (state file log key value) (3*key.length+1) (state file log [] value) := by have he := Code.clear_exec (2 : Reg) (state file log key value) convert he using 1 <;> try rfl funext k; fin_cases k <;> simp [state] theorem clear_value (file log key value : List Bool) : (Code.clear 3).Exec (state file log key value) (3*value.length+1) (state file log key []) := by have he := Code.clear_exec (3 : Reg) (state file log key value) convert he using 1 <;> try rfl funext k; fin_cases k <;> simp [state] def cost (R w L : ℕ) := 500*(R+1)*(w+1)*(L+1) theorem cost_arith (R w L : ℕ) : 90*(R*w+1)+60*(w+1)*(L+1)+(3*w+1) ≤ cost R w L ∧ 120*(R*w+1)+(24*w+4)+2*(3*w+1) ≤ cost R w 0 := by have h₁ : R*w+1 ≤ (R+1)*(w+1) := by nlinarith have h₂ : (R+1)*(w+1) ≤ (R+1)*(w+1)*(L+1) := Nat.le_mul_of_pos_right _ (by omega) have h₃ : (w+1)*(L+1) ≤ (R+1)*(w+1)*(L+1) := Nat.mul_le_mul_right _ (by nlinarith) have h₄ : w+1 ≤ (R+1)*(w+1) := by nlinarith unfold cost constructor <;> nlinarith only [h₁,h₂,h₃,h₄] theorem load_exec {R w : ℕ} (hw : 0