| import OAI.Computability.FourierTransform.Cost |
|
|
| namespace OAI |
|
|
| /-! Uniform elementary bound helpers (natural envelopes; later compare to the real bounds). -/ |
| namespace PowerSaving.RAM |
| open Finset |
|
|
| universe u v |
|
|
| /-- Pointwise polynomial bound with absolute constants. The bound relevant to word sizes |
| will use n as B. Local computations may also have polynomial *work* in a different B. -/ |
| def Small {ι : Type u} (B F : ι → ℕ) : Prop := ∃ d : ℕ, ∀ i, F i ≤ (B i+2)^d |
|
|
| namespace Small |
| variable {ι : Type u} {κ : Type v} {B C F G : ι → ℕ} |
|
|
| theorem const (B : ι → ℕ) (n : ℕ) : Small B (fun _ => n) := by |
| refine ⟨n, fun i => ?_⟩ |
| have hh : n < 2^n := Nat.lt_two_pow_self |
| exact hh.le.trans (Nat.pow_le_pow_left (by omega) _) |
|
|
| theorem self (B : ι → ℕ) : Small B B := ⟨1, by simp⟩ |
|
|
| theorem reindex (h : Small B F) (f : κ → ι) : Small (fun j => B (f j)) (fun j => F (f j)) := |
| let ⟨d, hd⟩ := h |
| ⟨d, fun j => hd (f j)⟩ |
|
|
| theorem mono (h : Small B F) (hh : ∀ i, G i ≤ F i) : Small B G := |
| let ⟨d, hd⟩ := h |
| ⟨d, fun i => (hh i).trans (hd i)⟩ |
|
|
| theorem mul (h : Small B F) (g : Small B G) : Small B (fun i => F i * G i) := by |
| obtain ⟨d,hd⟩ := h |
| obtain ⟨e,he⟩ := g |
| exact ⟨d+e, fun i => by simpa [pow_add] using Nat.mul_le_mul (hd i) (he i)⟩ |
|
|
| theorem pow_mono_degree (b : ℕ) {d e : ℕ} (h : d ≤ e) : |
| (b+2)^d ≤ (b+2)^e := |
| Nat.pow_le_pow_right (by omega) h |
|
|
| theorem add (h : Small B F) (g : Small B G) : Small B (fun i => F i + G i) := by |
| obtain ⟨d,hd⟩ := h |
| obtain ⟨e,he⟩ := g |
| refine ⟨d+e+1, fun i => ?_⟩ |
| have a := (hd i).trans (pow_mono_degree _ (Nat.le_add_right d e)) |
| have b := (he i).trans (pow_mono_degree _ (Nat.le_add_left e d)) |
| rw [pow_succ] |
| calc |
| F i + G i ≤ ((B i+2)^(d+e))*2 := by omega |
| _ ≤ _ := Nat.mul_le_mul_left _ (by omega) |
|
|
| theorem max (h : Small B F) (g : Small B G) : |
| Small B (fun i => Max.max (F i) (G i)) := |
| (h.add g).mono (fun i => by omega) |
|
|
| theorem pow (h : Small B F) (n : ℕ) : Small B (fun i => (F i)^n) := by |
| induction n with |
| | zero => simpa using Small.const B 1 |
| | succ n ih => simpa [pow_succ] using ih.mul h |
|
|
| theorem trans (h : Small B F) (g : Small C B) : Small C F := by |
| obtain ⟨d,hd⟩ := h |
| exact ((g.add (Small.const C 2)).pow d).mono hd |
|
|
| end Small |
|
|
| /-- Least data needed for a "big-O with +1" natural work budget convenience. -/ |
| def Dom {ι : Type u} (W F : ι → ℕ) : Prop := |
| ∃ C : ℕ, ∀ i, F i+1 ≤ C*(W i+1) |
|
|
| namespace Dom |
| variable {ι : Type u} {W F G : ι → ℕ} |
|
|
| theorem of_le (h : ∀ i, F i ≤ W i) : Dom W F := |
| ⟨1, fun i => by simpa using Nat.add_le_add_right (h i) 1⟩ |
|
|
| theorem self (W : ι → ℕ) : Dom W W := of_le (fun _ => le_rfl) |
|
|
| theorem const (W : ι → ℕ) (n : ℕ) : Dom W (fun _ => n) := by |
| refine ⟨n+1, ?_⟩ |
| intro i |
| simp [mul_add] |
|
|
| theorem add (a : Dom W F) (b : Dom W G) : Dom W (fun i => F i + G i) := by |
| obtain ⟨d,hd⟩ := a |
| obtain ⟨e,he⟩ := b |
| refine ⟨d+e, fun i => ?_⟩ |
| specialize hd i |
| specialize he i |
| dsimp |
| rw [add_mul] |
| omega |
|
|
| theorem trans (a : Dom W F) (b : Dom F G) : Dom W G := by |
| obtain ⟨d,hd⟩ := a |
| obtain ⟨e,he⟩ := b |
| exact ⟨e*d, fun i => (he i).trans (by simpa [mul_assoc] using Nat.mul_le_mul_left e (hd i))⟩ |
|
|
| end Dom |
| end PowerSaving.RAM |
|
|
| end OAI |
|
|
