lean/OAI/Computability/WeisfeilerLeman/RAMMemory.lean

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<xs.length := by simp [xs]
  have hw : ∀x∈xs,x.length=w := by
    intro x hx
    obtain ⟨j,rfl⟩ := List.mem_ofFn.mp hx
    simp [wordBits]
  have hs : xs=xs.take i.val++xs[i.val]::xs.drop (i.val+1) := by
    have h := List.take_append_drop i.val xs
    rw [List.drop_eq_getElem_cons hi] at h
    exact h.symm
  refine ⟨(xs.take i.val).flatten,(xs.drop (i.val+1)).flatten,?_,?_,?_⟩
  · rw [flatten_length w _ (fun x hx => 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<w) (q : Word w) (l : Log w) (file : List Bool) :
    ∃ u ≤ 60*(w+1)*(l.length+1), (lookup w).Exec (state file (SparseLookup.flatten (entries l)) (wordBits q) []) u
      (state file (SparseLookup.flatten (entries l)) (wordBits q) (wordBits (read q l))) := by
  obtain ⟨u,hu,he⟩ := WordMemory.lookup_exec hw q l
  refine ⟨u,hu,?_⟩
  apply Code.relabel_exec_of_maps lookupMap lookupMap_inj he
  · intro k; fin_cases k <;> 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<w) (a : Fin R → Word w) (l : Log w) (dest addr : Fin R) :
    ∃ u ≤ cost R w l.length, (load w dest.val addr.val).Exec (state (registerBits a) (SparseLookup.flatten (entries l)) [] []) u
      (state (registerBits (Function.update a dest (read (a addr) l))) (SparseLookup.flatten (entries l)) [] []) := by
  obtain ⟨x,hx,he⟩ := readKey_exec a addr (SparseLookup.flatten (entries l)) []
  obtain ⟨y,hy,hf⟩ := lookup_exec hw (a addr) l (registerBits a)
  obtain ⟨z,hz,hg⟩ := writeValue_exec a dest (read (a addr) l) (SparseLookup.flatten (entries l)) (wordBits (a addr))
  have hh := clear_key (registerBits (Function.update a dest (read (a addr) l))) (SparseLookup.flatten (entries l)) (wordBits (a addr)) []
  have hc := (cost_arith R w l.length).1
  refine ⟨_,?_,Code.Exec.seq he (Code.Exec.seq hf (Code.Exec.seq hg hh))⟩
  simp only [wordBits,List.length_ofFn]
  omega
 theorem save_exec {R w : ℕ} (a : Fin R → Word w) (l : Log w) (addr src : Fin R) :
    ∃ u ≤ cost R w 0, (save w addr.val src.val).Exec (state (registerBits a) (SparseLookup.flatten (entries l)) [] []) u
      (state (registerBits a) (SparseLookup.flatten (entries ((a addr,a src)::l))) [] []) := by
  obtain ⟨x,hx,he⟩ := readKey_exec a addr (SparseLookup.flatten (entries l)) []
  obtain ⟨y,hy,hf⟩ := readValue_exec a src (SparseLookup.flatten (entries l)) (wordBits (a addr))
  have hg := store_exec (a addr) (a src) l (registerBits a)
  have hh := clear_key (registerBits a) (SparseLookup.flatten (entries ((a addr,a src)::l))) (wordBits (a addr)) (wordBits (a src))
  have hj := clear_value (registerBits a) (SparseLookup.flatten (entries ((a addr,a src)::l))) [] (wordBits (a src))
  have hc := (cost_arith R w 0).2
  refine ⟨_,?_,Code.Exec.seq he (Code.Exec.seq hf (Code.Exec.seq hg (Code.Exec.seq hh hj)))⟩
  simp only [wordBits,List.length_ofFn]
  omega
 theorem load_size (R w : ℕ) (dest addr : Fin R) : (load w dest.val addr.val).controlSize ≤ cost R w 0 := by
  have h₁ := RAMSlices.read_size (w*addr.val) w
  have h₂ := RAMSlices.write_size (w*dest.val) w
  have h₃ := SparseLookup.program_size w
  have ha : w*addr.val ≤ w*R := Nat.mul_le_mul_left _ (Nat.le_of_lt addr.isLt)
  have hd : w*dest.val ≤ w*R := Nat.mul_le_mul_left _ (Nat.le_of_lt dest.isLt)
  simp only [load,readKey,writeValue,lookup,Code.controlSize,Code.relabel_controlSize,Code.clear]
  unfold cost
  nlinarith
 theorem save_size (R w : ℕ) (addr src : Fin R) : (save w addr.val src.val).controlSize ≤ cost R w 0 := by
  have h₁ := RAMSlices.read_size (w*addr.val) w
  have h₂ := RAMSlices.read_size (w*src.val) w
  have ha : w*addr.val ≤ w*R := Nat.mul_le_mul_left _ (Nat.le_of_lt addr.isLt)
  have hd : w*src.val ≤ w*R := Nat.mul_le_mul_left _ (Nat.le_of_lt src.isLt)
  simp only [save,readKey,readValue,store,Code.controlSize,Code.relabel_controlSize,Code.clear,
    SparseStore.program,Code.copy,Code.transfer,Code.distribute]
  unfold cost
  nlinarith
end WLTime.RAMMemory

end OAI