File size: 6,368 Bytes
6fe30b6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 | import OAI.Computability.FourierTransform.ParameterPrograms
namespace OAI
/- Poly-log preparation combinators. Cost polynomial in S, integer sizes in Bench.size. -/
namespace PowerSaving.RAM
open Ty
noncomputable section
universe U V
namespace Bench
variable {m : Bool} {ι : Type U} {κ : Type V} {b : Bench m ι} {q : Bench m κ} {s t : Ty}
def Dry (b : Bench m ι) (S : ι→ℕ) (t : Ty) (f : ι→T t) : Prop :=
PolyCan m b.size S b.tray t b.env f
structure Grain (b : Bench m ι) (S f : ι→ℕ) : Prop where
dry : b.Dry S w f
small : Small b.size f
variable {S : ι→ℕ}
lemma Moves.dry {W x} (h : b.Moves W t x) (g : Small S W) :
b.Dry S t x := PolyCan.of_can h g
lemma Moves.dunes {x} (h : b.Moves (fun _ => 0) t x) (S : ι→ℕ) :
b.Dry S t x := h.dry (Small.const _ 0)
lemma Nick.grain {x} (h : b.Nick x) (S : ι→ℕ) :
b.Grain S x := ⟨h.close.dunes S,h.small⟩
namespace Dry
variable {x y : ι→T t}
lemma congr (h : b.Dry S t x) (g : ∀ i, x i=y i) :
b.Dry S t y := by rwa [← funext g]
lemma pair {v : ι→T s} (h : b.Dry S t x) (g : b.Dry S s v) :
b.Dry S (p t s) fun i => (x i,v i) := PolyCan.pair h g
lemma fst {v : ι→T (p s t)} (h : b.Dry S (p s t) v) :
b.Dry S s fun i => (v i).1 := PolyCan.fst h
lemma snd {v : ι→T (p s t)} (h : b.Dry S (p s t) v) :
b.Dry S t fun i => (v i).2 := PolyCan.snd h
lemma wc (n : ℕ) : b.Dry S w fun _ => n := PolyCan.wc n
lemma one : b.Dry S sc fun _ => 1 := PolyCan.one
lemma mul {cl} {x y : ι→ℂ} (h : b.Dry S sc x) (g : b.Dry S (c cl) y) :
b.Dry S (c cl) fun i => x i*y i := PolyCan.mul h g
lemma inv {x : ι→ℂ} (h : b.Dry S sc x) (g : ∀ i, x i≠0) :
b.Dry S sc fun i => (x i)⁻¹ := PolyCan.inv h g
lemma transfer {f : ι→κ} {S : κ→ℕ} {x : κ→T t} (h : q.Dry S t x) (g : b.Instant q f) :
b.Dry (fun i => S (f i)) t fun i => x (f i) :=
PolyCan.pipe (g.prep.dunes _) (PolyCan.weaken (PolyCan.reindex h f) g.covers (Small.self _))
lemma together {v : ι→T s} (h : b.Dry S t x) (g : (b.extend t x).Dry S s v) :
b.Dry S s v := PolyCan.bind h g
lemma look {x : ι→Tape (T t)} {n} (h : b.Dry S (a t) x) (g : b.Dry S w n) :
b.Dry S t fun i => (x i).look (n i) t.blank := PolyCan.look h g
lemma pick {x : ι→ℕ→T t} {n k : ι→ℕ} (h : b.Dry S (a t) fun i => Tape.tab (n i) (x i))
(g : b.Dry S w k) (hk : ∀ i,k i<n i) :
b.Dry S t fun i => x i (k i) :=
(h.look g).congr fun i => by rw [Tape.look_tab, ite_eq_left (hk i)]
lemma testz {f} (h : b.Dry S w f)
(g : (b.along (Subtype.val (p:=fun i => f i = 0))).Dry (fun i => S i.val) t fun i => x i.val)
(j : (b.along (Subtype.val (p:=fun i => f i ≠ 0))).Dry (fun i => S i.val) t fun i => x i.val) :
b.Dry S t x := PolyCan.testz h g j
lemma branch {f} (h : b.Dry S w f) (g : b.Dry S t x) (j : b.Dry S t y) :
b.Dry S t fun i => if f i = 0 then x i else y i := by
refine testz h ?_ ?_
· exact (g.transfer (Instant.along b (Subtype.val (p:=fun i => f i = 0)))).congr
fun i => (ite_eq_left i.property).symm
· exact (j.transfer (Instant.along b (Subtype.val (p:=fun i => f i ≠ 0)))).congr
fun i => (ite_eq_right i.property).symm
end Dry
namespace Grain
variable {x y : ι→ℕ}
lemma wc (n : ℕ) : b.Grain S fun _ => n := (Nick.wc n).grain _
lemma add (h : b.Grain S x) (g : b.Grain S y) :
b.Grain S fun i => x i+y i :=
⟨PolyCan.wadd h.dry g.dry (h.small.add g.small),h.small.add g.small⟩
lemma sub (h : b.Grain S x) (g : b.Grain S y) :
b.Grain S fun i => x i-y i :=
⟨PolyCan.wsub h.dry g.dry h.small.sub,h.small.sub⟩
lemma mul (h : b.Grain S x) (g : b.Grain S y) :
b.Grain S fun i => x i*y i :=
⟨PolyCan.wmul h.dry g.dry (h.small.mul g.small),h.small.mul g.small⟩
lemma div (h : b.Grain S x) (g : b.Grain S y) :
b.Grain S fun i => x i/y i :=
⟨PolyCan.wdiv h.dry g.dry h.small.div,h.small.div⟩
lemma residue (h : b.Grain S x) (g : b.Grain S y) :
b.Grain S fun i => x i%y i :=
⟨PolyCan.wmod h.dry g.dry h.small.mod,h.small.mod⟩
lemma cmp (h : b.Grain S x) (g : b.Grain S y) :
b.Grain S fun i => if x i<y i then 1 else 0 :=
⟨PolyCan.wlt h.dry g.dry,(Small.const _ 1).mono fun i => by split <;> omega⟩
lemma congr (h : b.Grain S x) (g : ∀ i,x i=y i) :
b.Grain S y := by rwa [← funext g]
lemma transfer {f : ι→κ} {S x : κ→ℕ} (h : q.Grain S x) (g : b.Instant q f) :
b.Grain (fun i => S (f i)) fun i => x (f i) :=
⟨h.dry.transfer g,(h.small.reindex _).trans g.covers⟩
lemma logtwo (h : b.Grain S x) (g : Small S x) :
b.Grain S fun i => Nat.log 2 (x i) := by
have hh : (b.extend w x).Nick x := ⟨cherry (t:=w) b x,h.small⟩
exact ⟨h.dry.together (hh.logM.dry g),h.small.mono fun i => Nat.log_le_self 2 _⟩
end Grain
variable {n : ι→ℕ}
lemma strideG (h : b.Grain S n) (x : ι → ℕ → T t) :
(b.climbs n t x).Grain (fun i => S i.i) During.j :=
⟨PolyCan.fst PolyCan.second,
(h.small.reindex During.i).mono (fun i : During n => i.hj.le)⟩
lemma chopG (h : b.Grain S n) :
(b.scan n).Grain (fun i => S i.i) During.j :=
⟨PolyCan.second,(h.small.reindex During.i).mono (fun i : During n => i.hj.le)⟩
lemma Dry.token (b : Bench m ι) (n S : ι→ℕ) (x : ι → ℕ → T t) :
(b.climbs n t x).Dry (fun i => S i.i) t fun i => x i.i i.j :=
(tokenNow b n x).dunes _
lemma cycleG (h : b.Grain S n) (k : Small S n) (x : ι → ℕ → T t)
(g : b.Dry S t fun i => x i 0)
(j : (b.climbs n t x).Dry (fun i => S i.i) t fun i => x i.i (i.j+1)) :
b.Dry S t fun i => x i (n i) :=
PolyCan.loop h.dry g j h.small k
lemma arrayG (h : b.Grain S n) (k : Small S n) (x : ι→ℕ→T t)
(g : (b.scan n).Dry (fun i => S i.i) t fun i => x i.i i.j) :
b.Dry S (a t) fun i => Tape.tab (n i) (x i) := PolyCan.tab h.dry g h.small k
lemma Grain.twoPow (h : b.Grain S n) (k : Small S n)
(j : Small b.size fun i => 2^n i) :
b.Grain S fun i => 2^n i := by
let v (i : ι) (a : ℕ) : T w := 2^a
let D := b.climbs n w v
have hh : D.Grain (fun i => S i.i) fun i => v i.i i.j :=
⟨Dry.token b n S v,
(j.reindex During.i).mono fun i => Nat.pow_le_pow_right (by omega) i.hj.le⟩
refine ⟨cycleG h k v ?_ ((hh.mul (wc 2)).dry.congr fun i => (pow_succ _ _).symm),j⟩
simpa only [v,pow_zero] using Dry.wc (b:=b) (S:=S) 1
end Bench
end
end PowerSaving.RAM
end OAI
|