| import OAI.Computability.SpaceSimulation.Stack.Edit |
| import OAI.Computability.SpaceSimulation.Binary |
|
|
| namespace OAI |
|
|
| /-! Unbounded binary increment and decrement. Simple stack algorithms. -/ |
|
|
| namespace Fifths |
| namespace Bin |
| /-- Write at most one bit before the uncopied high bits. -/ |
| def lastDigit (inc more : Bool) : List Bool := |
| if inc || more then [inc] else [] |
|
|
| def tick (inc : Bool) : List Bool → List Bool |
| | [] => lastDigit inc false |
| | b :: l => |
| if b = inc then (!b) :: tick inc l |
| else lastDigit inc l.head?.isSome ++ l |
|
|
| theorem tick_inc (n : ℕ) : tick true n.bits = (n+1).bits := by |
| induction n using Nat.binaryRec' with |
| | zero => simp [tick,lastDigit] |
| | bit b n h ih => |
| rw [Nat.bits_append_bit n b h] |
| cases b with |
| | false => |
| change tick true _ = (2*n + 1).bits |
| simp [tick,lastDigit] |
| | true => |
| change tick true _ = (2*n+1+1).bits |
| rw [show 2*n+1+1 = 2*(n+1) by omega] |
| simp [tick,ih] |
|
|
| theorem tick_dec (n : ℕ) : tick false n.bits = (n-1).bits := by |
| induction n using Nat.binaryRec' with |
| | zero => simp [tick,lastDigit] |
| | bit b n h ih => |
| rw [Nat.bits_append_bit n b h] |
| cases b with |
| | false => |
| have q : n ≠ 0 := by simpa using h |
| change tick false _ = (2*n - 1).bits |
| rw [show 2*n-1 = 2*(n-1)+1 by omega] |
| simp [tick,ih] |
| | true => |
| change tick false _ = (2*n + 1 - 1).bits |
| by_cases q : n = 0 |
| · subst n; simp [tick,lastDigit] |
| · have e : n.bits.head?.isSome := by |
| have g : n.bits ≠ [] := by simpa using q |
| cases r : n.bits |
| · contradiction |
| · simp |
| simp [tick,lastDigit,e,q] |
| end Bin |
|
|
| namespace SM |
| open Bin |
| variable {X J K : Type} [DecidableEq K] |
|
|
| def finishDigit (inc : Bool) (k : K) : SM X J K Unit := |
| (peek (fun _ t => (t k).isSome)).bind (fun b => prepend k (lastDigit inc b)) |
|
|
| def finish (inc : Bool) (k t : K) : SM X J K (Option Unit) := |
| (finishDigit inc k).seq ((spill t k).seq (pure (some ()))) |
|
|
| def continueCarry (inc : Bool) (k t : K) : Option Bool → SM X J K (Option Unit) |
| | none => finish inc k t |
| | some b => if b = inc then |
| (prepend t [!b]).seq (pure none) |
| else finish inc k t |
|
|
| def carry (inc : Bool) (k t : K) : SM X J K Unit := |
| ((pop k).bind (continueCarry inc k t)).loop |
|
|
| theorem exec_finish {i : Inputs X J} {s : Store J K} {B} (inc : Bool) (k t : K) |
| (a : t ≠ k) (o : s.ok B) (p : (s.st k).length + (s.st t).length + 1 ≤ B) : |
| (finish inc k t).Exec i B s |
| ((s.set t []).set k ((s.st t).reverse ++ |
| (lastDigit inc (s.st k).head?.isSome ++ s.st k))) (some ()) := by |
| let l := lastDigit inc (s.st k).head?.isSome ++ s.st k |
| have h : l.length ≤ (s.st k).length + 1 := by |
| cases inc <;> cases e : (s.st k).head? <;> |
| simp [l,lastDigit,e] |
| have e : (finishDigit inc k).Exec i B s (s.set k l) () := |
| exec_bind _ _ (exec_peek o) |
| (exec_prepend k _ o (show l.length ≤ B by omega)) |
| have r := exec_spill (i := i) t k a e.endOk |
| (by simp only [Store.set_other _ _ a, Store.set_same]; omega) |
| have v := exec_seq e (exec_seq r (exec_pure (y := some ()) r.endOk)) |
| rw [Store.set_other _ _ a, Store.set_same, Store.set_swap s a, Store.set_set] at v |
| exact v |
|
|
| def carried (s : Store J K) (inc : Bool) (k t : K) := |
| (s.set t []).set k ((s.st t).reverse ++ tick inc (s.st k)) |
|
|
| theorem exec_carry {i : Inputs X J} {s : Store J K} {B} |
| (inc : Bool) (k t : K) |
| (a : t ≠ k) (o : s.ok B) (p : (s.st k).length + (s.st t).length + 1 ≤ B) : |
| (carry inc k t).Exec i B s (carried s inc k t) () := by |
| generalize e : s.st k = l |
| induction l generalizing s with |
| | nil => |
| have h : s.set k [] = s := by rw [← e]; simp |
| have f : (pop k).Exec i B s s none := by |
| simpa [e,h] using exec_pop (i := i) k o |
| have g := exec_finish (i := i) inc k t a o p |
| unfold carry |
| refine loop_stop _ (exec_bind _ _ f ?_) |
| simpa only [continueCarry,carried,e,tick,List.append_nil,List.head?_nil,Option.isSome_none] |
| using g |
| | cons b l ih => |
| let u := s.set k l |
| have f : (pop k).Exec i B s u (some b) := by |
| simpa [e,u] using exec_pop (i := i) k o |
| have ul : u.st k = l := by simp [u] |
| have y : u.st t = s.st t := by simp [u,a] |
| by_cases c : b = inc |
| · subst b |
| let v := u.set t ((!inc) :: s.st t) |
| have e' : ([!inc] ++ u.st t).length ≤ B := by |
| simp [e] at p; simp only [y,List.cons_append,List.nil_append,List.length_cons]; omega |
| have g : (prepend t [!inc]).Exec i B u v () := by |
| simpa only [v,y,List.cons_append,List.nil_append] using |
| exec_prepend (i := i) t _ f.endOk e' |
| have vk : v.st k = l := by simp [v,a.symm,ul] |
| have h := ih g.endOk (by simp [e] at p; simp only [vk,v,Store.set_same,List.length_cons]; |
| omega) vk |
| have r : carried s inc k t = carried v inc k t := by |
| unfold carried |
| simp only [vk,v,u,Store.set_same, Store.set_set,e,tick,ite_true,List.reverse_cons, |
| List.append_assoc,List.cons_append,List.nil_append] |
| rw [Store.set_swap s a, Store.set_set] |
| rw [r] |
| unfold carry |
| refine loop_continue _ (exec_bind _ _ f ?_) h |
| simpa only [continueCarry,ite_true] using |
| exec_seq g (exec_pure (y := (none : Option Unit)) g.endOk) |
| · have g := exec_finish (i := i) inc k t a f.endOk |
| (by simp only [ul,y]; simp [e] at p; omega) |
| unfold carry |
| refine loop_stop _ (exec_bind _ _ f ?_) |
| simp only [continueCarry,c,ite_false,carried,tick,e] |
| simpa only [ul,y,u,Store.set_swap s a,Store.set_set] using g |
| end SM |
| end Fifths |
|
|
| end OAI |
|
|
