| import OAI.Computability.Superstring.Programs |
|
|
| namespace OAI |
|
|
| namespace Superstring.BitCode.Program |
|
|
| variable {K : Type} [DecidableEq K] |
|
|
| /-- Execute a reserved loop counter, with a uniform bound for each body call. |
| There is no test of an arbitrary predicate: only this counter is tested. -/ |
| theorem counter_loop (b : Block (K ⊕ ℕ)) (f : Store K → Store K) |
| (d N M C : ℕ) |
| (hb : ∀ s z, Clean d z → (z 0).length = N → Bounded s M → |
| ∃ n ≤ C, b.Exec (Sum.elim s z) (Sum.elim (f s) z) n) |
| (s : Store K) (z : Store ℕ) (hz : Clean d z) (hN : (z 0).length = N) |
| (hinv : ∀ i ≤ (z (d + 2)).length, Bounded (f^[i] s) M) : |
| ∃ n ≤ (z (d + 2)).length * (C + 2) + 1, |
| (Block.loop (.inr (d + 2)) (.seq (.pop (.inr (d + 2))) b)).Exec |
| (Sum.elim s z) |
| (Sum.elim (f^[(z (d + 2)).length] s) (Function.update z (d + 2) [])) n := by |
| generalize he : z (d + 2) = w at * |
| induction w generalizing s z with |
| | nil => |
| have hu : Function.update z (d + 2) [] = z := by rw [← he, Function.update_eq_self] |
| refine ⟨1, by simp, ?_⟩ |
| simpa only [List.length_nil, Function.iterate_zero, id_eq, hu] using |
| (Block.Exec.loop_nil (a := Block.seq (.pop (.inr (d + 2))) b) |
| (show (Sum.elim s z) (.inr (d + 2)) = [] from he)) |
| | cons x xs ih => |
| let z' := Function.update z (d + 2) xs |
| have hz' : Clean d z' := hz.update_above le_rfl xs |
| have hN' : (z' 0).length = N := by simpa only [z', Function.update_of_ne (show (0 : ℕ) ≠ d + 2 by omega)] using hN |
| have hhead : Bounded s M := by simpa using hinv 0 (by omega) |
| obtain ⟨n, hn, hh⟩ := hb s z' hz' hN' hhead |
| have hpop : Block.Exec (.pop (.inr (d + 2))) (Sum.elim s z) (Sum.elim s z') 1 := by |
| simpa only [Sum.elim_inr, he, List.tail_cons, sum_update_right, z'] using |
| Block.Exec.pop (.inr (d + 2)) (Sum.elim s z) |
| have htail : ∀ i ≤ xs.length, Bounded (f^[i] (f s)) M := by |
| intro i hi |
| rw [← Function.iterate_succ_apply] |
| apply hinv |
| simp only [List.length_cons] |
| omega |
| obtain ⟨m, hm, hrest⟩ := ih (f s) z' hz' hN' (Function.update_self _ _ _) htail |
| have hresult := Block.Exec.loop_cons |
| (show (Sum.elim s z) (.inr (d + 2)) ≠ [] by simp [he]) |
| (Block.Exec.seq hpop hh) hrest |
| refine ⟨1 + n + m + 1, ?_, ?_⟩ |
| · simp only [List.length_cons] |
| nlinarith |
| · simpa only [z', Function.update_idem, List.length_cons, Function.iterate_succ_apply] |
| using hresult |
|
|
| end Superstring.BitCode.Program |
|
|
| namespace Superstring.BitCode.Program |
|
|
| /-- Uniform bit clock; the polynomial work counts syntactic bounded iterations. -/ |
| def clock (w N M : ℕ) : ℕ := 13 * w * (M + N + w + 1) |
|
|
| theorem clock_add (a b N M : ℕ) : |
| clock a N M + clock b N (M + a) ≤ clock (a + b) N M := by |
| dsimp only [clock] |
| nlinarith |
|
|
| theorem clock_step {a b : ℕ} (h : a + 1 ≤ b) (N M : ℕ) : |
| clock a N M + 1 ≤ clock b N M := by |
| dsimp only [clock] |
| nlinarith [Nat.mul_le_mul_right (M + N + a + 1) h, |
| Nat.mul_le_mul_left b (show M + N + a + 1 ≤ M + N + b + 1 by omega)] |
|
|
| theorem clock_loop (w N M : ℕ) : |
| 9 * N + 3 + (N * (clock w N (M + N * w) + 2) + 1) ≤ |
| clock ((N + 1) * (w + 1)) N M := by |
| let W := (N + 1) * (w + 1) |
| let B := M + N + W + 1 |
| have hW : N * w + w ≤ W := by dsimp [W]; nlinarith |
| have h₁ : clock w N (M + N * w) ≤ 13 * w * B := by |
| apply Nat.mul_le_mul_left |
| dsimp only [B] |
| omega |
| have h₂ : 11 * N + 4 ≤ 13 * (N + 1) * B := by |
| have hB : 1 ≤ B := by dsimp [B]; omega |
| nlinarith [Nat.mul_le_mul_left (13 * (N + 1)) hB] |
| have h₃ : N * w + (N + 1) ≤ W := by dsimp [W]; nlinarith |
| calc |
| _ ≤ 9 * N + 3 + (N * (13 * w * B + 2) + 1) := by gcongr |
| _ = 13 * (N * w) * B + (11 * N + 4) := by ring |
| _ ≤ 13 * (N * w) * B + 13 * (N + 1) * B := Nat.add_le_add_left h₂ _ |
| _ = 13 * (N * w + (N + 1)) * B := by ring |
| _ ≤ 13 * W * B := by gcongr |
|
|
| variable {K : Type} [DecidableEq K] |
|
|
| /-- Complete correctness and a polynomial bit-clock for bounded-loop programs. -/ |
| theorem compile_exec (p : Program K) (N : ℕ) (s : Store K) (M : ℕ) |
| (hs : Bounded s M) (z : Store ℕ) (hz : Clean p.depth z) |
| (hN : (z 0).length = N) : |
| ∃ n ≤ clock (p.work N) N M, |
| p.compile.Exec (Sum.elim s z) (Sum.elim (p.run N s) z) n := by |
| induction p generalizing s M z with |
| | push k v => |
| refine ⟨1, by simp [work, clock]; omega, ?_⟩ |
| simpa only [compile, run, Sum.elim_inl, sum_update_left] using |
| Block.Exec.push (.inl k) v (Sum.elim s z) |
| | pop k => |
| refine ⟨1, by simp [work, clock]; omega, ?_⟩ |
| simpa only [compile, run, Sum.elim_inl, sum_update_left] using |
| Block.Exec.pop (.inl k) (Sum.elim s z) |
| | clear k => |
| refine ⟨2 * (s k).length + 1, ?_, ?_⟩ |
| · have := hs k |
| simp only [work, clock] |
| omega |
| · simpa only [compile, run, Sum.elim_inl, sum_update_left] using |
| Block.clear_exec (.inl k) (Sum.elim s z) |
| | copy i j => |
| by_cases hij : i = j |
| · subst j |
| refine ⟨1, by simp [work, clock]; omega, ?_⟩ |
| simpa [compile, run] using |
| Block.Exec.skip (Sum.elim s z) |
| · refine ⟨2 * (s j).length + 9 * (s i).length + 3, ?_, ?_⟩ |
| · have := hs i |
| have := hs j |
| simp only [work, clock] |
| omega |
| · simpa only [compile, ite_eq_right hij, run, Sum.elim_inl, sum_update_left] using |
| Block.copy_exec (Sum.inl i : K ⊕ ℕ) (.inl j) (.inr 1) (by simpa using hij) |
| (by simp) (by simp) (Sum.elim s z) hz.1 |
| | skip => |
| exact ⟨1, by simp [work, clock]; omega, Block.Exec.skip _⟩ |
| | branch k a b c iha ihb ihc => |
| have ha := hz.mono (le_max_left _ _) |
| have hb := hz.mono ((le_max_left _ _).trans (le_max_right _ _)) |
| have hc := hz.mono ((le_max_right _ _).trans (le_max_right _ _)) |
| cases hh : (s k).head? with |
| | none => |
| obtain ⟨n, hn, hrun⟩ := iha s M hs z ha hN |
| refine ⟨n + 1, (Nat.add_le_add_right hn 1).trans (clock_step (by dsimp [work]; omega) N M), ?_⟩ |
| simpa only [compile, run, hh] using Block.Exec.branch_none (k := Sum.inl k) |
| (b := b.compile) (c := c.compile) hh hrun |
| | some q => cases q with |
| | false => |
| obtain ⟨n, hn, hrun⟩ := ihb s M hs z hb hN |
| refine ⟨n + 1, (Nat.add_le_add_right hn 1).trans (clock_step (by dsimp [work]; omega) N M), ?_⟩ |
| simpa only [compile, run, hh] using Block.Exec.branch_false (k := Sum.inl k) |
| (a := a.compile) (c := c.compile) hh hrun |
| | true => |
| obtain ⟨n, hn, hrun⟩ := ihc s M hs z hc hN |
| refine ⟨n + 1, (Nat.add_le_add_right hn 1).trans (clock_step (by dsimp [work]; omega) N M), ?_⟩ |
| simpa only [compile, run, hh] using Block.Exec.branch_true (k := Sum.inl k) |
| (a := a.compile) (b := b.compile) hh hrun |
| | seq a b iha ihb => |
| obtain ⟨n, hn, ha⟩ := iha s M hs z (hz.mono (le_max_left _ _)) hN |
| obtain ⟨m, hm, hb⟩ := ihb (a.run N s) (M + a.work N) (a.run_bounded N s M hs) |
| z (hz.mono (le_max_right _ _)) hN |
| exact ⟨n + m, (Nat.add_le_add hn hm).trans (clock_add _ _ _ _), Block.Exec.seq ha hb⟩ |
| | «repeat» a ih => |
| let c := a.depth + 2 |
| let z' := Function.update z c (z 0) |
| have hc : z c = [] := hz.2 a.depth (Nat.lt_succ_self _) |
| have hcopy : (Block.copy (.inr 0) (.inr c) (.inr 1)).Exec |
| (Sum.elim s z) (Sum.elim s z') (9 * N + 3) := by |
| have hh := Block.copy_exec (Sum.inr 0 : K ⊕ ℕ) (.inr c) (.inr 1) |
| (by simp [c]) (by simp) (by simp [c]) (Sum.elim s z) hz.1 |
| simpa only [Sum.elim_inr, hc, List.length_nil, hN, Nat.mul_zero, Nat.zero_add, |
| sum_update_right, z'] using hh |
| have hz' : Clean a.depth z' := (hz.mono (Nat.le_succ _)).update_above le_rfl _ |
| have hN' : (z' 0).length = N := by simp [z', c, hN] |
| have hend : Function.update z' c [] = z := by |
| rw [Function.update_idem, ← hc, Function.update_eq_self] |
| have hInv : ∀ i ≤ (z' c).length, Bounded ((a.run N)^[i] s) (M + N * a.work N) := by |
| intro i hi |
| have hi' : i ≤ N := by simpa only [z', Function.update_self, hN] using hi |
| exact (iterate_bounded (a.run N) (a.work N) (a.run_bounded N) s M i hs).mono |
| (Nat.add_le_add_left (Nat.mul_le_mul_right _ hi') _) |
| obtain ⟨n, hn, hloop⟩ := counter_loop a.compile (a.run N) a.depth N |
| (M + N * a.work N) (clock (a.work N) N (M + N * a.work N)) |
| (fun s z hz hN hs => ih s _ hs z hz hN) s z' hz' hN' hInv |
| simp only [z', c, Function.update_self, hN] at hn hloop |
| rw [show Function.update (Function.update z c (z 0)) c [] = z from hend] at hloop |
| refine ⟨9 * N + 3 + n, ?_, ?_⟩ |
| · exact (Nat.add_le_add_left hn _).trans (clock_loop (a.work N) N M) |
| · exact Block.Exec.seq hcopy hloop |
|
|
| end Superstring.BitCode.Program |
|
|
| namespace Superstring.BitCode |
|
|
| variable {K : Type} [DecidableEq K] |
|
|
| theorem single_bounded (i : K) (w : List Bool) : Program.Bounded (single i w) w.length := by |
| intro j |
| by_cases hj : j = i <;> simp [single, hj] |
| |
| namespace Block |
| |
| /-- No syntax can modify a register it does not mention. -/ |
| theorem Exec.frame {b : Block K} {s t : Store K} {n : ℕ} (h : b.Exec s t n) |
| (k : K) (hk : k ∉ b.support) : t k = s k := by |
| induction h with |
| | push i v s => exact Function.update_of_ne (by simpa [support] using hk) _ _ |
| | pop i s => exact Function.update_of_ne (by simpa [support] using hk) _ _ |
| | skip => rfl |
| | branch_none _ _ ih => exact ih (fun hh => hk (by simp [support, hh])) |
| | branch_false _ _ ih => exact ih (fun hh => hk (by simp [support, hh])) |
| | branch_true _ _ ih => exact ih (fun hh => hk (by simp [support, hh])) |
| | seq _ _ ih₁ ih₂ => |
| exact (ih₂ (fun hh => hk (by simp [support, hh]))).trans |
| (ih₁ (fun hh => hk (by simp [support, hh]))) |
| | loop_nil => rfl |
| | loop_cons _ _ _ ih₁ ih₂ => exact (ih₂ hk).trans (ih₁ (fun hh => hk (by simp [support, hh]))) |
|
|
| /-- The maximum stack length, unlike the total size, needs no finiteness of the |
| ambient register type. A finite code will subsequently be restricted to its support. -/ |
| theorem Exec.bounded {b : Block K} {s t : Store K} {n : ℕ} (h : b.Exec s t n) |
| (M : ℕ) (hs : Program.Bounded s M) : Program.Bounded t (M + n) := by |
| induction h generalizing M with |
| | push k v s => |
| exact (hs.mono (Nat.le_add_right M 1)).update k (v :: s k) |
| (by simpa only [List.length_cons] using Nat.succ_le_succ (hs k)) |
| | pop k s => |
| exact (hs.mono (Nat.le_add_right M 1)).update k (s k).tail |
| (by simp only [List.length_tail]; have := hs k; omega) |
| | skip => exact hs.mono (by omega) |
| | branch_none _ _ ih => exact (ih M hs).mono (by omega) |
| | branch_false _ _ ih => exact (ih M hs).mono (by omega) |
| | branch_true _ _ ih => exact (ih M hs).mono (by omega) |
| | seq _ _ ih₁ ih₂ => |
| have hh := ih₂ _ (ih₁ M hs) |
| simpa only [Nat.add_assoc] using hh |
| | loop_nil => exact hs.mono (by omega) |
| | loop_cons _ _ _ ih₁ ih₂ => exact (ih₂ _ (ih₁ M hs)).mono (by omega) |
|
|
| def clearMany : List K → Block K |
| | [] => .skip |
| | k :: ks => .seq (clear k) (clearMany ks) |
|
|
| def cleared (s : Store K) (l : List K) : Store K := fun k => if k ∈ l then [] else s k |
|
|
| theorem clearMany_exec (l : List K) (s : Store K) (M : ℕ) (hs : Program.Bounded s M) : |
| ∃ n ≤ l.length * (2 * M + 1) + 1, (clearMany l).Exec s (cleared s l) n := by |
| induction l generalizing s with |
| | nil => |
| have he : cleared s [] = s := by funext k; simp [cleared] |
| exact ⟨1, by simp, by simpa only [clearMany, he] using Exec.skip s⟩ |
| | cons k ks ih => |
| obtain ⟨n, hn, hh⟩ := ih (Function.update s k []) (hs.update k [] (by simp)) |
| have he : cleared (Function.update s k []) ks = cleared s (k :: ks) := by |
| funext j |
| by_cases hj : j = k <;> by_cases hmem : j ∈ ks <;> simp [cleared, hj, hmem] |
| rw [he] at hh |
| refine ⟨2 * (s k).length + 1 + n, ?_, Exec.seq (clear_exec k s) hh⟩ |
| simp only [List.length_cons] |
| have := hs k |
| nlinarith |
|
|
| /-- Restrict to the finitely many registers used by the actual finite code. |
| This proves that infinite ambient names are merely notation, not infinite memory |
| in the delivered machine. Every restricted alphabet is Bool. -/ |
| theorem certificate_any {α β : Type} (ea : α → List Bool) (eb : β → List Bool) |
| (Φ : α → β) (b : Block K) (i o : K) (P : Polynomial ℕ) |
| (correct : ∀ a, ∃ n ≤ P.eval (ea a).length, |
| b.Exec (single i (ea a)) (single o (eb (Φ a))) n) : |
| ∃ M : Turing.TM2ComputableInPolyTime ea eb Φ, ∀ k : M.tm.K, Finite (M.tm.Γ k) := by |
| classical |
| let U := insert i (insert o b.support) |
| let R := ↥U |
| let i' : R := ⟨i, by simp [U]⟩ |
| let o' : R := ⟨o, by simp [U]⟩ |
| let reg : K → R := fun k => if h : k ∈ U then ⟨k, h⟩ else i' |
| let code := b.rename reg |
| have hreg : ∀ k ∈ b.support, (reg k).val = k := by |
| intro k hk |
| simp only [reg, dite_eq_left (show k ∈ U by simp [U, hk])] |
| have hi (w : List Bool) : single i w ∘ (Subtype.val : R → K) = single i' w := by |
| funext j |
| have he : j.val = i ↔ j = i' := by |
| constructor |
| · exact fun h => Subtype.ext h |
| · exact fun h => congrArg Subtype.val h |
| simp only [Function.comp_apply, single, he] |
| have ho (w : List Bool) : single o w ∘ (Subtype.val : R → K) = single o' w := by |
| funext j |
| have he : j.val = o ↔ j = o' := by |
| constructor |
| · exact fun h => Subtype.ext h |
| · exact fun h => congrArg Subtype.val h |
| simp only [Function.comp_apply, single, he] |
| have hcorrect : ∀ a, ∃ n ≤ P.eval (ea a).length, |
| code.Exec (single i' (ea a)) (single o' (eb (Φ a))) n := by |
| intro a |
| obtain ⟨n, hn, hh⟩ := correct a |
| refine ⟨n, hn, ?_⟩ |
| simpa only [hi, ho] using hh.pullback reg (Subtype.val : R → K) Subtype.val_injective hreg |
| exact ⟨code.certificate ea eb Φ i' o' P hcorrect, |
| code.certificate_finite ea eb Φ i' o' P hcorrect⟩ |
|
|
| /-- Uniformly erase every used non-output stack. A proof of the observed output |
| and a polynomial clock suffice; hidden garbage is neither permitted nor assumed |
| away in the exact Mathlib final configuration. -/ |
| theorem certificate_observed {α β : Type} (ea : α → List Bool) (eb : β → List Bool) |
| (Φ : α → β) (b : Block K) (i o : K) (P : Polynomial ℕ) |
| (correct : ∀ a, ∃ n t, n ≤ P.eval (ea a).length ∧ |
| b.Exec (single i (ea a)) t n ∧ t o = eb (Φ a)) : |
| ∃ M : Turing.TM2ComputableInPolyTime ea eb Φ, ∀ k : M.tm.K, Finite (M.tm.Γ k) := by |
| classical |
| let l := ((insert i b.support).erase o).toList |
| let code := Block.seq b (clearMany l) |
| let Q : Polynomial ℕ := P + Polynomial.C l.length * (2 * (Polynomial.X + P) + 1) + 1 |
| apply certificate_any ea eb Φ code i o Q |
| intro a |
| obtain ⟨n, t, hn, hrun, hout⟩ := correct a |
| let N := (ea a).length |
| have ht := (hrun.bounded N (single_bounded i (ea a))).mono (Nat.add_le_add_left hn N) |
| obtain ⟨m, hm, hclear⟩ := clearMany_exec l t (N + P.eval N) ht |
| have hfinal : cleared t l = single o (eb (Φ a)) := by |
| funext k |
| by_cases hko : k = o |
| · subst k |
| simp [cleared, l, single, hout] |
| · by_cases hk : k ∈ l |
| · simp [cleared, hk, single, hko] |
| · have hnot : k ∉ insert i b.support := by |
| intro hh |
| apply hk |
| simp only [l, Finset.mem_toList, Finset.mem_erase] |
| exact ⟨hko, hh⟩ |
| have hi : k ≠ i := fun he => hnot (by simp [he]) |
| have hb : k ∉ b.support := fun he => hnot (Finset.mem_insert_of_mem he) |
| have htk : t k = [] := by simpa only [single, ite_eq_right hi] using hrun.frame k hb |
| simp only [cleared, ite_eq_right hk, single, ite_eq_right hko, htk] |
| rw [hfinal] at hclear |
| refine ⟨n + m, ?_, Exec.seq hrun hclear⟩ |
| simp only [Q, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C, |
| Polynomial.eval_ofNat, Polynomial.eval_one, Polynomial.eval_X] |
| exact (Nat.add_le_add hn hm).trans (by dsimp only [N]; omega) |
| |
| end Block |
| |
| end Superstring.BitCode |
| |
| namespace Superstring.BitCode.Program |
| |
| variable {K : Type} [DecidableEq K] |
|
|
| /-- A syntactically bounded-loop program gives a polynomial-time |
| certificate, including finite alphabets and erasure of temporary registers. -/ |
| theorem certificate {α β : Type} (ea : α → List Bool) (eb : β → List Bool) |
| (f : α → β) (p : Program K) (i o : K) |
| (correct : ∀ a, (p.run (ea a).length (single i (ea a))) o = eb (f a)) : |
| ∃ M : Turing.TM2ComputableInPolyTime ea eb f, ∀ k : M.tm.K, Finite (M.tm.Γ k) := by |
| let b : Block (K ⊕ ℕ) := .seq (Block.copy (.inl i) (.inr 0) (.inr 1)) p.compile |
| let P : Polynomial ℕ := 9 * Polynomial.X + 3 + |
| 13 * p.polynomial * (Polynomial.X + Polynomial.X + p.polynomial + 1) |
| apply Block.certificate_observed ea eb f b (.inl i) (.inl o) P |
| intro a |
| let w := ea a |
| let N := w.length |
| let s := single i w |
| let z : Store ℕ := single 0 w |
| have hinit : Function.update (single (Sum.inl i) w : Store (K ⊕ ℕ)) (.inr 0) w = |
| Sum.elim s z := by |
| funext k |
| cases k with |
| | inl k => simp [s, single] |
| | inr k => |
| by_cases hk : k = 0 <;> simp [z, single, hk] |
| have hcopy := Block.copy_exec (Sum.inl i : K ⊕ ℕ) (.inr 0) (.inr 1) |
| Sum.inl_ne_inr Sum.inl_ne_inr (by simp) (single (.inl i) w) |
| (by simp [single]) |
| have hin : (single (Sum.inl i) w : Store (K ⊕ ℕ)) (.inl i) = w := by simp [single] |
| have hout : (single (Sum.inl i) w : Store (K ⊕ ℕ)) (.inr 0) = [] := by simp [single] |
| rw [hin, hout] at hcopy |
| simp only [List.length_nil, Nat.mul_zero, Nat.zero_add] at hcopy |
| rw [hinit] at hcopy |
| have hz : Clean p.depth z := by |
| constructor |
| · simp [z, single] |
| · intro j _ |
| simp [z, single] |
| have hN : (z 0).length = N := by simp [z, single, N] |
| obtain ⟨n, hn, hh⟩ := p.compile_exec N s N (single_bounded i w) z hz hN |
| refine ⟨9 * N + 3 + n, Sum.elim (p.run N s) z, ?_, Block.Exec.seq hcopy hh, ?_⟩ |
| · simp only [P, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_ofNat, |
| Polynomial.eval_X, Polynomial.eval_one, eval_polynomial] |
| exact Nat.add_le_add_left hn (9 * N + 3) |
| · exact correct a |
|
|
| end Superstring.BitCode.Program |
|
|
| namespace Superstring.BitCode.Block |
|
|
| variable {K L : Type} [DecidableEq K] [DecidableEq L] |
|
|
| @[simp] theorem update_left (s : Store K) (r : Store L) (k : K) (w : List Bool) : |
| Function.update (Sum.elim s r) (.inl k) w = Sum.elim (Function.update s k w) r := by |
| funext j |
| cases j with |
| | inl j => by_cases hj : j = k <;> simp [hj] |
| | inr j => simp |
| |
| @[simp] theorem update_right (s : Store K) (r : Store L) (k : L) (w : List Bool) : |
| Function.update (Sum.elim s r) (.inr k) w = Sum.elim s (Function.update r k w) := by |
| funext j |
| cases j with |
| | inl j => simp |
| | inr j => by_cases hj : j = k <;> simp [hj] |
| |
| /-- Renaming into a disjoint register bank preserves a run and frames the |
| entire other bank, even when that other bank contains nonempty data. -/ |
| theorem Exec.left {b : Block K} {s t : Store K} {n : ℕ} (h : b.Exec s t n) |
| (r : Store L) : (b.rename Sum.inl).Exec (Sum.elim s r) (Sum.elim t r) n := by |
| induction h with |
| | push k x s => |
| simpa only [rename, Sum.elim_inl, update_left] using Exec.push (.inl k) x (Sum.elim s r) |
| | pop k s => |
| simpa only [rename, Sum.elim_inl, update_left] using Exec.pop (.inl k) (Sum.elim s r) |
| | skip => exact .skip _ |
| | branch_none hh _ ih => exact .branch_none hh ih |
| | branch_false hh _ ih => exact .branch_false hh ih |
| | branch_true hh _ ih => exact .branch_true hh ih |
| | seq _ _ ih₁ ih₂ => exact .seq ih₁ ih₂ |
| | loop_nil hh => exact .loop_nil hh |
| | loop_cons hh _ _ ih₁ ih₂ => exact .loop_cons hh ih₁ ih₂ |
|
|
| theorem Exec.right {b : Block L} {s t : Store L} {n : ℕ} (h : b.Exec s t n) |
| (r : Store K) : (b.rename Sum.inr).Exec (Sum.elim r s) (Sum.elim r t) n := by |
| induction h with |
| | push k x s => |
| simpa only [rename, Sum.elim_inr, update_right] using Exec.push (.inr k) x (Sum.elim r s) |
| | pop k s => |
| simpa only [rename, Sum.elim_inr, update_right] using Exec.pop (.inr k) (Sum.elim r s) |
| | skip => exact .skip _ |
| | branch_none hh _ ih => exact .branch_none hh ih |
| | branch_false hh _ ih => exact .branch_false hh ih |
| | branch_true hh _ ih => exact .branch_true hh ih |
| | seq _ _ ih₁ ih₂ => exact .seq ih₁ ih₂ |
| | loop_nil hh => exact .loop_nil hh |
| | loop_cons hh _ _ ih₁ ih₂ => exact .loop_cons hh ih₁ ih₂ |
|
|
| end Superstring.BitCode.Block |
|
|
| end OAI |
|
|
