| import OAI.Computability.WLIdentification.WordCommands |
|
|
| namespace OAI |
|
|
| namespace WLIdentification |
|
|
| namespace BoundedWords |
| open StackModel (Command) |
|
|
| /-- Word-register programs with bounded, captured-count loops. No unbounded |
| natural register, whole-input transition or host-language oracle is available. -/ |
| inductive Program (K : Type) where |
| | skip |
| | clear (k : K) |
| | push (k : K) (b : Bool) |
| | pop (k : K) |
| | copy (a b : K) |
| | seq (p q : Program K) |
| | cases (k : K) (empty zero one : Program K) |
| | repeat (k : K) (body : Program K) |
|
|
| namespace Program |
| variable {K : Type} [DecidableEq K] |
|
|
| def eval : Program K → (K → Word) → (K → Word) |
| | .skip, S => S |
| | .clear k, S => Function.update S k [] |
| | .push k b, S => Function.update S k (S k ++ [b]) |
| | .pop k, S => Function.update S k (S k).dropLast |
| | .copy a b, S => Function.update S b (S a) |
| | .seq p q, S => q.eval (p.eval S) |
| | .cases k nil zero one, S => match (S k).getLast? with |
| | none => nil.eval S |
| | some false => zero.eval S |
| | some true => one.eval S |
| | .repeat k p, S => p.eval^[(S k).length] S |
|
|
| def Size (S : K → Word) (B : ℕ) : Prop := ∀ k, (S k).length ≤ B |
|
|
| /-- An explicit bound on all data consumed by an execution. Proving this |
| invariant for an algorithm, rather than assuming its runtime, yields a cost. -/ |
| def Fits : Program K → (K → Word) → ℕ → Prop |
| | .skip, S, B | .clear _, S, B | .push _ _, S, B | .pop _, S, B | .copy _ _, S, B => Size S B |
| | .seq p q, S, B => p.Fits S B ∧ q.Fits (p.eval S) B |
| | .cases k nil zero one, S, B => Size S B ∧ match (S k).getLast? with |
| | none => nil.Fits S B |
| | some false => zero.Fits S B |
| | some true => one.Fits S B |
| | .repeat k p, S, B => Size S B ∧ ∀ i < (S k).length, p.Fits (p.eval^[i] S) B |
|
|
| abbrev Work : Program K → Type |
| | .skip | .clear _ | .push _ _ | .pop _ => Empty |
| | .copy _ _ => Unit |
| | .seq p q => Work p ⊕ Work q |
| | .cases _ p q r => Work p ⊕ (Work q ⊕ Work r) |
| | .repeat _ p => Work p ⊕ Bool |
|
|
| noncomputable instance workFintype (p : Program K) : Fintype p.Work := by |
| induction p <;> simp only [Work] <;> infer_instance |
| instance workDecidableEq : (p : Program K) → DecidableEq p.Work |
| | .skip | .clear _ | .push _ _ | .pop _ => inferInstance |
| | .copy _ _ => inferInstance |
| | .seq p q => @instDecidableEqSum _ _ (workDecidableEq p) (workDecidableEq q) |
| | .cases _ p q r => @instDecidableEqSum _ _ (workDecidableEq p) |
| (@instDecidableEqSum _ _ (workDecidableEq q) (workDecidableEq r)) |
| | .repeat _ p => @instDecidableEqSum _ _ (workDecidableEq p) inferInstance |
|
|
| def cost : Program K → ℕ → ℕ |
| | .skip, _ => 1 |
| | .clear _, B => 3 * B + 2 |
| | .push _ _, _ | .pop _, _ => 2 |
| | .copy _ _, B => 12 * B + 8 |
| | .seq p q, B => p.cost B + q.cost B |
| | .cases _ p q r, B => max (p.cost B) (max (q.cost B) (r.cost B)) + 4 |
| | .repeat _ p, B => 12 * B + 8 + (p.cost B + 2) * B + 2 |
|
|
| noncomputable def compile : (p : Program K) → Command (K ⊕ p.Work) (Option Bool) |
| | .skip => .modify (fun _ => none) |
| | .clear k => Command.clear (.inl k) |
| | .push k b => .seq (.push (.inl k) (fun _ => b)) (.modify (fun _ => none)) |
| | .pop k => .seq (.pop (.inl k) (fun _ _ => none)) (.modify (fun _ => none)) |
| | .copy a b => if a = b then .modify (fun _ => none) |
| else Command.copy (.inl a) (.inl b) (.inr ()) |
| | .seq p q => .seq (p.compile.rename Command.embedLeft) (q.compile.rename Command.embedRight) |
| | .cases k p q r => |
| .seq (Command.read (.inl k)) (.branch Option.isSome |
| (.seq (Command.emit (.inl k)) (.branch (fun b => b.getD false) |
| (r.compile.rename (Command.embedRight.trans Command.embedRight)) |
| (q.compile.rename (Command.embedLeft.trans Command.embedRight)))) |
| (p.compile.rename Command.embedLeft)) |
| | .repeat k p => .seq (Command.copy (.inl k) (.inr (.inr false)) (.inr (.inr true))) |
| (Command.drain (.inr (.inr false)) (p.compile.rename Command.embedLeft)) |
|
|
| omit [DecidableEq K] in |
| /-- Every syntactic cost is polynomial in the maintained word bound; its |
| constants depend on finite code, not the input or loop counts. -/ |
| theorem cost_polynomial (p : Program K) : ∃ C d : ℕ, ∀ B, p.cost B ≤ C * (B + 1)^d := by |
| induction p with |
| | skip => exact ⟨1, 0, by intro B; simp [cost]⟩ |
| | clear k => exact ⟨5, 1, by intro B; simp only [cost, pow_one]; omega⟩ |
| | push k b | pop k => exact ⟨2, 0, by intro B; simp [cost]⟩ |
| | copy a b => exact ⟨20, 1, by intro B; simp only [cost, pow_one]; omega⟩ |
| | seq p q ihp ihq => |
| obtain ⟨C, d, hp⟩ := ihp |
| obtain ⟨D, e, hq⟩ := ihq |
| refine ⟨C + D, max d e, ?_⟩ |
| intro B |
| have hp' := (hp B).trans (Nat.mul_le_mul_left C (Nat.pow_le_pow_right (by omega) (le_max_left d e))) |
| have hq' := (hq B).trans (Nat.mul_le_mul_left D (Nat.pow_le_pow_right (by omega) (le_max_right d e))) |
| dsimp only [cost] |
| nlinarith |
| | cases k p q r ihp ihq ihr => |
| obtain ⟨C,d,hp⟩ := ihp |
| obtain ⟨D,e,hq⟩ := ihq |
| obtain ⟨E,f,hr⟩ := ihr |
| let z := max d (max e f) |
| have hdz : d ≤ z := le_max_left _ _ |
| have hez : e ≤ z := (le_max_left _ _).trans (le_max_right _ _) |
| have hfz : f ≤ z := (le_max_right _ _).trans (le_max_right _ _) |
| refine ⟨C + D + E + 4, z, ?_⟩ |
| intro B |
| have hpos : 1 ≤ (B+1)^z := Nat.one_le_pow _ _ (by omega) |
| have hp' := (hp B).trans (Nat.mul_le_mul_left C (Nat.pow_le_pow_right (by omega) hdz)) |
| have hq' := (hq B).trans (Nat.mul_le_mul_left D (Nat.pow_le_pow_right (by omega) hez)) |
| have hr' := (hr B).trans (Nat.mul_le_mul_left E (Nat.pow_le_pow_right (by omega) hfz)) |
| dsimp only [cost] |
| have hm : max (p.cost B) (max (q.cost B) (r.cost B)) ≤ (C+D+E)*(B+1)^z := by |
| apply max_le |
| · nlinarith |
| · apply max_le <;> nlinarith |
| nlinarith |
| | «repeat» k p ih => |
| obtain ⟨C,d,hp⟩ := ih |
| refine ⟨C+24, d+1, ?_⟩ |
| intro B |
| have hpos : 1 ≤ (B+1)^d := Nat.one_le_pow _ _ (by omega) |
| have hmul := Nat.mul_le_mul_right B (hp B) |
| simp only [cost, pow_succ] |
| nlinarith |
|
|
| end Program |
| end BoundedWords |
|
|
| namespace BoundedWords.Program |
| open StackModel.Command |
| variable {K : Type} [DecidableEq K] |
|
|
| @[simp] theorem elim_empty {A B : Type} : |
| Sum.elim (fun _ : A => ([] : Word)) (fun _ : B => []) = fun _ => [] := by |
| funext x; cases x <;> rfl |
|
|
| theorem update_inl {A : Type} [DecidableEq A] (S : K → Word) (W : A → Word) (k : K) (v : Word) : |
| Function.update (Sum.elim S W) (.inl k) v = Sum.elim (Function.update S k v) W := by |
| funext x |
| cases x with |
| | inl j => by_cases h : j = k <;> simp [h] |
| | inr a => simp |
|
|
| def Correct (p : Program K) : Prop := ∀ S B, p.Fits S B → ∀ s : Option Bool, |
| ∃ n ≤ p.cost B, Exec p.compile s (Sum.elim S (fun _ => [])) none |
| (Sum.elim (p.eval S) (fun _ => [])) n |
|
|
| theorem correct_skip : Correct (.skip : Program K) := by |
| intro S B h s |
| exact ⟨1, le_rfl, .modify _ _ _⟩ |
|
|
| theorem correct_clear (k : K) : Correct (.clear k) := by |
| intro S B h s |
| obtain ⟨n, hn, he⟩ := clear_exec (.inl k : K ⊕ Empty) s (Sum.elim S (fun _ => [])) |
| refine ⟨n, hn.trans (by dsimp only [Sum.elim_inl, cost]; have := h k; omega), ?_⟩ |
| simpa only [compile, eval, update_inl] using he |
|
|
| theorem correct_push (k : K) (b : Bool) : Correct (.push k b) := by |
| intro S B h s |
| have he := Exec.seq (Exec.push (.inl k : K ⊕ Empty) (fun _ : Option Bool => b) s |
| (Sum.elim S (fun _ => []))) (Exec.modify (fun _ => none) s _) |
| refine ⟨2, le_rfl, ?_⟩ |
| simpa only [compile, eval, Sum.elim_inl, update_inl] using he |
|
|
| theorem correct_pop (k : K) : Correct (.pop k) := by |
| intro S B h s |
| have he := Exec.seq (Exec.pop (.inl k : K ⊕ Empty) (fun _ _ : Option Bool => none) s |
| (Sum.elim S (fun _ => []))) (Exec.modify (fun _ => none) none _) |
| refine ⟨2, le_rfl, ?_⟩ |
| simpa only [compile, eval, Sum.elim_inl, update_inl] using he |
|
|
| theorem correct_copy (a b : K) : Correct (.copy a b) := by |
| intro S B h s |
| by_cases hab : a = b |
| · subst b |
| refine ⟨1, by dsimp [cost]; omega, ?_⟩ |
| simpa only [compile, ite_eq_left rfl, ite_true, eval, Function.update_eq_self] using |
| (Exec.modify (fun _ : Option Bool => none) s (Sum.elim S (fun _ : Unit => []))) |
| · obtain ⟨n, hn, he⟩ := copy_exec (.inl a : K ⊕ Unit) (.inl b) (.inr ()) |
| (by simpa using hab) (by simp) (by simp) s (Sum.elim S (fun _ => [])) |
| have hs : Function.update (Function.update (Sum.elim S (fun _ : Unit => [])) (.inl b) (S a)) |
| (.inr ()) [] = Sum.elim (Function.update S b (S a)) (fun _ => []) := by |
| rw [update_inl] |
| exact Function.update_eq_self _ _ |
| refine ⟨n, hn.trans ?_, ?_⟩ |
| · simp only [Sum.elim_inl, Sum.elim_inr, List.length_nil, mul_zero, add_zero, cost] |
| have := h a; have := h b; omega |
| · simpa only [compile, ite_eq_right hab, eval, Sum.elim_inl, hs] using he |
|
|
| theorem correct_seq {p q : Program K} (hp : Correct p) (hq : Correct q) : Correct (.seq p q) := by |
| intro S B h s |
| obtain ⟨a, ha, hea⟩ := hp S B h.1 s |
| obtain ⟨b, hb, heb⟩ := hq (p.eval S) B h.2 none |
| refine ⟨b+a, by dsimp only [cost]; omega, ?_⟩ |
| have he := Exec.seq (hea.left (fun _ : q.Work => [])) (heb.right (fun _ : p.Work => [])) |
| simpa only [compile, eval, elim_empty] using he |
|
|
| theorem correct_cases {k : K} {p q r : Program K} (hp : Correct p) (hq : Correct q) |
| (hr : Correct r) : Correct (.cases k p q r) := by |
| intro S B h s |
| let W : K ⊕ (p.Work ⊕ (q.Work ⊕ r.Work)) → Word := Sum.elim S (fun _ => []) |
| cases hl : (S k).getLast? with |
| | none => |
| have hw : S k = [] := List.getLast?_eq_none_iff.mp hl |
| obtain ⟨n, hn, he⟩ := hp S B (by simpa only [Fits, hl] using h.2) none |
| have hu : Function.update W (.inl k) [] = W := by |
| have hw' : W (.inl k) = [] := hw |
| rw [← hw'] |
| exact Function.update_eq_self _ _ |
| have hread : Exec (StackModel.Command.read (.inl k)) s W none W 1 := by |
| simpa only [StackModel.Command.read, show W (.inl k) = [] from hw, List.getLast?_nil, List.dropLast_nil, hu] using |
| Exec.pop (.inl k) (fun _ b => b) s W |
| have he' := he.left (fun _ : q.Work ⊕ r.Work => []) |
| simp only [elim_empty] at he' |
| refine ⟨n+2, by dsimp only [cost]; have := le_max_left (p.cost B) (max (q.cost B) (r.cost B)); omega, ?_⟩ |
| have hex := Exec.seq hread (Exec.branch_false (test := Option.isSome) (c := .seq (emit (.inl k)) |
| (.branch (fun x : Option Bool => x.getD false) |
| (r.compile.rename (embedRight.trans embedRight)) |
| (q.compile.rename (embedLeft.trans embedRight)))) (by rfl) he') |
| simpa only [compile, eval, hl, elim_empty, W, Nat.add_assoc] using hex |
| | some b => |
| obtain ⟨v, hv⟩ := List.getLast?_eq_some_iff.mp hl |
| let V := Function.update W (.inl k) v |
| have hread : Exec (StackModel.Command.read (.inl k)) s W (some b) V 1 := by |
| simpa only [StackModel.Command.read, show W (.inl k) = v ++ [b] from hv, |
| List.getLast?_append, List.getLast?_singleton, Option.some_or, |
| List.dropLast_append_cons, List.dropLast_singleton, List.append_nil, V] using |
| Exec.pop (.inl k) (fun _ b => b) s W |
| have hrestore : Function.update V (.inl k) (V (.inl k) ++ [b]) = W := by |
| simp only [V, Function.update_self, Function.update_idem] |
| exact (congrArg (Function.update W (.inl k)) hv.symm).trans (Function.update_eq_self _ _) |
| have hemit : Exec (emit (.inl k)) (some b) V (some b) W 1 := by |
| simpa only [emit, Option.getD_some, hrestore] using |
| Exec.push (.inl k) (fun x : Option Bool => x.getD false) (some b) V |
| cases b with |
| | false => |
| obtain ⟨n, hn, he⟩ := hq S B (by simpa only [hl] using h.2) (some false) |
| have he' := (he.left (fun _ : r.Work => [])).right (fun _ : p.Work => []) |
| simp only [elim_empty] at he' |
| have hex := Exec.seq hread (Exec.branch_true (test := Option.isSome) (d := p.compile.rename embedLeft) (by rfl) |
| (Exec.seq hemit (Exec.branch_false (test := fun x : Option Bool => x.getD false) |
| (c := r.compile.rename (embedRight.trans embedRight)) (by rfl) he'))) |
| refine ⟨n+4, ?_, ?_⟩ |
| · dsimp only [cost] |
| have := (le_max_left (q.cost B) (r.cost B)).trans (le_max_right (p.cost B) _) |
| omega |
| · simpa only [compile, eval, hl, elim_empty, rename_rename, |
| Function.Embedding.coe_trans, W, Nat.add_assoc, Nat.reduceAdd] using hex |
| | true => |
| obtain ⟨n, hn, he⟩ := hr S B (by simpa only [hl] using h.2) (some true) |
| have he' := (he.right (fun _ : q.Work => [])).right (fun _ : p.Work => []) |
| simp only [elim_empty] at he' |
| have hex := Exec.seq hread (Exec.branch_true (test := Option.isSome) (d := p.compile.rename embedLeft) (by rfl) |
| (Exec.seq hemit (Exec.branch_true (test := fun x : Option Bool => x.getD false) |
| (d := q.compile.rename (embedLeft.trans embedRight)) (by rfl) he'))) |
| refine ⟨n+4, ?_, ?_⟩ |
| · dsimp only [cost] |
| have := (le_max_right (q.cost B) (r.cost B)).trans (le_max_right (p.cost B) _) |
| omega |
| · simpa only [compile, eval, hl, elim_empty, rename_rename, |
| Function.Embedding.coe_trans, W, Nat.add_assoc, Nat.reduceAdd] using hex |
|
|
| end BoundedWords.Program |
|
|
| namespace BoundedWords.Program |
| open StackModel.Command |
| variable {K : Type} [DecidableEq K] |
|
|
| def counterData (w : Word) : Bool → Word := fun b => if b then [] else w |
|
|
| def loopState {A : Type} (S : K → Word) (w : Word) : K ⊕ (A ⊕ Bool) → Word := |
| Sum.elim S (Sum.elim (fun _ => []) (counterData w)) |
|
|
| omit [DecidableEq K] in |
| @[simp] theorem loopState_var {A : Type} (S : K → Word) (w : Word) (k : K) : |
| loopState (A:=A) S w (.inl k) = S k := rfl |
| omit [DecidableEq K] in |
| @[simp] theorem loopState_counter {A : Type} (S : K → Word) (w : Word) : |
| loopState (A:=A) S w (.inr (.inr false)) = w := rfl |
| omit [DecidableEq K] in |
| @[simp] theorem loopState_temp {A : Type} (S : K → Word) (w : Word) : |
| loopState (A:=A) S w (.inr (.inr true)) = [] := rfl |
|
|
| omit [DecidableEq K] in |
| @[simp] theorem loopState_empty {A : Type} (S : K → Word) : |
| loopState (A:=A) S [] = Sum.elim S (fun _ => []) := by |
| funext x |
| cases x with |
| | inl k => rfl |
| | inr x => cases x with |
| | inl a => rfl |
| | inr b => cases b <;> rfl |
|
|
| theorem update_counter {A : Type} [DecidableEq A] (S : K → Word) (w v : Word) : |
| Function.update (loopState (A:=A) S w) (.inr (.inr false)) v = loopState S v := by |
| funext x |
| cases x with |
| | inl k => simp [loopState] |
| | inr x => cases x with |
| | inl a => simp [loopState] |
| | inr b => cases b <;> simp [loopState, counterData] |
|
|
| /-- The captured counter is consumed one bit per loop, independently of all |
| public registers modified by the body. -/ |
| theorem drain_repeat {p : Program K} (hp : Correct p) (B : ℕ) (S : K → Word) (w : Word) |
| (hfit : ∀ i < w.length, p.Fits (p.eval^[i] S) B) (s : Option Bool) : |
| ∃ n ≤ (p.cost B + 2) * w.length + 2, |
| Exec (drain (.inr (.inr false)) (p.compile.rename embedLeft)) s (loopState S w) none |
| (loopState (p.eval^[w.length] S) []) n := by |
| induction w using List.reverseRecOn generalizing S s with |
| | nil => |
| have hr : Exec (StackModel.Command.read (.inr (.inr false))) s |
| (loopState (A:=p.Work) S []) none (loopState S []) 1 := by |
| simpa only [StackModel.Command.read, loopState_counter, List.getLast?_nil, |
| List.dropLast_nil, update_counter] using |
| Exec.pop (.inr (.inr false)) (fun _ b => b) s (loopState (A:=p.Work) S []) |
| exact ⟨2, by simp, Exec.seq hr (.while_false _ _ _ _ rfl)⟩ |
| | append_singleton w b ih => |
| obtain ⟨a, ha, hea⟩ := hp S B (hfit 0 (by simp)) (some b) |
| have hbody := hea.left (counterData w) |
| have htail : ∀ i < w.length, p.Fits (p.eval^[i] (p.eval S)) B := by |
| intro i hi |
| simpa only [Function.iterate_succ_apply] using hfit (i+1) (by simp; omega) |
| obtain ⟨n, hn, hen⟩ := ih (S := p.eval S) htail none |
| have hr : Exec (StackModel.Command.read (.inr (.inr false))) s |
| (loopState (A:=p.Work) S (w ++ [b])) (some b) (loopState S w) 1 := by |
| simpa only [StackModel.Command.read, loopState_counter, List.getLast?_append, |
| List.getLast?_singleton, Option.some_or, List.dropLast_append_cons, |
| List.dropLast_singleton, List.append_nil, update_counter] using |
| Exec.pop (.inr (.inr false)) (fun _ b => b) s (loopState (A:=p.Work) S (w ++ [b])) |
| dsimp only [drain] at hen |
| cases hen with |
| | seq hpop hwhile => |
| cases hpop |
| rename_i t |
| have hex := Exec.seq hr (Exec.while_true (by rfl) |
| (Exec.seq hbody (Exec.pop (.inr (.inr false)) (fun _ b => b) none (loopState (A:=p.Work) (p.eval S) w))) hwhile) |
| refine ⟨t + 1 + (a + 1 + 1), ?_, ?_⟩ |
| · simp only [List.length_append, List.length_singleton] at * |
| nlinarith |
| · simpa only [drain, List.length_append, List.length_singleton, |
| Function.iterate_succ_apply, StackModel.Command.read, loopState, Nat.add_assoc] using hex |
|
|
| theorem correct_repeat {k : K} {p : Program K} (hp : Correct p) : Correct (.repeat k p) := by |
| intro S B h s |
| obtain ⟨a, ha, hea⟩ := copy_exec (.inl k : K ⊕ (p.Work ⊕ Bool)) |
| (.inr (.inr false)) (.inr (.inr true)) (by simp) (by simp) (by simp) s (loopState S []) |
| have hstate : Function.update |
| (Function.update (loopState (A:=p.Work) S []) (.inr (.inr false)) (S k)) |
| (.inr (.inr true)) [] = loopState S (S k) := by |
| rw [update_counter] |
| exact Function.update_eq_self _ _ |
| simp only [loopState_var, hstate] at hea |
| obtain ⟨b, hb, heb⟩ := drain_repeat hp B S (S k) h.2 none |
| refine ⟨b+a, ?_, ?_⟩ |
| · have hk := h.1 k |
| simp only [loopState_counter, loopState_temp, loopState_var, List.length_nil, mul_zero, |
| zero_add, cost] at ha ⊢ |
| have hm := Nat.mul_le_mul_left (p.cost B+2) hk |
| omega |
| · simpa only [compile, eval, loopState_empty] using Exec.seq hea heb |
|
|
| /-- Fully uniform compilation, with all work stacks again empty at the boundary. -/ |
| theorem correct (p : Program K) : p.Correct := by |
| induction p with |
| | skip => exact correct_skip |
| | clear k => exact correct_clear k |
| | push k b => exact correct_push k b |
| | pop k => exact correct_pop k |
| | copy a b => exact correct_copy a b |
| | seq p q hp hq => exact correct_seq hp hq |
| | cases k p q r hp hq hr => exact correct_cases hp hq hr |
| | «repeat» k p hp => exact correct_repeat hp |
|
|
| end BoundedWords.Program |
|
|
| end WLIdentification |
|
|
| end OAI |
|
|
