| import OAI.Computability.WeisfeilerLeman.TapeCompiler |
|
|
| namespace OAI |
|
|
| universe uK uA uS uT |
|
|
| namespace WLTime.TypedStack |
|
|
| inductive Command (K : Type uK) (A : Type uA) (S : Type uS) where |
| | next (q : S) |
| | push (k : K) (x : A) (q : S) |
| | pop (k : K) (q : S) |
| | halt (b : Bool) |
|
|
| structure Machine (K : Type uK) (A : Type uA) (S : Type uS) where |
| inputStack : K |
| inputLetter : Bool → A |
| initial : S |
| transition : S → (K → Option A) → Command K A S |
|
|
| structure Config (K : Type uK) (A : Type uA) (S : Type uS) where |
| state : Bool ⊕ S |
| stack : K → List A |
|
|
| namespace Machine |
| variable {K : Type uK} {A : Type uA} {S : Type uS} [DecidableEq K] (M : Machine K A S) |
|
|
| def perform (_M : Machine K A S) (C : Config K A S) (a : Command K A S) : Config K A S := match a with |
| | .next q => { C with state := .inr q } |
| | .push k x q => ⟨.inr q,Function.update C.stack k (x::C.stack k)⟩ |
| | .pop k q => ⟨.inr q,Function.update C.stack k (C.stack k).tail⟩ |
| | .halt b => { C with state := .inl b } |
| def step (C : Config K A S) : Config K A S := match C.state with |
| | .inl _ => C |
| | .inr q => M.perform C (M.transition q (fun k => (C.stack k).head?)) |
| def initialConfig (w : List Bool) : Config K A S := |
| ⟨.inr M.initial,fun k => if k=M.inputStack then w.map M.inputLetter else []⟩ |
| def run (w : List Bool) (t : ℕ) := M.step^[t] (M.initialConfig w) |
|
|
| variable [Fintype K] [Fintype A] [Fintype S] |
|
|
| noncomputable def registerEquiv : K ≃ Fin (Fintype.card K) := |
| (Equiv.swap M.inputStack ((Fintype.equivFin K).symm ⟨0,Fintype.card_pos_iff.mpr ⟨M.inputStack⟩⟩)).trans |
| (Fintype.equivFin K) |
| omit [Fintype A] [Fintype S] in |
| @[simp] theorem register_input : (M.registerEquiv M.inputStack).val=0 := by |
| simp [registerEquiv] |
|
|
| noncomputable def decodeSymbol (x : Fin (2+Fintype.card A)) : A := |
| match finSumFinEquiv.symm x with |
| | .inl b => M.inputLetter (b.val=1) |
| | .inr a => (Fintype.equivFin A).symm a |
|
|
| noncomputable def encodeSymbol (_M : Machine K A S) (x : A) : Fin (2+Fintype.card A) := |
| finSumFinEquiv (.inr (Fintype.equivFin A x)) |
|
|
| omit [Fintype K] [Fintype S] [DecidableEq K] in |
| @[simp] theorem decode_encode (x : A) : M.decodeSymbol (M.encodeSymbol x)=x := by |
| simp [decodeSymbol,encodeSymbol] |
|
|
| noncomputable def encodeCommand : Command K A S → |
| StackMachine.Command (Fintype.card K) (2+Fintype.card A) (Fintype.card S) |
| | .next q => .next (Fintype.equivFin S q) |
| | .push k x q => .push (M.registerEquiv k) (M.encodeSymbol x) (Fintype.equivFin S q) |
| | .pop k q => .pop (M.registerEquiv k) (Fintype.equivFin S q) |
| | .halt b => .halt b |
|
|
| noncomputable abbrev compile : StackMachine.Machine where |
| count := Fintype.card K |
| alphabet := 2+Fintype.card A |
| states := Fintype.card S |
| count_pos := Fintype.card_pos_iff.mpr ⟨M.inputStack⟩ |
| alphabet_ge := by omega |
| initial := Fintype.equivFin S M.initial |
| transition q v := M.encodeCommand |
| (M.transition ((Fintype.equivFin S).symm q) (fun k => (v (M.registerEquiv k)).map M.decodeSymbol)) |
|
|
| noncomputable def project (C : M.compile.Config) : Config K A S where |
| state := C.state.map id (Fintype.equivFin S).symm |
| stack k := (C.stack (M.registerEquiv k)).map M.decodeSymbol |
|
|
| theorem project_perform (C : M.compile.Config) (a : Command K A S) : |
| M.project (M.compile.perform C (M.encodeCommand a))=M.perform (M.project C) a := by |
| cases a with |
| | next q => simp only [encodeCommand,StackMachine.Machine.perform,project,Sum.map_inr, |
| Equiv.symm_apply_apply,perform] |
| | halt b => rfl |
| | push k x q => |
| simp only [encodeCommand,StackMachine.Machine.perform,project,Sum.map_inr, |
| Equiv.symm_apply_apply,perform] |
| congr 1 |
| funext j |
| by_cases hj : j=k |
| · subst j |
| simp only [Function.update_self,List.map_cons,M.decode_encode] |
| · have hn : M.registerEquiv j≠M.registerEquiv k := fun hh => hj (M.registerEquiv.injective hh) |
| simp only [Function.update_of_ne hj,Function.update_of_ne hn] |
| | pop k q => |
| simp only [encodeCommand,StackMachine.Machine.perform,project,Sum.map_inr, |
| Equiv.symm_apply_apply,perform] |
| congr 1 |
| funext j |
| by_cases hj : j=k |
| · subst j |
| simp only [Function.update_self,List.map_tail] |
| · have hn : M.registerEquiv j≠M.registerEquiv k := fun hh => hj (M.registerEquiv.injective hh) |
| simp only [Function.update_of_ne hj,Function.update_of_ne hn] |
|
|
| theorem project_step (C : M.compile.Config) : M.project (M.compile.step C)=M.step (M.project C) := by |
| obtain ⟨p,s⟩ := C |
| cases p with |
| | inl b => rfl |
| | inr q => |
| change M.project (M.compile.perform _ (M.encodeCommand _))=_ |
| rw [M.project_perform] |
| simp only [step,project,Sum.map_inr,List.head?_map] |
|
|
| theorem project_initial (w : List Bool) : M.project (M.compile.initialConfig w)=M.initialConfig w := by |
| have hi (b : Bool) : M.decodeSymbol (M.compile.inputLetter b)=M.inputLetter b := by |
| cases b <;> rfl |
| simp only [project,StackMachine.Machine.initialConfig,Sum.map_inr,Equiv.symm_apply_apply,initialConfig] |
| congr 1 |
| funext k |
| have hk : (M.registerEquiv k).val=0 ↔ k=M.inputStack := by |
| rw [← M.register_input] |
| exact Fin.ext_iff.symm.trans (M.registerEquiv.injective.eq_iff) |
| simp only [hk] |
| split_ifs |
| · simp only [List.map_map] |
| exact List.map_congr_left (fun b _ => hi b) |
| · rfl |
|
|
| theorem project_run (w : List Bool) (t : ℕ) : M.project (M.compile.run w t)=M.run w t := by |
| induction t with |
| | zero => exact M.project_initial w |
| | succ t ih => |
| simp only [run,StackMachine.Machine.run,Function.iterate_succ_apply'] at * |
| rw [M.project_step,ih] |
|
|
| theorem compile_halt (w : List Bool) (t : ℕ) (b : Bool) |
| (h : (M.run w t).state=.inl b) : (M.compile.run w t).state=.inl b := by |
| rw [← M.project_run] at h |
| cases he : (M.compile.run w t).state with |
| | inl b' => simpa only [project,he,Sum.map_inl,id_eq,Sum.inl.injEq] using h |
| | inr q => simp only [project,he,Sum.map_inr,reduceCtorEq] at h |
|
|
| theorem oneTape_correct (w : List Bool) (t : ℕ) (b : Bool) |
| (h : (M.run w t).state=.inl b) : |
| M.compile.oneTape.toTM.halts w ∧ |
| M.compile.oneTape.toTM.time w ≤ 8*(Fintype.card K+1)*(w.length+t+1)^2 ∧ |
| (M.compile.oneTape.toTM.accepts w ↔ b=true) := |
| M.compile.oneTape_correct w t b (M.compile_halt w t b h) |
|
|
| end Machine |
| end WLTime.TypedStack |
|
|
| namespace WLTime.TypedStack |
| namespace Command |
| variable {K : Type uK} {A : Type uA} {S : Type uS} {T : Type uT} |
| def rename (f : S → T) : Command K A S → Command K A T |
| | .next q => .next (f q) |
| | .push k x q => .push k x (f q) |
| | .pop k q => .pop k (f q) |
| | .halt b => .halt b |
| def redirect (f : S → T) (r : T) : Command K A S → Command K A T |
| | .next q => .next (f q) |
| | .push k x q => .push k x (f q) |
| | .pop k q => .pop k (f q) |
| | .halt _ => .next r |
| end Command |
|
|
| variable {K : Type uK} {A : Type uA} {S : Type uS} {T : Type uT} [DecidableEq K] |
| abbrev Stacks (K : Type uK) (A : Type uA) := K → List A |
| abbrev Tops (K : Type uK) (A : Type uA) := K → Option A |
| def tops (s : Stacks K A) : Tops K A := fun k => (s k).head? |
|
|
| inductive Execution (tr : S → Tops K A → Command K A S) : |
| S → Stacks K A → ℕ → Bool → Stacks K A → Prop |
| | halt {q s b} (h : tr q (tops s)=.halt b) : Execution tr q s 1 b s |
| | next {q s q' t b out} (h : tr q (tops s)=.next q') |
| (tail : Execution tr q' s t b out) : Execution tr q s (t+1) b out |
| | push {q s k x q' t b out} (h : tr q (tops s)=.push k x q') |
| (tail : Execution tr q' (Function.update s k (x::s k)) t b out) : |
| Execution tr q s (t+1) b out |
| | pop {q s k q' t b out} (h : tr q (tops s)=.pop k q') |
| (tail : Execution tr q' (Function.update s k (s k).tail) t b out) : |
| Execution tr q s (t+1) b out |
|
|
| namespace Execution |
| theorem iterate (M : Machine K A S) {q s t b out} (h : Execution M.transition q s t b out) : |
| M.step^[t] ⟨.inr q,s⟩=⟨.inl b,out⟩ := by |
| induction h with |
| | @halt q s b h => |
| change M.perform ⟨.inr q,s⟩ (M.transition q (tops s))=⟨.inl b,s⟩ |
| rw [h] |
| rfl |
| | @next q s q' t b out h tail ih => |
| rw [Function.iterate_succ_apply] |
| change M.step^[t] (M.perform ⟨.inr q,s⟩ (M.transition q (tops s)))=⟨.inl b,out⟩ |
| rw [h] |
| exact ih |
| | @push q s k x q' t b out h tail ih => |
| rw [Function.iterate_succ_apply] |
| change M.step^[t] (M.perform ⟨.inr q,s⟩ (M.transition q (tops s)))=⟨.inl b,out⟩ |
| rw [h] |
| exact ih |
| | @pop q s k q' t b out h tail ih => |
| rw [Function.iterate_succ_apply] |
| change M.step^[t] (M.perform ⟨.inr q,s⟩ (M.transition q (tops s)))=⟨.inl b,out⟩ |
| rw [h] |
| exact ih |
|
|
| theorem rename {tr : S → Tops K A → Command K A S} {tr' : T → Tops K A → Command K A T} |
| (f : S → T) (hf : ∀ q v,tr' (f q) v=Command.rename f (tr q v)) |
| {q s t b out} (h : Execution tr q s t b out) : Execution tr' (f q) s t b out := by |
| induction h with |
| | halt h => exact .halt (by rw [hf,h]; rfl) |
| | next h tail ih => exact .next (by rw [hf,h]; rfl) ih |
| | push h tail ih => exact .push (by rw [hf,h]; rfl) ih |
| | pop h tail ih => exact .pop (by rw [hf,h]; rfl) ih |
| |
| theorem plug {tr : S → Tops K A → Command K A S} {tr' : T → Tops K A → Command K A T} |
| (f : S → T) (r : T) (hf : ∀ q v,tr' (f q) v=Command.redirect f r (tr q v)) |
| {q s t b mid} (h : Execution tr q s t b mid) |
| {u c out} (cont : Execution tr' r mid u c out) : Execution tr' (f q) s (t+u) c out := by |
| induction h with |
| | halt h => |
| simpa only [Nat.add_comm] using Execution.next (by rw [hf,h]; rfl) cont |
| | next h tail ih => |
| simpa only [Nat.add_right_comm] using Execution.next (by rw [hf,h]; rfl) (ih cont) |
| | push h tail ih => |
| simpa only [Nat.add_right_comm] using Execution.push (by rw [hf,h]; rfl) (ih cont) |
| | pop h tail ih => |
| simpa only [Nat.add_right_comm] using Execution.pop (by rw [hf,h]; rfl) (ih cont) |
| end Execution |
| |
| inductive Code (K : Type uK) (A : Type uA) where |
| | skip |
| | push (k : K) (x : A) |
| | pushDyn (k : K) (letter : Tops K A → A) |
| | pop (k : K) |
| | seq (left right : Code K A) |
| | branch (test : Tops K A → Bool) (yes no : Code K A) |
| | loop (test : Tops K A → Bool) (body : Code K A) |
|
|
| namespace Code |
| @[reducible] def State : Code K A → Type |
| | .skip => Unit |
| | .push _ _ => Fin 2 |
| | .pushDyn _ _ => Fin 2 |
| | .pop _ => Fin 2 |
| | .seq a b => a.State ⊕ b.State |
| | .branch _ a b => Unit ⊕ (a.State ⊕ b.State) |
| | .loop _ a => Unit ⊕ a.State |
|
|
| noncomputable instance stateFintype (c : Code K A) : Fintype c.State := by |
| induction c with |
| | skip => exact inferInstanceAs (Fintype Unit) |
| | push k x => exact inferInstanceAs (Fintype (Fin 2)) |
| | pushDyn k f => exact inferInstanceAs (Fintype (Fin 2)) |
| | pop k => exact inferInstanceAs (Fintype (Fin 2)) |
| | seq a b ha hb => exact inferInstanceAs (Fintype (a.State ⊕ b.State)) |
| | branch p a b ha hb => exact inferInstanceAs (Fintype (Unit ⊕ (a.State ⊕ b.State))) |
| | loop p a ha => exact inferInstanceAs (Fintype (Unit ⊕ a.State)) |
|
|
| def entry : (c : Code K A) → c.State |
| | .skip => () |
| | .push _ _ => 0 |
| | .pushDyn _ _ => 0 |
| | .pop _ => 0 |
| | .seq a _ => .inl a.entry |
| | .branch _ _ _ => .inl () |
| | .loop _ _ => .inl () |
|
|
| def transition : (c : Code K A) → c.State → Tops K A → Command K A c.State |
| | .skip,_,_ => .halt false |
| | .push k x,q,_ => if q=0 then .push k x 1 else .halt false |
| | .pushDyn k f,q,v => if q=0 then .push k (f v) 1 else .halt false |
| | .pop k,q,_ => if q=0 then .pop k 1 else .halt false |
| | .seq a b,.inl q,v => Command.redirect Sum.inl (.inr b.entry) (a.transition q v) |
| | .seq _ b,.inr q,v => Command.rename Sum.inr (b.transition q v) |
| | .branch p a b,.inl _,v => .next (if p v then .inr (.inl a.entry) else .inr (.inr b.entry)) |
| | .branch _ a _,.inr (.inl q),v => Command.rename (Sum.inr ∘ Sum.inl) (a.transition q v) |
| | .branch _ _ b,.inr (.inr q),v => Command.rename (Sum.inr ∘ Sum.inr) (b.transition q v) |
| | .loop p a,.inl _,v => if p v then .next (.inr a.entry) else .halt false |
| | .loop _ a,.inr q,v => Command.redirect Sum.inr (.inl ()) (a.transition q v) |
|
|
| def machine (c : Code K A) (k : K) (bits : Bool → A) : Machine K A c.State := |
| ⟨k,bits,c.entry,c.transition⟩ |
|
|
| inductive Exec : Code K A → Stacks K A → ℕ → Stacks K A → Prop |
| | skip (s) : Exec .skip s 1 s |
| | push (s k x) : Exec (.push k x) s 2 (Function.update s k (x::s k)) |
| | pushDyn (s k f) : Exec (.pushDyn k f) s 2 (Function.update s k (f (tops s)::s k)) |
| | pop (s k) : Exec (.pop k) s 2 (Function.update s k (s k).tail) |
| | seq {a b s mid out t u} (first : Exec a s t mid) (second : Exec b mid u out) : |
| Exec (.seq a b) s (t+u) out |
| | branch_true {p a b s t out} (test : p (tops s)=true) (body : Exec a s t out) : |
| Exec (.branch p a b) s (t+1) out |
| | branch_false {p a b s t out} (test : p (tops s)=false) (body : Exec b s t out) : |
| Exec (.branch p a b) s (t+1) out |
| | loop_false {p a s} (test : p (tops s)=false) : Exec (.loop p a) s 1 s |
| | loop_true {p a s mid out t u} (test : p (tops s)=true) |
| (body : Exec a s t mid) (rest : Exec (.loop p a) mid u out) : |
| Exec (.loop p a) s (t+u+1) out |
|
|
| theorem exec_finite {c : Code K A} {s t out} (h : c.Exec s t out) : |
| Execution c.transition c.entry s t false out := by |
| induction h with |
| | skip s => exact .halt rfl |
| | push s k x => |
| exact .push (q' := (1 : Fin 2)) (by simp [entry,transition]) (.halt (by simp [transition])) |
| | pushDyn s k f => |
| exact .push (q' := (1 : Fin 2)) (by simp [entry,transition]) (.halt (by simp [transition])) |
| | pop s k => |
| exact .pop (q' := (1 : Fin 2)) (by simp [entry,transition]) (.halt (by simp [transition])) |
| | @seq a b s mid out t u first second ih1 ih2 => |
| exact ih1.plug Sum.inl (.inr b.entry) (fun _ _ => rfl) (ih2.rename Sum.inr (fun _ _ => rfl)) |
| | branch_true hp body ih => |
| exact .next (by simp [entry,transition,hp]) (ih.rename (Sum.inr ∘ Sum.inl) (fun _ _ => rfl)) |
| | branch_false hp body ih => |
| exact .next (by simp [entry,transition,hp]) (ih.rename (Sum.inr ∘ Sum.inr) (fun _ _ => rfl)) |
| | loop_false hp => exact .halt (by simp [entry,transition,hp]) |
| | loop_true hp body rest ih1 ih2 => |
| exact .next (by simp [entry,transition,hp]) |
| (ih1.plug Sum.inr (.inl ()) (fun _ _ => rfl) ih2) |
|
|
| theorem exec_iterate (c : Code K A) (k : K) (bits : Bool → A) {s t out} (h : c.Exec s t out) : |
| (c.machine k bits).step^[t] ⟨.inr c.entry,s⟩=⟨.inl false,out⟩ := |
| (exec_finite h).iterate (c.machine k bits) |
|
|
| end Code |
| end WLTime.TypedStack |
|
|
| namespace WLTime.TypedStack.Code |
| variable {K : Type uK} {A : Type uA} [DecidableEq K] |
|
|
| def nonempty (k : K) (v : Tops K A) : Bool := (v k).isSome |
| def clear (k : K) : Code K A := .loop (nonempty k) (.pop k) |
| def transfer (a b : K) (zero : A) : Code K A := |
| .loop (nonempty a) (.seq (.pushDyn b (fun v => (v a).getD zero)) (.pop a)) |
|
|
| theorem clear_exec (k : K) (s : Stacks K A) : |
| (clear k).Exec s (3*(s k).length+1) (Function.update s k []) := by |
| generalize hx : s k=xs |
| induction xs generalizing s with |
| | nil => |
| have hs : Function.update s k []=s := by rw [← hx]; exact Function.update_eq_self k s |
| rw [hs] |
| exact .loop_false (by simp [nonempty,tops,hx]) |
| | cons x xs ih => |
| have hstep := ih (Function.update s k xs) (by simp) |
| have he : (Function.update (Function.update s k xs) k [])=Function.update s k [] := by simp |
| rw [he] at hstep |
| have first : Exec (.pop k) s 2 (Function.update s k xs) := by |
| simpa only [hx,List.tail_cons] using Exec.pop s k |
| have hh := Exec.loop_true (p:=nonempty k) (by simp [nonempty,tops,hx]) first hstep |
| convert hh using 1 <;> simp [clear] |
| omega |
| |
| theorem transfer_exec (a b : K) (hab : a≠b) (zero : A) (s : Stacks K A) : |
| (transfer a b zero).Exec s (5*(s a).length+1) |
| (Function.update (Function.update s a []) b ((s a).reverse++s b)) := by |
| generalize hx : s a=xs |
| induction xs generalizing s with |
| | nil => |
| have hout : Function.update (Function.update s a []) b (([] : List A).reverse++s b)=s := by |
| simp only [List.reverse_nil,List.nil_append] |
| rw [← hx,Function.update_eq_self] |
| exact Function.update_eq_self b s |
| rw [hout] |
| exact .loop_false (by simp [nonempty,tops,hx]) |
| | cons x xs ih => |
| let s₁ := Function.update s b (x::s b) |
| let s₂ := Function.update s₁ a xs |
| have hs₁a : s₁ a=x::xs := by simp [s₁,Function.update_of_ne hab,hx] |
| have hs₂a : s₂ a=xs := by simp [s₂] |
| have body : Exec (.seq (.pushDyn b (fun v => (v a).getD zero)) (.pop a)) s 4 s₂ := by |
| have hp : Exec (.pushDyn b (fun v => (v a).getD zero)) s 2 s₁ := by |
| simpa [tops,hx,s₁] using Exec.pushDyn s b (fun v => (v a).getD zero) |
| have hq : Exec (.pop a) s₁ 2 s₂ := by |
| simpa [hs₁a,s₂] using Exec.pop s₁ a |
| exact .seq hp hq |
| have hrest := ih s₂ hs₂a |
| have hout : Function.update (Function.update s₂ a []) b (xs.reverse++s₂ b)= |
| Function.update (Function.update s a []) b ((x::xs).reverse++s b) := by |
| funext k |
| by_cases hb : k=b |
| · subst k |
| simp [s₂,s₁,hab.symm,List.reverse_cons,List.append_assoc] |
| · by_cases ha : k=a |
| · subst k |
| simp [hb] |
| · simp [s₂,s₁,hb,ha] |
| rw [hout] at hrest |
| have hh := Exec.loop_true (p:=nonempty a) (by simp [nonempty,tops,hx]) body hrest |
| convert hh using 1 <;> simp [transfer] |
| omega |
| |
| def distribute (a b c : K) (zero : A) : Code K A := |
| .loop (nonempty a) (.seq (.pushDyn b (fun v => (v a).getD zero)) |
| (.seq (.pushDyn c (fun v => (v a).getD zero)) (.pop a))) |
|
|
| theorem distribute_exec (a b c : K) (hab : a≠b) (hac : a≠c) (hbc : b≠c) |
| (zero : A) (s : Stacks K A) : |
| (distribute a b c zero).Exec s (7*(s a).length+1) |
| (Function.update (Function.update (Function.update s a []) b ((s a).reverse++s b)) |
| c ((s a).reverse++s c)) := by |
| generalize hx : s a=xs |
| induction xs generalizing s with |
| | nil => |
| have hout : Function.update (Function.update (Function.update s a []) b ([]++s b)) c ([]++s c)=s := by |
| simp only [List.nil_append] |
| rw [← hx,Function.update_eq_self,Function.update_eq_self,Function.update_eq_self] |
| change Exec _ s 1 (Function.update (Function.update (Function.update s a []) b ([]++s b)) c ([]++s c)) |
| rw [hout] |
| exact .loop_false (by simp [nonempty,tops,hx]) |
| | cons x xs ih => |
| let s₁ := Function.update s b (x::s b) |
| let s₂ := Function.update s₁ c (x::s c) |
| let s₃ := Function.update s₂ a xs |
| have hs₁a : s₁ a=x::xs := by simp [s₁,hab,hx] |
| have hs₁c : s₁ c=s c := by simp [s₁,hbc.symm] |
| have hs₂a : s₂ a=x::xs := by simp [s₂,hac,hs₁a] |
| have hs₃a : s₃ a=xs := by simp [s₃] |
| have first : Exec (.pushDyn b (fun v => (v a).getD zero)) s 2 s₁ := by |
| simpa [tops,hx,s₁] using Exec.pushDyn s b (fun v => (v a).getD zero) |
| have second : Exec (.pushDyn c (fun v => (v a).getD zero)) s₁ 2 s₂ := by |
| simpa [tops,hs₁a,hs₁c,s₂] using Exec.pushDyn s₁ c (fun v => (v a).getD zero) |
| have third : Exec (.pop a) s₂ 2 s₃ := by |
| simpa [hs₂a,s₃] using Exec.pop s₂ a |
| have body := Exec.seq first (Exec.seq second third) |
| have hrest := ih s₃ hs₃a |
| have hout : Function.update (Function.update (Function.update s₃ a []) b (xs.reverse++s₃ b)) |
| c (xs.reverse++s₃ c)=Function.update (Function.update (Function.update s a []) |
| b ((x::xs).reverse++s b)) c ((x::xs).reverse++s c) := by |
| funext k |
| by_cases hc : k=c |
| · subst k |
| simp [s₃,s₂,s₁,hac.symm,List.reverse_cons,List.append_assoc] |
| · by_cases hb : k=b |
| · subst k |
| simp [s₃,s₂,s₁,hab.symm,hbc,List.reverse_cons,List.append_assoc] |
| · by_cases ha : k=a |
| · subst k |
| simp [hc,hb] |
| · simp [s₃,s₂,s₁,hc,hb,ha] |
| rw [hout] at hrest |
| have hh := Exec.loop_true (p:=nonempty a) (by simp [nonempty,tops,hx]) body hrest |
| convert hh using 1 <;> simp [distribute] |
| omega |
| |
| end WLTime.TypedStack.Code |
| |
| end OAI |
| |
