File size: 6,562 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 144 145 146 147 | import OAI.Computability.FourierTransform.IntegerPrograms
import OAI.Computability.FourierTransform.TensorFibers
namespace OAI
/-! Transposed column address trick: a table of the addition of two f-bit digit
vectors. We will be able to charge construction of the *whole* table. -/
namespace PowerSaving.RAM
open Binary Ty Finset
noncomputable section
def xorOrd (k : ℕ) : Layout (Bits k × Bits k) := (bits k).pair (bits k)
def xorTab (k : ℕ) : Tape ℕ := (xorOrd k).tape (fun i => (bits k).loc (i.1+i.2))
private lemma digit_prefix (z p : ℕ) (hp : p>0) :
z % (p*2) = z%p + (z/p%2)*p := by
have h : (z/p/2)*(p*2) + ((z/p%2)*p+z%p) = z := by
calc
_ = ((2*(z/p/2)+z/p%2)*p) + z%p := by ring
_ = z := by rw [Nat.div_add_mod, mul_comm, Nat.div_add_mod]
have hd : (z/p%2)*p+z%p < p*2 := by
rw [mul_comm p]
exact Layout.lt_join (Nat.mod_lt _ (by decide)) (Nat.mod_lt _ hp)
exact (congr_arg (· % (p*2)) h).symm.trans ((Layout.mod_join hd).trans (add_comm ..))
private lemma digit_plus (k : ℕ) (x y : Bits k) (j : ℕ) (hj : j<k) :
let b := (bits k).loc
b (x+y) / 2^j % 2 =
((b x / 2^j) + (b y / 2^j))%2 := by
intro b
let i : Fin k := ⟨j,hj⟩
have h (v : Bits k) : b v / 2^j % 2 = (v i).val := bits_div k v i
rw [Nat.add_mod,h,h,h]
exact ZMod.val_add _ _
namespace Can
universe U
variable {ι : Type U} {m : Bool} {s : Ty} {x : ι→T s} {B f : ι→ℕ}
/-- Assume the input environment supplies arguments to this subcalculation at O(1) cost. -/
private theorem xor_value (v : ∀ i, Bits (f i) × Bits (f i))
(hf : Can m B s w x f (fun _ => 0))
(ha : Can m B s w x (fun i => (bits (f i)).loc (v i).1) (fun _ => 0))
(hb : Can m B s w x (fun i => (bits (f i)).loc (v i).2) (fun _ => 0))
(hB : Small B f) (hd : Small B fun i => 2^f i) :
Can m B s w x (fun i => (bits (f i)).loc ((v i).1+(v i).2)) f := by
let X := fun i => (bits (f i)).loc ((v i).1+(v i).2)
let a1 i := (bits (f i)).loc (v i).1
let a2 i := (bits (f i)).loc (v i).2
let g := fun (i : ι) (j : ℕ) => (2^j,X i % 2^j)
let Y := p w w
let T₀ := p s (p w Y)
let env (d : During f) : T T₀ := (x d.i,d.j,g d.i d.j)
let B' (d : During f) := B d.i
let E (d : During f) := 2^d.j
have hv (w : ∀ i, Bits (f i)) :
Small B fun i => (bits (f i)).loc (w i) :=
Small.loc (x:=w) (L:=fun i => bits (f i)) hd
have sE : Small B' E :=
(hd.reindex (During.i (n:=f))).mono (fun d => Nat.pow_le_pow_right (by omega) d.hj.le)
have sr : Small B' (fun d : During f => (g d.i d.j).2) :=
((hv (fun i => (v i).1+(v i).2)).reindex (During.i (n:=f))).mod
have step : Can m B' T₀ Y env (fun d => g d.i (d.j+1)) (fun _ => 0) := by
have cg : Can m B' T₀ Y env (fun d => g d.i d.j) (fun _ => 0) := Can.snd Can.second
have ce : Can m B' T₀ w env E (fun _ => 0) := cg.fst
have cs2 : Can m B' T₀ w env (fun d => 2) (fun _ => 0) := Can.wc _
have sa : Small B' fun d : During f => a1 d.i := (hv (fun i => (v i).1)).reindex During.i
have sb : Small B' fun d : During f => a2 d.i := (hv (fun i => (v i).2)).reindex During.i
have ca : Can m B' T₀ w env (fun d => a1 d.i) (fun _ => 0) :=
Can.first.then_do (ha.reindex During.i)
have cb : Can m B' T₀ w env (fun d => a2 d.i) (fun _ => 0) :=
Can.first.then_do (hb.reindex During.i)
have cp := (ca.dvdW ce sa).plus (cb.dvdW ce sb) sa.div sb.div
have sx := (sa.div (Q:=E)).add (sb.div (Q:=E))
have cy := (cp.modW cs2 sx).times ce sx.mod sE
have cq := (cg.snd).plus cy sr ((sx.mod (Q:=fun _ => 2)).mul sE)
refine ((ce.times cs2 sE (Small.const ..)).pair cq).cong (fun _ => rfl) ?_
intro d
apply Prod.ext
· exact (pow_succ ..).symm
· change X d.i % 2^d.j + _ = X d.i % 2^(d.j+1)
rw [pow_succ,digit_prefix (X d.i) (2^d.j) (by positivity)]
have h := digit_plus _ (v d.i).1 (v d.i).2 d.j d.hj
congr 1
exact congr_arg (· * 2^d.j) h.symm
have c0 : Can m B s Y x (fun i => g i 0) (fun _ => 0) := by
simp only [g,pow_zero,Nat.mod_one]
exact (Can.wc _).pair (Can.wc _)
have hh := Can.loop (t:=Y) (v:=g) (uB:=fun _ _ => 0) hf c0 step hB
have he (i) : (g i (f i)).2=X i := Nat.mod_eq_of_lt ((bits (f i)).bd _)
simpa [he,X] using hh.snd
theorem xor_prepare (hf : Can m B s w x f (fun _ => 0))
(hg : Can m B s w x (fun i => 2^f i) (fun _ => 0))
(hB : Small B f) (hd : Small B fun i => 2^f i) :
Can m B s (a w) x (fun i => xorTab (f i)) (fun i => (2^f i)^3) := by
let V i := (bits (f i)).n
let D i := xorOrd (f i)
have sn : Small B fun i => (D i).n := hd.mul hd
have hn : Can m B s w x (fun i => (D i).n) (fun _ => 0) := hg.times hg hd hd
let I i := Bits (f i) × Bits (f i)
let BB (d : Σ i, I i) := B d.1
let VV (d : Σ i, I i) : T (p s w) := (x d.1,(D d.1).loc d.2)
have hh : Can m BB (p s w) w VV (fun d : Σ i, I i =>
(bits (f d.1)).loc (d.2.1+d.2.2)) (fun d => f d.1) := by
have hv : Can m BB (p s w) w VV
(fun d => V d.1) (fun _ => 0) :=
Can.first.then_do (hg.reindex (Sigma.fst (β:=I)))
have hBB := sn.reindex (Sigma.fst (β:=I))
let X (d : Σ i, I i) := bits (f d.1)
apply xor_value (f:=fun d : Σ i, I i => f d.1) _
(Can.first.then_do (hf.reindex (Sigma.fst (β:=I)))) _ _
(hB.reindex Sigma.fst) (hd.reindex Sigma.fst)
· exact Can.addr_high (u:=fun d : Σ i, I i => d.2) (L:=X) (R:=X)
Can.second hv hBB
· exact Can.addr_low (u:=fun d : Σ i, I i => d.2) (L:=X) (R:=X)
Can.second hv hBB
have ht := Can.layout (t:=w) (P:=f) (L:=D) (α:=I)
(v:=fun (i : ι) j => (bits (f i)).loc (j.1+j.2)) hn hh sn
refine ht.mono (fun i => ?_)
change 0+2^f i * 2^f i + _* f i ≤ _
have he : f i < 2^f i := Nat.lt_two_pow_self
change 0+2^f i * 2^f i + 2^f i * 2^f i * f i ≤ _
have h := Nat.mul_le_mul_left (2^f i * 2^f i) he
simpa [pow_succ,Nat.mul_add,add_comm] using h
theorem xor_lookup {W : ι → ℕ}
(v : ∀ i, Bits (f i) × Bits (f i))
(ht : Can m B s (a w) x (fun i => xorTab (f i)) W)
(ha : Can m B s w x (fun i => (bits (f i)).loc (v i).1) W)
(hb : Can m B s w x (fun i => (bits (f i)).loc (v i).2) W)
(hn : Can m B s w x (fun i => 2^f i) W)
(hd : Small B fun i => 2^f i) :
Can m B s w x (fun i => (bits (f i)).loc ((v i).1+(v i).2)) W :=
Can.fetch (t:=w) (L:=fun i => xorOrd (f i)) (i:=v)
(v:=fun i j => (bits (f i)).loc (j.1+j.2)) ht
(Can.addr_join (u:=v) (L:=fun i => bits (f i)) (R:=fun i => bits (f i))
ha hb hn hd hd)
end Can
end
end PowerSaving.RAM
end OAI
|