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