| import OAI.Computability.SpaceSimulation.Stack.Comp |
|
|
| namespace OAI |
|
|
| /-! Some elementary SM programs and their space bounds. We move by |
| popping into empty scratch stacks or onto stacks already in use; as |
| long as the end stacks of such a drain fit, the intermediate writes fit. |
| All lemmas here bound maximum height, not time. -/ |
| namespace Fifths |
| variable {X J K : Type} |
|
|
| namespace Store |
| @[ext] theorem ext' {s t : Store J K} (r : s.ro = t.ro) (a : ∀ k, s.st k = t.st k) : |
| s = t := by cases s; cases t; congr; exact funext a |
|
|
| def atX (s : Store J K) (p : ℕ) : Store J K := |
| ⟨{s.ro with px := p}, s.st⟩ |
|
|
| def pre (s : Store J K) (dest : K → Bool) (l : List Bool) : Store J K := |
| ⟨s.ro, fun k => if dest k then l ++ s.st k else s.st k⟩ |
|
|
| @[simp] theorem pre_nil (s : Store J K) (d : K → Bool) : |
| s.pre d [] = s := by |
| refine ext' rfl ?_; simp [pre] |
| @[simp] theorem pre_pre (s : Store J K) (d : K → Bool) (l m) : |
| (s.pre d l).pre d m = s.pre d (m ++ l) := by |
| refine ext' rfl ?_; intro k; cases e : d k <;> simp [pre,e] |
|
|
| section |
| variable [DecidableEq K] |
|
|
| def set (s : Store J K) (k : K) (l : List Bool) : Store J K := |
| ⟨s.ro, Function.update s.st k l⟩ |
|
|
| @[simp] theorem set_ro (s : Store J K) (k l) : (s.set k l).ro = s.ro := rfl |
| @[simp] theorem set_same (s : Store J K) (k l) : (s.set k l).st k = l := by simp [set] |
| @[simp] theorem set_other (s : Store J K) {k y} (l) (h : y ≠ k) : |
| (s.set k l).st y = s.st y := by simp [set,h] |
|
|
| @[simp] theorem set_set (s : Store J K) (k l m) : (s.set k l).set k m = s.set k m := by |
| refine ext' rfl ?_; intro y; by_cases h : y = k <;> simp [h] |
| @[simp] theorem set_self (s : Store J K) (k) : s.set k (s.st k) = s := by simp [set] |
| theorem set_swap (s : Store J K) {k y} (h : y ≠ k) (l m) : |
| (s.set k l).set y m = (s.set y m).set k l := by |
| refine ext' rfl ?_ |
| intro z |
| by_cases a : z = k |
| · subst z; simp [Ne.symm h] |
| by_cases b : z = y |
| · subst z; simp [h] |
| simp [a,b] |
|
|
| theorem set_ok {s : Store J K} {k l B} (o : s.ok B) (p : l.length ≤ B) : |
| (s.set k l).ok B := by |
| intro y |
| by_cases h : y = k |
| · simpa [h] using p |
| · simpa [h] using o y |
|
|
| def drained (s : Store J K) (k : K) (d : K → Bool) (code : Bool → List Bool) : |
| Store J K := |
| (s.set k []).pre d ((s.st k).reverse.flatMap code) |
|
|
| end |
| end Store |
|
|
| namespace SM |
| section Simple |
| variable [DecidableEq K] |
|
|
| def editOne (k : K) (a : StOp) : StChange J K := |
| ⟨{}, Function.update (fun _ => .keep) k a⟩ |
|
|
| theorem perform_one (s : Store J K) (i : Inputs X J) (k : K) (a : StOp) : |
| s.perform i (editOne k a) = s.set k (a.apply (s.st k)) := by |
| refine Store.ext' rfl ?_; intro y |
| by_cases h : y = k |
| · subst y; simp [Store.perform,editOne] |
| · simp [Store.perform,editOne,h,StOp.apply] |
|
|
| / |
| def pop (k : K) : SM X J K (Option Bool) := |
| act (fun _ t => (t k, editOne k .pop)) |
|
|
| theorem exec_pop {i : Inputs X J} {s : Store J K} {B} (k : K) |
| (o : s.ok B) : (pop k).Exec i B s (s.set k (s.st k).tail) (s.st k).head? := by |
| rw [show s.set k (s.st k).tail = s.perform i (editOne k .pop) from |
| (perform_one s i k .pop).symm] |
| refine exec_act rfl o ?_ |
| rw [perform_one] |
| apply Store.set_ok o |
| specialize o k |
| cases e : s.st k with |
| | nil => simp [StOp.apply] |
| | cons a b => simp [e] at o; simp [StOp.apply]; omega |
|
|
| end Simple |
|
|
| / |
| def racks (d : K → Bool) (b : Bool) : StChange J K := |
| ⟨{}, fun k => if d k then .push b else .keep⟩ |
|
|
| theorem racks_perform (s : Store J K) (i : Inputs X J) (d) (b) : |
| s.perform i (racks d b) = s.pre d [b] := by |
| refine Store.ext' rfl ?_; intro k; cases e : d k <;> |
| simp [Store.perform, racks, StOp.apply, e, Store.pre] |
|
|
| def broadcast (d : K → Bool) : List Bool → SM X J K Unit |
| | [] => pure () |
| | b :: l => (broadcast d l).seq (change (racks d b)) |
|
|
| theorem exec_broadcast {i : Inputs X J} {s : Store J K} {B} |
| (d : K → Bool) (l : List Bool) |
| (o : s.ok B) (p : (s.pre d l).ok B) : |
| (broadcast d l).Exec i B s (s.pre d l) () := by |
| induction l with |
| | nil => simpa [broadcast] using exec_pure (i := i) (y := ()) o |
| | cons b l ih => |
| have h : (s.pre d l).ok B := by |
| intro k; specialize p k |
| cases e : d k |
| · simpa [Store.pre,e] using p |
| · simp [Store.pre,e] at *; omega |
| have t : (s.pre d l).perform i (racks d b) = s.pre d (b :: l) := by |
| simp [racks_perform] |
| exact exec_seq (ih h) |
| (t ▸ exec_change (racks d b) h (show ((s.pre d l).perform i (racks d b)).ok B from |
| t.symm ▸ p)) |
| section |
| variable [DecidableEq K] |
|
|
| def onto (k : K) : K → Bool := fun y => decide (y = k) |
|
|
| theorem pre_onto (s : Store J K) (k l) : s.pre (onto k) l = s.set k (l ++ s.st k) := by |
| refine Store.ext' rfl ?_; intro y |
| by_cases h : y = k <;> simp [Store.pre,h,onto] |
|
|
| def prepend (k : K) (l : List Bool) : SM X J K Unit := broadcast (onto k) l |
| theorem exec_prepend {i : Inputs X J} {s : Store J K} {B} (k : K) (l : List Bool) |
| (o : s.ok B) (p : (l ++ s.st k).length ≤ B) : |
| (prepend k l).Exec i B s (s.set k (l ++ s.st k)) () := by |
| rw [← pre_onto] |
| refine exec_broadcast _ _ o ?_ |
| rw [pre_onto]; exact Store.set_ok o p |
|
|
| / |
| (possibly zero), with each popped bit mapped to its own fixed code. -/ |
| def drainBody (k : K) (d : K → Bool) (code : Bool → List Bool) : |
| SM X J K (Option Unit) := |
| (pop k).bind fun |
| | none => pure (some ()) |
| | some b => (broadcast d (code b)).seq (pure none) |
|
|
| def drain (k : K) (d : K → Bool) (code : Bool → List Bool) : |
| SM X J K Unit := |
| (drainBody k d code).loop |
|
|
| theorem exec_drain {i : Inputs X J} {s : Store J K} {B} |
| (k : K) (d : K → Bool) (code : Bool → List Bool) (dk : d k = false) |
| (o : s.ok B) (p : (s.drained k d code).ok B) : |
| (drain k d code).Exec i B s (s.drained k d code) () := by |
| generalize h : s.st k = l |
| induction l generalizing s with |
| | nil => |
| have e₁ : (pop k).Exec i B s s none := by |
| have e := exec_pop (i := i) k (s := s) o |
| have g : s.set k [] = s := by rw [← h]; simp |
| simpa [h,g] using e |
| have e₂ : (drainBody k d code).Exec i B s s (some ()) := by |
| unfold drainBody |
| refine exec_bind _ _ e₁ ?_ |
| exact exec_pure o |
| have r : s.drained k d code = s := by |
| simp only [Store.drained,h,List.reverse_nil,List.flatMap_nil,Store.pre_nil] |
| rw [← h]; simp |
| rw [r] |
| exact loop_stop _ e₂ |
| | cons b l ih => |
| let t := s.set k l |
| have ot : t.ok B := by |
| apply Store.set_ok o |
| specialize o k |
| simp [h] at o; omega |
| let u := t.pre d (code b) |
| have hu : u.st k = l := by simp [u,t,Store.pre,dk] |
| have r : u.drained k d code = s.drained k d code := by |
| simp only [Store.drained,h,hu] |
| refine Store.ext' rfl ?_ |
| intro y |
| by_cases hy : y = k |
| · subst y; simp [Store.pre, dk] |
| · cases e : d y <;> simp [Store.pre,hy,e,u,t] |
| have ou : u.ok B := by |
| rw [← r] at p |
| intro y |
| by_cases hy : y = k |
| · subst y; simpa [hu,t] using ot k |
| · specialize p y |
| cases e : d y |
| · simpa [Store.drained,Store.pre,e,hy] using p |
| · simp [Store.drained,Store.pre,e,hy] at p; omega |
| have e₁ : (pop k).Exec i B s t (some b) := by |
| simpa [t,h] using exec_pop (i := i) k o |
| have e₂ : (drainBody k d code).Exec i B s u none := by |
| unfold drainBody |
| refine exec_bind _ _ e₁ ?_ |
| exact exec_seq (exec_broadcast _ _ ot ou) (exec_pure ou) |
| rw [← r] |
| exact loop_continue _ e₂ (ih ou (r.symm ▸ p) hu) |
|
|
| def clear (k : K) : SM X J K Unit := drain k (fun _ => false) (fun _ => []) |
|
|
| theorem exec_clear {i : Inputs X J} {s : Store J K} {B} (k : K) (o : s.ok B) : |
| (clear k).Exec i B s (s.set k []) () := by |
| have h : s.drained k (fun _ => false) (fun _ => []) = s.set k [] := by |
| refine Store.ext' rfl ?_; simp [Store.drained, Store.pre] |
| rw [← h] |
| exact exec_drain k _ _ rfl o (h.symm ▸ Store.set_ok o (by simp)) |
|
|
| def spill (k y : K) : SM X J K Unit := drain k (onto y) (fun b => [b]) |
| theorem exec_spill {i : Inputs X J} {s : Store J K} {B} (k y : K) (h : k ≠ y) |
| (o : s.ok B) (p : (s.st k).length + (s.st y).length ≤ B) : |
| (spill k y).Exec i B s ((s.set k []).set y ((s.st k).reverse ++ s.st y)) () := by |
| have r : s.drained k (onto y) (fun b => [b]) = |
| (s.set k []).set y ((s.st k).reverse ++ s.st y) := by |
| simp [Store.drained,pre_onto,h.symm] |
| rw [← r] |
| refine exec_drain k _ _ (by simp [onto,h]) o ?_ |
| rw [r] |
| apply Store.set_ok (Store.set_ok o (by simp)) |
| simpa using p |
| end |
|
|
| / |
| def rewind : SM X J K Unit := |
| (act (fun r _ => |
| match r.sx with |
| | .left => (some (), .none) |
| | _ => (none, (⟨{dx := .L}, fun _ => .keep⟩)))).loop |
|
|
| theorem exec_rewind {i : Inputs X J} {s : Store J K} {B} (o : s.ok B) : |
| rewind.Exec i B s (s.atX 0) () := by |
| let a (r : Reads X J) (_ : K → Option Bool) : Option Unit × StChange J K := |
| match r.sx with |
| | .left => (some (), .none) |
| | _ => (none, ⟨{dx := .L}, fun _ => .keep⟩) |
| change (act a).loop.Exec _ _ _ _ _ |
| generalize h : s.ro.px = p |
| induction p generalizing s with |
| | zero => |
| have g : (s.ro.see i).sx = .left := by simp [Readers.see,h] |
| have e : s.atX 0 = s := by rw [← h]; rfl |
| rw [e] |
| exact loop_stop _ (show (act a).Exec i B s s (some ()) from |
| exec_act (c := .none) (by simp [a,g]) o o) |
| | succ p ih => |
| have g : (s.ro.see i).sx ≠ .left := by simp [Readers.see,h] |
| let c : StChange J K := ⟨{dx := .L}, fun _ => .keep⟩ |
| have e : a (s.ro.see i) s.see = (none,c) := by |
| cases e : (s.ro.see i).sx with |
| | left => contradiction |
| | right => simp [a,e,c] |
| | sym => simp [a,e,c] |
| have r : s.perform i c = s.atX p := by |
| simp [Store.perform,c,Readers.walk, Mark.walk,h,Store.atX,StOp.apply] |
| have t : (s.atX p).ok B := o |
| exact loop_continue _ (show (act a).Exec i B s (s.atX p) none from |
| r ▸ exec_act e o (r.symm ▸ t)) |
| (ih t rfl) |
| end SM |
| end Fifths |
|
|
| end OAI |
|
|
