| import Mathlib |
| import OAI.Computability.DeterministicSum.PaddedMaps |
|
|
| namespace OAI |
|
|
| /-! Uniform downward matrix recursion and address-capacity invariants. -/ |
|
|
| namespace DeterministicThreeSum.Structured.Indexed.MatrixDown |
| open Command DeterministicThreeSum.Rectangular Axis MatrixLayout |
|
|
| def update (Q k r : ℕ) : Command := straight [ |
| .assign 8 (.register 3), .assign 3 (.register 4), .assign 4 (.register 8), |
| .assign 7 (.register 1), .assign 9 (.register 6), |
| .binary 6 .quot (.register 6) (.literal Q), |
| .binary 8 .quot (.register 1) (.register 9), |
| .binary 8 .add (.register 8) (.literal (k-1)), |
| .binary 8 .quot (.register 8) (.literal k), |
| .binary 1 .mul (.register 8) (.literal r), |
| .binary 1 .mul (.register 1) (.register 6), .assign 0 (.literal 0)] |
|
|
| def updated (s : Data) (Q k r P S B n : ℕ) : Data := |
| put (put (put (put (put (put (put (put (put (put (put (put s 8 P) 3 S) 4 P) |
| 7 (n*B)) 9 B) 6 (B/Q)) 8 n) 8 (n+(k-1))) 8 ((n+(k-1))/k)) |
| 1 (((n+(k-1))/k)*r)) 1 (((n+(k-1))/k)*r*(B/Q))) 0 0 |
|
|
| lemma ceil_eq {k : ℕ} (hk : 0<k) (n : ℕ) : (n+(k-1))/k=batchCount n k := by |
| rw [batchCount,Nat.ceilDiv_eq_add_pred_div] |
| congr 1 |
| omega |
|
|
| lemma update_correct {w Q k r P S B n : ℕ} (s : Data) |
| (hQ : 0<Q) (hk : 0<k) (hB : 0<B) |
| (hQW : Q<wordModulus w) (hkW : k<wordModulus w) (hrW : r<wordModulus w) |
| (hP : P<wordModulus w) (hS : S<wordModulus w) (hBW : B<wordModulus w) |
| (hnB : n*B<wordModulus w) (hnk : n+(k-1)<wordModulus w) |
| (hnr : batchCount n k*r<wordModulus w) |
| (hnext : batchCount n k*r*(B/Q)<wordModulus w) |
| (h1 : s.registers 1=n*B) (h3 : s.registers 3=P) |
| (h4 : s.registers 4=S) (h6 : s.registers 6=B) : |
| Eval w (update Q k r) s 12 (updated s Q k r P S B n) := by |
| have hn : n<wordModulus w := lt_of_le_of_lt (Nat.le_add_right _ _) hnk |
| have hbq : B/Q<wordModulus w := lt_of_le_of_lt (Nat.div_le_self ..) hBW |
| have hnkdiv : (n+(k-1))/k<wordModulus w := |
| lt_of_le_of_lt (Nat.div_le_self ..) hnk |
| have hkr : ((n+(k-1))/k)*r<wordModulus w := by simpa only [ceil_eq hk] using hnr |
| have hkrq : ((n+(k-1))/k)*r*(B/Q)<wordModulus w := by simpa only [ceil_eq hk] using hnext |
| apply straight_correct |
| simp [updated,execStraight,Atom.eval,operand_literal,operand_register,evalBinOp,put, |
| h1,h3,h4,h6,hQ.ne',hk.ne',hB.ne',Nat.mul_div_cancel _ hB, |
| Nat.mod_eq_of_lt hQW,Nat.mod_eq_of_lt hkW,Nat.mod_eq_of_lt hrW, |
| Nat.mod_eq_of_lt hP,Nat.mod_eq_of_lt hS,Nat.mod_eq_of_lt hBW, |
| Nat.mod_eq_of_lt hnB,Nat.mod_eq_of_lt hnk,Nat.mod_eq_of_lt hkrq, |
| Nat.mod_eq_of_lt (show k-1<wordModulus w by omega),Function.update_idem] |
|
|
| def body (Q k r : ℕ) : Command := .seq (PaddedAxis.pass (k*Q) r) (update Q k r) |
| def loop (Q k r : ℕ) : Command := .loop .lt (.literal 0) (.register 6) (body Q k r) |
|
|
| def value (T Q k r : ℕ) (co : ℕ → ℕ) : ℕ → ℕ → (ℕ → ℕ) → (ℕ → ℕ) |
| | 0,_,x => x |
| | d+1,t,x => value T Q k r co d (batchCount t k*r) |
| (mapValue T (k*Q) r (Q^d) (PaddedAxis.pad x (t*Q^(d+1))) co) |
|
|
| def capacity (Q k r : ℕ) : ℕ → ℕ → ℕ |
| | 0,t => t |
| | d+1,t => max (batchCount t k*(k*Q)*Q^d) |
| (max (batchCount t k*r*Q^d) (capacity Q k r d (batchCount t k*r))) |
|
|
| def finalCount (k r : ℕ) : ℕ → ℕ → ℕ |
| | 0,t => t |
| | d+1,t => finalCount k r d (batchCount t k*r) |
|
|
| end DeterministicThreeSum.Structured.Indexed.MatrixDown |
|
|
| namespace DeterministicThreeSum.Structured.Indexed.MatrixDown |
| open Command DeterministicThreeSum.Rectangular Axis |
|
|
| lemma capacity_output (Q k r d t : ℕ) : |
| batchCount t k*r*tensorStride Q d ≤ capacity Q k r d t := by |
| cases d with |
| | zero => simp [tensorStride,capacity] |
| | succ d => exact (le_max_left _ _).trans (le_max_right _ _) |
|
|
| lemma capacity_input {Q k r d t : ℕ} (hk : 0<k) : |
| t*Q^d ≤ capacity Q k r d t := by |
| cases d with |
| | zero => simp [capacity] |
| | succ d => |
| have h := Nat.mul_le_mul_right (Q^(d+1)) (batchCount_covers t k hk) |
| have he : k*batchCount t k*Q^(d+1)=batchCount t k*(k*Q)*Q^d := by |
| rw [pow_succ]; ring |
| rw [he] at h |
| exact h.trans (le_max_left _ _) |
|
|
| lemma batch_pos {t k : ℕ} (ht : 0<t) (hk : 0<k) : 0<batchCount t k := by |
| have h:=batchCount_covers t k hk |
| by_contra hn |
| have hz : batchCount t k=0 := by omega |
| simp only [hz] at h |
| omega |
|
|
| lemma batch_le {k : ℕ} (hk : 0<k) (t : ℕ) : batchCount t k ≤ t+k := by |
| rw [← ceil_eq hk] |
| exact (Nat.div_le_self ..).trans (by omega) |
|
|
| theorem loop_correct {w T Q k r L d t P S C : ℕ} (state : Data) (x co : ℕ → ℕ) |
| (hQ : 1<Q) (hk : 0<k) (hr : 0<r) (ht : 0<t) (hT : 0<T) |
| (hadd : 2*T<wordModulus w) (hmul : T*T<wordModulus w) |
| (hL : capacity Q k r d t≤L) |
| (hLw : (L+k)*r+L+k+Q+r+3<wordModulus w) |
| (hP : P+L+1<wordModulus w) (hS : S+L+1<wordModulus w) |
| (hC : C+r*(k*Q)<wordModulus w) |
| (hPS : S+L≤P ∨ P+L≤S) |
| (hCP : C+r*(k*Q)≤P ∨ P+L≤C) (hCS : C+r*(k*Q)≤S ∨ S+L≤C) |
| (hregs : ∀ a : Fin 8, state.registers a.val= |
| environment T (batchCount t k*r*tensorStride Q d) P S C (tensorStride Q d) (t*Q^d) 0 a) |
| (hx : ∀ i, i<t*Q^d → state.memory (S+i)=some (x i) ∧ x i<T) |
| (hc : ∀ i, i<r*(k*Q) → state.memory (C+i)=some (co i) ∧ co i<T) : |
| ∃ cost out, Eval w (loop Q k r) state cost out ∧ |
| cost≤(((PaddedAxis.row (k*Q) r).cost+5)*L+15)*d+1 ∧ |
| (∀ a : Fin 8, out.registers a.val= |
| environment T 0 (banks d P S).1 (banks d P S).2 C 0 (finalCount k r d t) 0 a) ∧ |
| (∀ j, j<finalCount k r d t → out.memory ((banks d P S).2+j)=some (value T Q k r co d t x j) ∧ |
| value T Q k r co d t x j<T) ∧ |
| (∀ a, (a<P ∨ P+L≤a) → (a<S ∨ S+L≤a) → out.memory a=state.memory a) := by |
| induction d generalizing t P S state x with |
| | zero => |
| have h6 : state.registers 6=0 := by simpa [environment,tensorStride] using hregs ⟨6,by omega⟩ |
| have htest : test w state .lt (.literal 0) (.register 6)=false := by |
| simp [test,operand_literal,operand_register,evalTest,h6] |
| refine ⟨1,state,Eval.loopFalse htest,by simp,?_,?_,by simp⟩ |
| · simpa only [tensorStride,Nat.mul_zero,banks_zero,pow_zero,Nat.mul_one,finalCount] using hregs |
| · simpa only [value,banks_zero,pow_zero,Nat.mul_one,finalCount] using hx |
| | succ d ih => |
| have hlenX : batchCount t k*(k*Q)*Q^d≤L := (le_max_left _ _).trans hL |
| have hlenY : batchCount t k*r*Q^d≤L := ((le_max_left _ _).trans (le_max_right _ _)).trans hL |
| have hlenNext : capacity Q k r d (batchCount t k*r)≤L := |
| ((le_max_right _ _).trans (le_max_right _ _)).trans hL |
| have hp : 0<Q^d := pow_pos (by omega) _ |
| have hn : 0<batchCount t k*r := Nat.mul_pos (batch_pos ht hk) hr |
| have hB : Q^d≤L := (by simpa using Nat.mul_le_mul_right (Q^d) hn : Q^d≤batchCount t k*r*Q^d) |>.trans hlenY |
| have hnL : batchCount t k*r≤L := |
| (by simpa using Nat.mul_le_mul_left (batchCount t k*r) hp : batchCount t k*r≤batchCount t k*r*Q^d) |>.trans hlenY |
| have hnr : batchCount (batchCount t k*r) k*r<wordModulus w := by |
| have hh := Nat.mul_le_mul_right r ((batch_le hk (batchCount t k*r)).trans (Nat.add_le_add_right hnL k)) |
| omega |
| have hnext : batchCount (batchCount t k*r) k*r*(Q^d/Q)<wordModulus w := by |
| rw [tensorStride_div hQ] |
| have hh := (capacity_output Q k r d (batchCount t k*r)).trans hlenNext |
| omega |
| have h6 : state.registers 6=Q^d := by simpa [environment,tensorStride] using hregs ⟨6,by omega⟩ |
| have htest : test w state .lt (.literal 0) (.register 6)=true := by |
| simp [test,operand_literal,operand_register,evalTest,h6, |
| Nat.mod_eq_of_lt (show Q^d<wordModulus w by omega),hp] |
| have hin : t*Q^(d+1)≤batchCount t k*(k*Q)*Q^d := by |
| have hh := Nat.mul_le_mul_right (Q^(d+1)) (batchCount_covers t k hk) |
| convert hh using 1 |
| rw [pow_succ] |
| ring |
| have hregs' : ∀ a : Fin 8, state.registers a.val= |
| environment T (batchCount t k*r*Q^d) P S C (Q^d) (t*Q^(d+1)) 0 a := hregs |
| obtain ⟨cost,u,ep,hcost,hframe,hidx,hmem,houtside⟩ := PaddedAxis.pass_correct state x co |
| (Nat.mul_pos hk (by omega)) hr hp hT hadd hmul |
| (by omega : batchCount t k*r*Q^d+1<wordModulus w) (by omega) (by omega) hC hin |
| (by omega) (by omega) hregs' hx hc |
| have hparam : ∀ a : Fin 8, a.val≠0 → u.registers a.val= |
| environment T (batchCount t k*r*Q^d) P S C (Q^d) (t*Q^(d+1)) 0 a := |
| fun a ha => (hframe a.val a.isLt ha).trans (hregs' a) |
| have h1u : u.registers 1=batchCount t k*r*Q^d := by simpa [environment] using hparam ⟨1,by omega⟩ (by norm_num) |
| have h3u : u.registers 3=P := by simpa [environment] using hparam ⟨3,by omega⟩ (by norm_num) |
| have h4u : u.registers 4=S := by simpa [environment] using hparam ⟨4,by omega⟩ (by norm_num) |
| have h6u : u.registers 6=Q^d := by simpa [environment] using hparam ⟨6,by omega⟩ (by norm_num) |
| have eu := update_correct u (by omega : 0<Q) hk hp (by omega) (by omega) (by omega) |
| (by omega) (by omega) (by omega) (by omega) (by omega) hnr hnext h1u h3u h4u h6u |
| let v := updated u Q k r P S (Q^d) (batchCount t k*r) |
| have hregsv : ∀ a : Fin 8, v.registers a.val= |
| environment T (batchCount (batchCount t k*r) k*r*tensorStride Q d) |
| S P C (tensorStride Q d) ((batchCount t k*r)*Q^d) 0 a := by |
| intro a |
| have h2u : u.registers 2=T := by simpa [environment] using hparam ⟨2,by omega⟩ (by norm_num) |
| have h5u : u.registers 5=C := by simpa [environment] using hparam ⟨5,by omega⟩ (by norm_num) |
| fin_cases a <;> simp [v,updated,put,environment,tensorStride_div hQ,ceil_eq hk,h2u,h5u] |
| have hc' : ∀ i, i<r*(k*Q) → v.memory (C+i)=some (co i) ∧ co i<T := by |
| intro i hi |
| have ho : C+i<P ∨ P+batchCount t k*r*Q^d≤C+i := by omega |
| simp only [v,updated,put] |
| rw [houtside _ ho] |
| exact hc i hi |
| have hx' : ∀ i, i<(batchCount t k*r)*Q^d → v.memory (P+i)= |
| some (mapValue T (k*Q) r (Q^d) (PaddedAxis.pad x (t*Q^(d+1))) co i) ∧ |
| mapValue T (k*Q) r (Q^d) (PaddedAxis.pad x (t*Q^(d+1))) co i<T := by |
| intro i hi |
| exact ⟨hmem i hi,mapValue_lt hT _ _ _ _ _ _⟩ |
| obtain ⟨rest,out,er,hrcost,hregsFinal,hmFinal,houtFinal⟩ := ih v |
| (mapValue T (k*Q) r (Q^d) (PaddedAxis.pad x (t*Q^(d+1))) co) |
| hn hlenNext hS hP (by omega) hCS hCP hregsv hx' hc' |
| refine ⟨1+(cost+12)+1+rest,out,Eval.loopTrue htest (Eval.seq ep eu) er,?_,?_,?_,?_⟩ |
| · have hcL : cost≤((PaddedAxis.row (k*Q) r).cost+5)*L+1 := hcost.trans (by gcongr) |
| nlinarith only [hcL,hrcost] |
| · simpa only [banks_succ,finalCount] using hregsFinal |
| · simpa only [banks_succ,value,finalCount] using hmFinal |
| · intro a ha hb |
| rw [houtFinal a hb ha] |
| exact houtside a (by omega) |
|
|
| end DeterministicThreeSum.Structured.Indexed.MatrixDown |
| namespace DeterministicThreeSum.Structured.Indexed.MatrixDown |
| open Command DeterministicThreeSum.Rectangular Axis MatrixLayout |
| noncomputable section |
|
|
| def leftLeaves {T a b k r : ℕ} (f : FixedFormula (ZMod T) a b k r) : |
| (d t : ℕ) → LeftBatch (ZMod T) a b d t → Fin (finalCount k r d t) → ZMod T |
| | 0,_,x,z => x z 0 0 |
| | d+1,t,x,z => leftLeaves f d (batchCount t k*r) (childLeft f x) z |
|
|
| theorem value_leftLeaves {T a b k r d t : ℕ} |
| (ha : 0<a) (hb : 0<b) (hr : 0<r) |
| (f : FixedFormula (ZMod T) a b k r) (x : LeftBatch (ZMod T) a b d t) |
| (data co : ℕ → ℕ) |
| (hx : ∀ z u v, (data (z.val*(a*b)^d+pairCode a b d u v):ZMod T)=x z u v) |
| (hc : ∀ (s : Fin r) (i : Fin k × Fin a × Fin b), |
| (co (s.val*(k*(a*b))+(tripleIndex k a b i).val):ZMod T)=f.left s i) |
| (z : Fin (finalCount k r d t)) : |
| (value T (a*b) k r co d t data z.val : ZMod T)=leftLeaves f d t x z := by |
| induction d generalizing t data with |
| | zero => simpa only [value,leftLeaves,pairCode,pow_zero,Nat.mul_one,Nat.add_zero] using hx z 0 0 |
| | succ d ih => |
| apply ih (childLeft f x) (mapValue T (k*(a*b)) r ((a*b)^d) |
| (PaddedAxis.pad data (t*((a*b)^(d+1)))) co) |
| intro j u v |
| obtain ⟨⟨g,s⟩,rfl⟩ := finProdFinEquiv.surjective j |
| simpa only [finProdFinEquiv,Equiv.coe_fn_mk,Fin.val_mk,Nat.add_comm,Nat.mul_comm] using |
| left_level_value ha hb hr f x data co hx hc g s u v |
|
|
| theorem left_loop_correct {w T a b k r L d t P S C : ℕ} |
| (state : Data) (f : FixedFormula (ZMod T) a b k r) |
| (x : LeftBatch (ZMod T) a b d t) (data co : ℕ → ℕ) |
| (ha : 0<a) (hb : 0<b) (hQ : 1<a*b) (hk : 0<k) (hr : 0<r) (ht : 0<t) (hT : 0<T) |
| (hadd : 2*T<wordModulus w) (hmul : T*T<wordModulus w) |
| (hL : capacity (a*b) k r d t≤L) |
| (hLw : (L+k)*r+L+k+a*b+r+3<wordModulus w) |
| (hP : P+L+1<wordModulus w) (hS : S+L+1<wordModulus w) |
| (hC : C+r*(k*(a*b))<wordModulus w) |
| (hPS : S+L≤P ∨ P+L≤S) |
| (hCP : C+r*(k*(a*b))≤P ∨ P+L≤C) (hCS : C+r*(k*(a*b))≤S ∨ S+L≤C) |
| (hregs : ∀ z : Fin 8, state.registers z.val= |
| environment T (batchCount t k*r*tensorStride (a*b) d) P S C |
| (tensorStride (a*b) d) (t*(a*b)^d) 0 z) |
| (hx : ∀ i, i<t*(a*b)^d → state.memory (S+i)=some (data i) ∧ data i<T) |
| (hc : ∀ i, i<r*(k*(a*b)) → state.memory (C+i)=some (co i) ∧ co i<T) |
| (hsource : ∀ z u v, (data (z.val*(a*b)^d+pairCode a b d u v):ZMod T)=x z u v) |
| (hformula : ∀ (s : Fin r) (i : Fin k × Fin a × Fin b), |
| (co (s.val*(k*(a*b))+(tripleIndex k a b i).val):ZMod T)=f.left s i) : |
| ∃ cost out, Eval w (loop (a*b) k r) state cost out ∧ |
| cost≤(((PaddedAxis.row (k*(a*b)) r).cost+5)*L+15)*d+1 ∧ |
| (∀ z : Fin 8, out.registers z.val= |
| environment T 0 (banks d P S).1 (banks d P S).2 C 0 (finalCount k r d t) 0 z) ∧ |
| (∀ z : Fin (finalCount k r d t), ∃ n, |
| out.memory ((banks d P S).2+z.val)=some n ∧ n<T ∧ |
| (n:ZMod T)=leftLeaves f d t x z) ∧ |
| (∀ addr, (addr<P ∨ P+L≤addr) → (addr<S ∨ S+L≤addr) → out.memory addr=state.memory addr) := by |
| obtain ⟨cost,out,he,hcost,hregsFinal,hm,ho⟩ := loop_correct state data co hQ hk hr ht hT |
| hadd hmul hL hLw hP hS hC hPS hCP hCS hregs hx hc |
| refine ⟨cost,out,he,hcost,hregsFinal,?_,ho⟩ |
| intro z |
| exact ⟨_,(hm z.val z.isLt).1,(hm z.val z.isLt).2, |
| value_leftLeaves ha hb hr f x data co hsource hformula z⟩ |
|
|
| end |
| end DeterministicThreeSum.Structured.Indexed.MatrixDown |
|
|
| namespace DeterministicThreeSum.Structured.Indexed.MatrixDown |
| open Command DeterministicThreeSum.Rectangular Axis MatrixLayout |
| noncomputable section |
|
|
| def rightLeaves {T a b k r : ℕ} (f : FixedFormula (ZMod T) a b k r) : |
| (d t : ℕ) → RightBatch (ZMod T) a b d t → Fin (finalCount k r d t) → ZMod T |
| | 0,_,y,z => y z 0 0 |
| | d+1,t,y,z => rightLeaves f d (batchCount t k*r) (childRight f y) z |
|
|
| theorem value_rightLeaves {T a b k r d t : ℕ} |
| (ha : 0<a) (hb : 0<b) (hr : 0<r) |
| (f : FixedFormula (ZMod T) a b k r) (y : RightBatch (ZMod T) a b d t) |
| (data co : ℕ → ℕ) |
| (hy : ∀ z u v, (data (z.val*(b*a)^d+pairCode b a d u v):ZMod T)=y z u v) |
| (hc : ∀ (s : Fin r) (i : Fin k × Fin b × Fin a), |
| (co (s.val*(k*(b*a))+(tripleIndex k b a i).val):ZMod T)=f.right s i) |
| (z : Fin (finalCount k r d t)) : |
| (value T (b*a) k r co d t data z.val : ZMod T)=rightLeaves f d t y z := by |
| induction d generalizing t data with |
| | zero => simpa only [value,rightLeaves,pairCode,pow_zero,Nat.mul_one,Nat.add_zero] using hy z 0 0 |
| | succ d ih => |
| apply ih (childRight f y) (mapValue T (k*(b*a)) r ((b*a)^d) |
| (PaddedAxis.pad data (t*((b*a)^(d+1)))) co) |
| intro j u v |
| obtain ⟨⟨g,s⟩,rfl⟩ := finProdFinEquiv.surjective j |
| simpa only [finProdFinEquiv,Equiv.coe_fn_mk,Fin.val_mk,Nat.add_comm,Nat.mul_comm] using |
| right_level_value ha hb hr f y data co hy hc g s u v |
|
|
| end |
| end DeterministicThreeSum.Structured.Indexed.MatrixDown |
|
|
| end OAI |
|
|
