import OAI.Computability.WeisfeilerLeman.Transducer

namespace OAI

universe uK uA

namespace WLTime.BitWords
 def value (xs : List Bool) : ℕ := Nat.ofDigits 2 (xs.map Bool.toNat)
 @[simp] theorem value_nil : value []=0 := rfl
 @[simp] theorem value_cons (b : Bool) (xs : List Bool) : value (b::xs)=b.toNat+2*value xs := rfl
 theorem value_ofFn {w : ℕ} (f : Fin w → Bool) : value (List.ofFn f)=Nat.ofBits f := by
  induction w with
  | zero => simp [value]
  | succ w ih =>
    rw [List.ofFn_succ,value_cons,Nat.ofBits_succ,ih]
    dsimp only [Function.comp_def]
    omega
 theorem value_lt (xs : List Bool) : value xs<2^xs.length := by
  rw [←List.ofFn_get xs,value_ofFn]
  simpa only [List.length_ofFn] using Nat.ofBits_lt_two_pow xs.get
 theorem value_word {w : ℕ} (a : Word w) : value (wordBits a)=a.val := by
  rw [wordBits,value_ofFn,Nat.ofBits_testBit,Nat.mod_eq_of_lt a.isLt]
 theorem testBit_value (xs : List Bool) (i : ℕ) : (value xs).testBit i=xs.getD i false := by
  rw [←List.ofFn_get xs,value_ofFn,Nat.testBit_ofBits]
  simp only [List.ofFn_get]
  split_ifs with h
  · change xs[i]=xs.getD i false
    exact (List.getD_eq_getElem _ _ h).symm
  · exact (List.getD_eq_default xs false (Nat.le_of_not_gt h)).symm
 theorem word_of_value (xs : List Bool) : wordBits (⟨value xs,value_lt xs⟩ : Word xs.length)=xs := by
  apply List.ext_getElem
  · simp [wordBits]
  · intro i hi hj
    simp only [wordBits,List.getElem_ofFn,testBit_value]
    exact List.getD_eq_getElem _ _ hj
 def inc : List Bool → List Bool
  | [] => []
  | false::xs => true::xs
  | true::xs => false::inc xs
 @[simp] theorem length_inc (xs : List Bool) : (inc xs).length=xs.length := by
  induction xs with
  | nil => rfl
  | cons b xs ih => cases b <;> simp [inc,ih]
 theorem inc_value (xs : List Bool) : value (inc xs)=(value xs+1)%2^xs.length := by
  induction xs with
  | nil => simp [inc]
  | cons b xs ih =>
    cases b
    · have hx := value_lt xs
      simp only [inc,value_cons,Bool.toNat_false,Bool.toNat_true,List.length_cons,pow_succ]
      rw [Nat.mod_eq_of_lt (by omega)]
      omega
    · simp only [inc,value_cons,Bool.toNat_false,Bool.toNat_true,List.length_cons,pow_succ,ih,zero_add]
      have he : 1+2*value xs+1=2*(value xs+1) := by omega
      rw [he,Nat.mul_comm (2^xs.length) 2,Nat.mul_mod_mul_left]
 theorem word_injective {w : ℕ} : Function.Injective (wordBits (w:=w)) := by
  intro a b h
  apply Fin.ext
  simpa only [value_word] using congrArg value h
end WLTime.BitWords

namespace WLTime.BitWords
 def carry : List Bool → ℕ
  | true::xs => carry xs+1
  | _ => 0
 def rest : List Bool → List Bool
  | true::xs => rest xs
  | xs => xs
 def raise : List Bool → List Bool
  | [] => []
  | _::xs => true::xs
 theorem carry_le (xs : List Bool) : carry xs≤xs.length := by
  induction xs with
  | nil => rfl
  | cons b xs ih => cases b <;> simp [carry]; omega
 theorem inc_decompose (xs : List Bool) : inc xs=List.replicate (carry xs) false++raise (rest xs) := by
  induction xs with
  | nil => rfl
  | cons b xs ih => cases b <;> simp [inc,carry,rest,raise,ih,List.replicate_succ]
end WLTime.BitWords
namespace WLTime.TypedStack.Code
open BitWords
variable {K : Type uK} [DecidableEq K]
def carryCode (a b : K) : Code K Bool :=
  .loop (fun v => v a==some true) (.seq (.pop a) (.push b false))
def raiseCode (a : K) : Code K Bool :=
  .branch (nonempty a) (.seq (.pop a) (.push a true)) .skip
def increment (a b : K) : Code K Bool :=
  .seq (carryCode a b) (.seq (raiseCode a) (.transfer b a false))
 theorem carryCode_exec (a b : K) (hab : a≠b) (s : Stacks K Bool) :
    (carryCode a b).Exec s (5*carry (s a)+1)
      (Function.update (Function.update s a (rest (s a))) b (List.replicate (carry (s a)) false++s b)) := by
  generalize hx : s a=xs
  induction xs generalizing s with
  | nil =>
    have hout : Function.update (Function.update s a (rest [])) b (List.replicate (carry []) false++s b)=s := by
      simp only [rest,carry,List.replicate_zero,List.nil_append]
      rw [←hx,Function.update_eq_self,Function.update_eq_self]
    rw [hout]
    exact .loop_false (by simp [tops,hx])
  | cons x xs ih =>
    cases x
    · have hout : Function.update (Function.update s a (rest (false::xs))) b (List.replicate (carry (false::xs)) false++s b)=s := by
        simp only [rest,carry,List.replicate_zero,List.nil_append]
        rw [←hx,Function.update_eq_self,Function.update_eq_self]
      rw [hout]
      exact .loop_false (by simp [tops,hx])
    · let mid := Function.update (Function.update s a xs) b (false::s b)
      have hb : (Code.seq (.pop a) (.push b false)).Exec s 4 mid := by
        simpa only [hx,List.tail_cons,Function.update_of_ne hab.symm,mid] using
          Exec.seq (Exec.pop s a) (Exec.push (Function.update s a (s a).tail) b false)
      have hs : mid a=xs := by simp [mid,hab]
      have hh := ih mid hs
      have hout : Function.update (Function.update mid a (rest xs)) b (List.replicate (carry xs) false++mid b)=
          Function.update (Function.update s a (rest (true::xs))) b (List.replicate (carry (true::xs)) false++s b) := by
        funext k
        by_cases hk : k=b
        · subst k
          simp only [Function.update_self,mid,carry]
          rw [List.replicate_succ']
          simp only [List.append_assoc,List.singleton_append]
        · by_cases ha : k=a
          · subst k; simp [mid,hk,rest]
          · simp [mid,hk,ha]
      rw [hout] at hh
      have he := Exec.loop_true (p:=fun v : Tops K Bool => v a==some true) (by simp [tops,hx]) hb hh
      convert he using 1
      · rfl
      · simp [carry]; omega
 theorem raiseCode_exec (a : K) (s : Stacks K Bool) :
    ∃u≤5,(raiseCode a).Exec s u (Function.update s a (raise (s a))) := by
  cases hx : s a with
  | nil =>
    refine ⟨2,by omega,?_⟩
    have ht : Function.update s a (raise (s a))=s := by rw [hx]; change Function.update s a []=s; rw [←hx]; exact Function.update_eq_self _ _
    rw [hx] at ht
    rw [ht]
    exact Exec.branch_false (by simp [nonempty,tops,hx]) (Exec.skip s)
  | cons b xs =>
    have he := Exec.seq (Exec.pop s a) (Exec.push (Function.update s a (s a).tail) a true)
    have hf := Exec.branch_true (b:=.skip) (p:=nonempty a) (by simp [nonempty,tops,hx]) he
    refine ⟨5,by omega,?_⟩
    simpa only [raiseCode,hx,List.tail_cons,Function.update_self,Function.update_idem,raise] using hf
 theorem increment_exec (a b : K) (hab : a≠b) (s : Stacks K Bool) (hb : s b=[]) :
    ∃u≤10*(s a).length+7,(increment a b).Exec s u (Function.update s a (inc (s a))) := by
  let mid := Function.update (Function.update s a (rest (s a))) b (List.replicate (carry (s a)) false)
  have hc : (carryCode a b).Exec s (5*carry (s a)+1) mid := by simpa only [hb,List.append_nil] using carryCode_exec a b hab s
  obtain ⟨u,hu,he⟩ := raiseCode_exec a mid
  have ht := transfer_exec b a hab.symm false (Function.update mid a (raise (mid a)))
  have hf := Exec.seq hc (Exec.seq he ht)
  have hout : Function.update (Function.update (Function.update mid a (raise (mid a))) b []) a
      (((Function.update mid a (raise (mid a))) b).reverse++(Function.update mid a (raise (mid a))) a)=
      Function.update s a (inc (s a)) := by
    funext k
    by_cases ha : k=a
    · subst k
      simp [mid,hab,hab.symm,inc_decompose]
    · by_cases hkb : k=b
      · subst k; simp [mid,ha,hb]
      · simp [mid,ha,hkb]
  rw [hout] at hf
  refine ⟨_,?_,hf⟩
  simp only [mid,Function.update_of_ne hab.symm,Function.update_self,List.length_replicate]
  have h := carry_le (s a)
  omega
end WLTime.TypedStack.Code

namespace WLTime.SparseMatch
open TypedStack
abbrev Reg := Fin 4
def state (a b f h : List Bool) : Stacks Reg Bool := ![a,b,f,h]
def body : Code Reg Bool :=
  .seq (.pushDyn 2 (fun v => (v 2).getD false && ((v 0).getD false == (v 1).getD false)))
    (.seq (.pushDyn 3 (fun v => (v 0).getD false)) (.seq (.pop 0) (.pop 1)))
def program : ℕ → Code Reg Bool
  | 0 => .skip
  | n+1 => .seq body (program n)
 theorem body_exec (x y q : Bool) (xs ys fs hs : List Bool) :
    body.Exec (state (x::xs) (y::ys) (q::fs) hs) 8
      (state xs ys ((q&&(x==y))::q::fs) (x::hs)) := by
  let s := state (x::xs) (y::ys) (q::fs) hs
  let s₁ := Function.update s 2 ((q&&(x==y))::q::fs)
  let s₂ := Function.update s₁ 3 (x::hs)
  let s₃ := Function.update s₂ 0 xs
  have h₁ : (Code.pushDyn 2 (fun v : Tops Reg Bool => (v 2).getD false && ((v 0).getD false == (v 1).getD false))).Exec s 2 s₁ := by
    simpa [s,s₁,state,tops] using Code.Exec.pushDyn s 2 (fun v => (v 2).getD false && ((v 0).getD false == (v 1).getD false))
  have h₂ : (Code.pushDyn 3 (fun v : Tops Reg Bool => (v 0).getD false)).Exec s₁ 2 s₂ := by
    simpa [s₂,s₁,s,state,tops] using Code.Exec.pushDyn s₁ 3 (fun v => (v 0).getD false)
  have h₃ : (Code.pop 0).Exec s₂ 2 s₃ := by simpa [s₃,s₂,s₁,s,state] using Code.Exec.pop s₂ 0
  have h₄ : (Code.pop 1).Exec s₃ 2 (state xs ys ((q&&(x==y))::q::fs) (x::hs)) := by
    have he := Code.Exec.pop s₃ 1
    convert he using 1
    funext i; fin_cases i <;> simp [s₃,s₂,s₁,s,state]
  exact Code.Exec.seq h₁ (Code.Exec.seq h₂ (Code.Exec.seq h₃ h₄))
 theorem program_exec (xs ys tail fs hs : List Bool) (q : Bool) (hlen : ys.length=xs.length) :
    ∃gs, gs.length=xs.length+fs.length+1 ∧ gs.headD false=(q && (xs==ys)) ∧
      (program xs.length).Exec (state (xs++tail) ys (q::fs) hs) (8*xs.length+1)
        (state tail [] gs (xs.reverse++hs)) := by
  induction xs generalizing ys fs hs q with
  | nil =>
    have hy : ys=[] := List.eq_nil_of_length_eq_zero hlen
    subst ys
    exact ⟨q::fs,by simp,by simp,by simpa [program,state] using Code.Exec.skip (state tail [] (q::fs) hs)⟩
  | cons x xs ih =>
    cases ys with
    | nil => simp at hlen
    | cons y ys =>
      have hy : ys.length=xs.length := by simpa using hlen
      obtain ⟨gs,hg,hhead,he⟩ := ih ys (q::fs) (x::hs) (q&&(x==y)) hy
      refine ⟨gs,by simp only [List.length_cons] at hg ⊢; omega,?_,?_⟩
      · rw [hhead]
        simp only [List.cons_beq_cons]
        cases q <;> cases hxy : (x==y) <;> simp
      · have h := Code.Exec.seq (body_exec x y q (xs++tail) ys fs hs) he
        simpa only [program,List.length_cons,List.cons_append,List.reverse_cons,List.append_assoc,List.singleton_append,List.nil_append,Nat.mul_add,Nat.mul_one,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using h
 theorem program_size (n : ℕ) : (program n).controlSize=8*n+1 := by
  induction n with
  | zero => rfl
  | succ n ih => simp only [program,body,Code.controlSize,ih]; omega
end WLTime.SparseMatch
namespace WLTime.SparseTake
open TypedStack
abbrev Reg := Fin 3
def state (a b c : List Bool) : Stacks Reg Bool := ![a,b,c]
def body : Code Reg Bool :=
  .seq (.pushDyn 1 (fun v => (v 0).getD false))
    (.seq (.pushDyn 2 (fun v => (v 0).getD false)) (.pop 0))
def program : ℕ → Code Reg Bool
  | 0 => .skip
  | n+1 => .seq body (program n)
 theorem body_exec (x : Bool) (xs bs cs : List Bool) :
    body.Exec (state (x::xs) bs cs) 6 (state xs (x::bs) (x::cs)) := by
  let s := state (x::xs) bs cs
  let s₁ := Function.update s 1 (x::bs)
  let s₂ := Function.update s₁ 2 (x::cs)
  have he₁ : (Code.pushDyn 1 (fun v : Tops Reg Bool => (v 0).getD false)).Exec s 2 s₁ := by
    simpa [s₁,s,state,tops] using Code.Exec.pushDyn s 1 (fun v => (v 0).getD false)
  have he₂ : (Code.pushDyn 2 (fun v : Tops Reg Bool => (v 0).getD false)).Exec s₁ 2 s₂ := by
    simpa [s₂,s₁,s,state,tops] using Code.Exec.pushDyn s₁ 2 (fun v => (v 0).getD false)
  have he₃ : (Code.pop 0).Exec s₂ 2 (state xs (x::bs) (x::cs)) := by
    have he := Code.Exec.pop s₂ 0
    convert he using 1
    funext i; fin_cases i <;> simp [s₂,s₁,s,state]
  exact Code.Exec.seq he₁ (Code.Exec.seq he₂ he₃)
 theorem program_exec (xs tail bs cs : List Bool) :
    (program xs.length).Exec (state (xs++tail) bs cs) (6*xs.length+1)
      (state tail (xs.reverse++bs) (xs.reverse++cs)) := by
  induction xs generalizing bs cs with
  | nil => simpa [program,state] using Code.Exec.skip (state tail bs cs)
  | cons x xs ih =>
    have he := Code.Exec.seq (body_exec x (xs++tail) bs cs) (ih (x::bs) (x::cs))
    simpa only [program,List.length_cons,List.cons_append,List.reverse_cons,List.append_assoc,List.singleton_append,List.nil_append,Nat.mul_add,Nat.mul_one,Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using he
 theorem program_size (n : ℕ) : (program n).controlSize=6*n+1 := by
  induction n with
  | zero => rfl
  | succ n ih => simp only [program,body,Code.controlSize,ih]; omega
end WLTime.SparseTake

namespace WLTime.SparseLookup
open TypedStack
abbrev Reg := Fin 8
def state (log query out hist copy flags candidate tmp : List Bool) : Stacks Reg Bool :=
  ![log,query,out,hist,copy,flags,candidate,tmp]
def matchMap : Fin 4 → Reg := ![0,4,5,3]
def takeMap : Fin 3 → Reg := ![0,3,6]
 theorem matchMap_inj : Function.Injective matchMap := by decide
 theorem takeMap_inj : Function.Injective takeMap := by decide
def first (w : ℕ) : Code Reg Bool :=
  .seq (.copy 1 4 7 false) (.seq (.push 5 true)
    (.seq ((SparseMatch.program w).relabel matchMap) ((SparseTake.program w).relabel takeMap)))
def finish : Code Reg Bool :=
  .seq (.branch (fun v => (v 5).getD false) (.transfer 6 2 false) (.clear 6)) (.clear 5)
def one (w : ℕ) : Code Reg Bool := .seq (first w) finish
 theorem first_exec (key value query tail hist : List Bool)
    (hk : key.length=query.length) (hv : value.length=query.length) :
    ∃fs, fs.length=query.length+1 ∧ fs.headD false=(key==query) ∧
      (first query.length).Exec (state (key++value++tail) query [] hist [] [] [] [])
        (26*query.length+6)
        (state tail query [] (value.reverse++key.reverse++hist) [] fs value.reverse []) := by
  let s₀ := state (key++value++tail) query [] hist [] [] [] []
  let s₁ := state (key++value++tail) query [] hist query [] [] []
  let s₂ := state (key++value++tail) query [] hist query [true] [] []
  have h₁ : (Code.copy 1 4 7 false).Exec s₀ (12*query.length+2) s₁ := by
    have h := Code.copy_exec (1 : Reg) 4 7 (by decide) (by decide) (by decide) false s₀ rfl
    convert h using 1
    · rfl
    · funext i; fin_cases i <;> simp [s₁,s₀,state]
  have h₂ : (Code.push 5 true).Exec s₁ 2 s₂ := by
    have h := Code.Exec.push s₁ 5 true
    convert h using 1
    funext i; fin_cases i <;> simp [s₂,s₁,state]
  obtain ⟨fs,hlen,hhead,hm⟩ := SparseMatch.program_exec key query (value++tail) [] hist true hk.symm
  have h₃ : ((SparseMatch.program query.length).relabel matchMap).Exec s₂ (8*query.length+1)
      (state (value++tail) query [] (key.reverse++hist) [] fs [] []) := by
    rw [hk] at hm
    apply Code.relabel_exec_of_maps matchMap matchMap_inj hm
    · intro i; fin_cases i <;> simp [s₂,state,SparseMatch.state,matchMap,List.append_assoc]
    · intro i; fin_cases i <;> simp [state,SparseMatch.state,matchMap]
    · intro i hi; fin_cases i <;> simp_all [state,s₂,matchMap]
      <;> first | exact False.elim (hi 0 rfl) | exact False.elim (hi 1 rfl) | exact False.elim (hi 2 rfl) | exact False.elim (hi 3 rfl)
  have h₄ : ((SparseTake.program query.length).relabel takeMap).Exec
      (state (value++tail) query [] (key.reverse++hist) [] fs [] []) (6*query.length+1)
      (state tail query [] (value.reverse++key.reverse++hist) [] fs value.reverse []) := by
    have ht := SparseTake.program_exec value tail (key.reverse++hist) []
    rw [hv] at ht
    apply Code.relabel_exec_of_maps takeMap takeMap_inj ht
    · intro i; fin_cases i <;> simp [state,SparseTake.state,takeMap]
    · intro i; fin_cases i <;> simp [state,SparseTake.state,takeMap,List.append_assoc]
    · intro i hi; fin_cases i <;> simp_all [state,takeMap]
      <;> first | exact False.elim (hi 0 rfl) | exact False.elim (hi 1 rfl) | exact False.elim (hi 2 rfl)
  refine ⟨fs,by simpa [hk] using hlen,by simpa using hhead,?_⟩
  have he := Code.Exec.seq h₁ (Code.Exec.seq h₂ (Code.Exec.seq h₃ h₄))
  convert he using 1
  · rfl
  · omega
 theorem finish_exec (tail query hist fs value : List Bool) :
    ∃u ≤ 5*value.length+3*fs.length+3,
      finish.Exec (state tail query [] hist [] fs value.reverse []) u
        (state tail query (if fs.headD false then value else []) hist [] [] [] []) := by
  let s := state tail query [] hist [] fs value.reverse []
  let out := if fs.headD false then value else []
  let mid := state tail query out hist [] fs [] []
  have hb : ∃u ≤ 5*value.length+2,
      (Code.branch (fun v : Tops Reg Bool => (v 5).getD false) (.transfer 6 2 false) (.clear 6)).Exec s u mid := by
    cases hh : fs.headD false
    · have he := Code.clear_exec (6 : Reg) s
      have ho : out=[] := ite_eq_right (by rw [hh]; decide)
      have hm : Function.update s 6 []=mid := by
        funext i; fin_cases i <;> simp [s,mid,state,ho]
      rw [hm] at he
      refine ⟨_,?_,Code.Exec.branch_false (by simpa [tops,s,state] using hh) he⟩
      simp [s,state]; omega
    · have he := Code.transfer_exec (6 : Reg) 2 (by decide) false s
      have ho : out=value := ite_eq_left hh
      have hm : Function.update (Function.update s 6 []) 2 ((s 6).reverse++s 2)=mid := by
        funext i; fin_cases i <;> simp [s,mid,state,ho]
      rw [hm] at he
      refine ⟨_,?_,Code.Exec.branch_true (by simpa [tops,s,state] using hh) he⟩
      simp [s,state]
  obtain ⟨u,hu,he⟩ := hb
  have hc := Code.clear_exec (5 : Reg) mid
  have hf : Function.update mid 5 []=state tail query out hist [] [] [] [] := by
    funext i; fin_cases i <;> simp [mid,state]
  rw [hf] at hc
  refine ⟨_,?_,Code.Exec.seq he hc⟩
  change u+(3*fs.length+1) ≤ _
  omega
 theorem one_exec (key value query tail hist : List Bool)
    (hk : key.length=query.length) (hv : value.length=query.length) :
    ∃u ≤ 40*(query.length+1),
      (one query.length).Exec (state (key++value++tail) query [] hist [] [] [] []) u
        (state tail query (if key=query then value else []) (value.reverse++key.reverse++hist) [] [] [] []) := by
  obtain ⟨fs,hf,hh,he⟩ := first_exec key value query tail hist hk hv
  obtain ⟨u,hu,hg⟩ := finish_exec tail query (value.reverse++key.reverse++hist) fs value
  rw [hh] at hg
  simp only [beq_iff_eq] at hg
  refine ⟨_,?_,Code.Exec.seq he hg⟩
  rw [hf,hv] at hu
  omega
end WLTime.SparseLookup
namespace WLTime.TypedStack.Code
variable {K : Type uK} {A : Type uA} [DecidableEq K]
def pushList (k : K) : List A → Code K A
  | [] => .skip
  | x::xs => .seq (pushList k xs) (.push k x)
 theorem pushList_exec (k : K) (xs : List A) (s : Stacks K A) :
    (pushList k xs).Exec s (2*xs.length+1) (Function.update s k (xs++s k)) := by
  induction xs with
  | nil => simpa [pushList] using Exec.skip s
  | cons x xs ih =>
    have he := Exec.seq ih (Exec.push (Function.update s k (xs++s k)) k x)
    simpa only [pushList,List.length_cons,List.cons_append,Function.update_self,Function.update_idem,
      Nat.mul_add,Nat.mul_one,Nat.add_assoc] using he
 omit [DecidableEq K] in
 theorem pushList_size (k : K) (xs : List A) : (pushList k xs).controlSize=2*xs.length+1 := by
  induction xs with
  | nil => rfl
  | cons x xs ih => simp only [pushList,controlSize,List.length_cons,ih]; omega
end WLTime.TypedStack.Code
namespace WLTime.SparseLookup
open TypedStack
abbrev Entry := List Bool × List Bool
def flatten (l : List Entry) : List Bool := l.flatMap (fun e => e.1++e.2)
def WellFormed (w : ℕ) (l : List Entry) : Prop := ∀e∈l,e.1.length=w ∧ e.2.length=w
def consumed (q : List Bool) : List Entry → List Entry
  | [] => []
  | e::l => if e.1=q then [e] else e::consumed q l
def remaining (q : List Bool) : List Entry → List Entry
  | [] => []
  | e::l => if e.1=q then l else remaining q l
def found (q : List Bool) : List Entry → List Bool
  | [] => []
  | e::l => if e.1=q then e.2 else found q l
 theorem split_log (q : List Bool) (l : List Entry) : consumed q l++remaining q l=l := by
  induction l with
  | nil => rfl
  | cons e l ih => by_cases he : e.1=q <;> simp [consumed,remaining,he,ih]
 theorem flatten_append (l m : List Entry) : flatten (l++m)=flatten l++flatten m := by simp [flatten]
 theorem flatten_length (w : ℕ) (l : List Entry) (hw : WellFormed w l) : (flatten l).length=2*w*l.length := by
  induction l with
  | nil => simp [flatten]
  | cons e l ih =>
    have he := hw e (by simp)
    have hl : WellFormed w l := fun a ha => hw a (by simp [ha])
    have hh := ih hl
    simp only [flatten,List.flatMap_cons,List.length_append,List.length_cons] at *
    rw [he.1,he.2,hh]
    ring
 theorem consumed_length (q : List Bool) (l : List Entry) : (flatten (consumed q l)).length ≤ (flatten l).length := by
  have hh := congrArg (fun l => (flatten l).length) (split_log q l)
  rw [flatten_append,List.length_append] at hh
  omega
 theorem found_length (q : List Bool) (l : List Entry) (hw : WellFormed q.length l) :
    (found q l).length=0 ∨ (found q l).length=q.length := by
  induction l with
  | nil => exact Or.inl rfl
  | cons e l ih =>
    by_cases he : e.1=q
    · exact Or.inr (by simpa [found,he] using (hw e (by simp)).2)
    · simpa [found,he] using ih (fun a ha => hw a (by simp [ha]))
def keepGoing (v : Tops Reg Bool) : Bool := (Code.nonempty 0 v) && !(Code.nonempty 2 v)
def search (w : ℕ) : Code Reg Bool := .loop keepGoing (one w)
 theorem search_exec (q : List Bool) (l : List Entry) (hist : List Bool) (hq : 0<q.length) (hw : WellFormed q.length l) :
    ∃u ≤ 42*(q.length+1)*l.length+1,
      (search q.length).Exec (state (flatten l) q [] hist [] [] [] []) u
        (state (flatten (remaining q l)) q (found q l) ((flatten (consumed q l)).reverse++hist) [] [] [] []) := by
  induction l generalizing hist with
  | nil =>
    refine ⟨1,by simp,?_⟩
    have he : (search q.length).Exec (state [] q [] hist [] [] [] []) 1 (state [] q [] hist [] [] [] []) :=
      Code.Exec.loop_false (by simp [keepGoing,Code.nonempty,tops,state])
    simpa [flatten,consumed,remaining,found] using he
  | cons e l ih =>
    have he := hw e (by simp)
    have hl : WellFormed q.length l := fun a ha => hw a (by simp [ha])
    have hkne : e.1≠[] := by
      intro h
      have hh := he.1
      rw [h,List.length_nil] at hh
      omega
    obtain ⟨a,ha,hstep⟩ := one_exec e.1 e.2 q (flatten l) hist he.1 he.2
    by_cases h : e.1=q
    · have hval : e.2≠[] := by intro hh; rw [hh,List.length_nil] at he; omega
      simp only [ite_eq_left h] at hstep
      have hstop : (search q.length).Exec
          (state (flatten l) q e.2 (e.2.reverse++e.1.reverse++hist) [] [] [] []) 1
          (state (flatten l) q e.2 (e.2.reverse++e.1.reverse++hist) [] [] [] []) :=
        Code.Exec.loop_false (by simp [keepGoing,Code.nonempty,tops,state,hval])
      have hex := Code.Exec.loop_true (p:=keepGoing) (by simp [keepGoing,Code.nonempty,tops,state,hkne]) hstep hstop
      refine ⟨a+1+1,?_,?_⟩
      · simp only [List.length_cons]; nlinarith
      · simpa only [search,flatten,List.flatMap_cons,consumed,remaining,found,ite_eq_left h,List.flatMap_nil,List.append_nil,
          List.reverse_append,List.append_assoc] using hex
    · simp only [ite_eq_right h] at hstep
      obtain ⟨b,hb,hrest⟩ := ih (e.2.reverse++e.1.reverse++hist) hl
      have hex := Code.Exec.loop_true (p:=keepGoing) (by simp [keepGoing,Code.nonempty,tops,state,hkne]) hstep hrest
      refine ⟨a+b+1,?_,?_⟩
      · simp only [List.length_cons]; nlinarith
      · simpa only [search,flatten,List.flatMap_cons,consumed,remaining,found,ite_eq_right h,List.reverse_append,List.append_assoc] using hex
end WLTime.SparseLookup

end OAI