| import OAI.Computability.FourierTransform.LayoutPrograms |
|
|
| namespace OAI |
|
|
| namespace PowerSaving.RAM |
| open Ty Finset |
| noncomputable section |
|
|
| universe U |
| variable {ι : Type U} {m : Bool} |
|
|
| namespace Small |
| variable {B P Q : ι → ℕ} |
|
|
| theorem sub (h : Small B P) : Small B (fun i => P i-Q i) := |
| h.mono fun _ => Nat.sub_le _ _ |
|
|
| theorem div (h : Small B P) : Small B (fun i => P i/Q i) := |
| h.mono fun _ => Nat.div_le_self _ _ |
|
|
| theorem mod (h : Small B P) : Small B (fun i => P i%Q i) := |
| h.mono fun _ => Nat.mod_le _ _ |
| end Small |
|
|
| namespace Can |
| variable {s t : Ty} {x : ι → T s} {B W A Q : ι → ℕ} |
|
|
| lemma minus (h : Can m B s w x A W) (k : Can m B s w x Q W) |
| (hh : Small B A) : Can m B s w x (fun i => A i - Q i) W := |
| h.wsub k hh.sub |
|
|
| lemma times (h : Can m B s w x A W) (k : Can m B s w x Q W) |
| (hh : Small B A) (gg : Small B Q) : Can m B s w x (fun i => A i * Q i) W := |
| h.wmul k (hh.mul gg) |
|
|
| lemma plus (h : Can m B s w x A W) (k : Can m B s w x Q W) |
| (hh : Small B A) (gg : Small B Q) : Can m B s w x (fun i => A i + Q i) W := |
| h.wadd k (hh.add gg) |
|
|
| lemma dvdW (h : Can m B s w x A W) (k : Can m B s w x Q W) (hh : Small B A) : |
| Can m B s w x (fun i => A i / Q i) W := |
| h.wdiv k hh.div |
|
|
| lemma modW (h : Can m B s w x A W) (k : Can m B s w x Q W) (hh : Small B A) : |
| Can m B s w x (fun i => A i % Q i) W := |
| h.wmod k hh.mod |
|
|
| lemma wpow_fixed (n : ℕ) (h : Can m B s w x A W) (hh : Small B A) : |
| Can m B s w x (fun i => (A i)^n) W := by |
| induction n with |
| | zero => simpa using wc (s:=s) (m:=m) (B:=B) (x:=x) (W:=W) 1 |
| | succ n ih => simpa [pow_succ] using ih.times h (hh.pow n) hh |
|
|
| /-- Cost-sensitive powering of two to a variable exponent by doubling. -/ |
| lemma wTwo (h : Can m B s w x A W) (hh : Small B A) |
| (hq : Small B fun i => 2^A i) (ha : Dom W A) : |
| Can m B s w x (fun i => 2^A i) W := by |
| let v (_ : ι) (n : ℕ) := 2^n |
| have hs : Can m (fun d : During A => B d.i) (p s (p w w)) w |
| (fun d => (x d.i, d.j, v d.i d.j)) (fun d => v d.i (d.j+1)) (fun _ => 0) := by |
| have hp : Small (fun d : During A => B d.i) fun d => v d.i d.j := |
| (hq.reindex During.i).mono (fun d => Nat.pow_le_pow_right (by omega) d.hj.le) |
| unfold v at * |
| simp only [pow_succ] |
| exact (Can.snd Can.second).times (Can.wc _) hp (Small.const ..) |
| have ht := Can.loop (t:=w) (v:=v) (W':=fun _ => 0) (uB:=fun _ _ => 0) h |
| (by simpa only [v,pow_zero] using (Can.wc (m:=m) (W:=fun _ => 0) |
| (B:=B) (s:=s) (x:=x) 1)) hs hh |
| simp only [Finset.sum_const_zero,Nat.add_zero] at ht |
| exact ht.weaken ((Dom.self W).add ha) |
| |
| end Can |
| |
| namespace Can |
| variable {s t : Ty} {x : ι → T s} {B W A Q : ι → ℕ} |
| |
| lemma neg {cl} {z : ι→ℂ} (h : Can m B s (c cl) x z W) : |
| Can m B s (c cl) x (fun i => -(z i)) W := by |
| simpa using (Can.sub Can.zero h) |
| |
| lemma cNat (n : ℕ) : Can m B s sc x (fun _ => (n:ℂ)) W := by |
| induction n with |
| | zero => |
| simp only [Nat.cast_zero] |
| exact Can.zero |
| | succ n ih => simpa using ih.add Can.one |
| |
| lemma cInt (n : ℤ) : Can m B s sc x (fun _ => (n:ℂ)) W := by |
| cases n with |
| | ofNat n => |
| simpa using (cNat (s:=s) (m:=m) (B:=B) (W:=W) (x:=x) n) |
| | negSucc n => |
| simpa using (cNat (s:=s) (m:=m) (B:=B) (W:=W) (x:=x) (n+1)).neg |
| |
| lemma rat (z : ℚ) : Can m B s sc x (fun _ => (z:ℂ)) W := by |
| rw [Rat.cast_def] |
| simp only [div_eq_mul_inv] |
| exact (Can.cInt _).mul ((Can.cNat _).inv (by intro i; exact_mod_cast z.den_nz)) |
| |
| lemma cpow_fixed (n : ℕ) {v : ι→ℂ} (h : Can m B s sc x v W) : |
| Can m B s sc x (fun i => v i ^ n) W := by |
| induction n with |
| | zero => |
| simp only [pow_zero] |
| exact Can.one |
| | succ n ih => simpa [pow_succ] using ih.mul h |
| |
| lemma prod_cconst {μ : Type*} [Fintype μ] {v : μ→ι→ℂ} |
| (h : ∀ i : μ, Can m B s sc x (v i) W) : |
| Can m B s sc x (fun j => ∏ i, v i j) W := by |
| classical |
| have hh (l : Finset μ) : Can m B s sc x (fun j => ∏ i∈l,v i j) W := by |
| induction l using Finset.induction with |
| | empty => |
| simp only [prod_empty] |
| exact Can.one |
| | insert i l hi ih => |
| simp only [prod_insert hi] |
| exact (h i).mul ih |
| exact hh _ |
| |
| end Can |
| |
| namespace Can |
| -- product addressing at arbitrary parameter types |
| variable {s t : Ty} {x : ι → T s} {B W : ι → ℕ} |
| variable {α β : ι → Type*} {L : ∀ i, Layout (α i)} {R : ∀ i, Layout (β i)} |
| {u : ∀ i, α i × β i} |
| |
| lemma addr_join (h : Can m B s w x (fun i => (L i).loc (u i).1) W) |
| (k : Can m B s w x (fun i => (R i).loc (u i).2) W) |
| (d : Can m B s w x (fun i => (R i).n) W) |
| (hl : Small B fun i => (L i).n) (hr : Small B fun i => (R i).n) : |
| Can m B s w x (fun i => ((L i).pair (R i)).loc (u i)) W := |
| (h.times d (Small.loc (x:=fun i => (u i).1) (L:=L) hl) hr).plus k |
| ((Small.loc (x:=fun i => (u i).1) (L:=L) hl).mul hr) |
| (Small.loc (x:=fun i => (u i).2) (L:=R) hr) |
| |
| lemma addr_high (h : Can m B s w x (fun i => ((L i).pair (R i)).loc (u i)) W) |
| (k : Can m B s w x (fun i => (R i).n) W) |
| (hs : Small B fun i => (L i).n*(R i).n) : |
| Can m B s w x (fun i => (L i).loc (u i).1) W := |
| (h.dvdW k (Small.loc (L:=fun i => (L i).pair (R i)) (x:=u) hs)).cong |
| (fun _ => rfl) (fun _ => Layout.pair_div ..) |
| |
| lemma addr_low (h : Can m B s w x (fun i => ((L i).pair (R i)).loc (u i)) W) |
| (k : Can m B s w x (fun i => (R i).n) W) |
| (hs : Small B fun i => (L i).n*(R i).n) : |
| Can m B s w x (fun i => (R i).loc (u i).2) W := |
| (h.modW k (Small.loc (L:=fun i => (L i).pair (R i)) (x:=u) hs)).cong |
| (fun _ => rfl) (fun _ => Layout.pair_mod ..) |
| |
| end Can |
| end |
| end PowerSaving.RAM |
| |
| end OAI |
| |
