| import Mathlib |
|
|
| namespace OAI |
|
|
| /-! Exact bilinear formulas and recursive simultaneous matrix products. -/ |
|
|
| namespace DeterministicThreeSum.Rectangular |
| open scoped BigOperators |
| open Finset |
|
|
| structure BilinearFormula (R I J O K : Type*) where |
| left : K → I → R |
| right : K → J → R |
| out : K → O → R |
|
|
| namespace BilinearFormula |
| variable {R I J O K : Type*} [CommRing R] [Fintype I] [Fintype J] [Fintype K] |
|
|
| def coeff (f : BilinearFormula R I J O K) (i : I) (j : J) (o : O) : R := |
| ∑ k, f.left k i * f.right k j * f.out k o |
|
|
| def eval (f : BilinearFormula R I J O K) (x : I → R) (y : J → R) (o : O) : R := |
| ∑ k, ((∑ i, f.left k i * x i) * (∑ j, f.right k j * y j)) * f.out k o |
|
|
| lemma eval_eq (f : BilinearFormula R I J O K) (x : I → R) (y : J → R) (o : O) : |
| f.eval x y o = ∑ i, ∑ j, f.coeff i j o * x i * y j := by |
| simp only [eval, coeff, Finset.sum_mul, Finset.mul_sum] |
| conv_lhs => rw [Finset.sum_comm]; arg 2; ext j; rw [Finset.sum_comm] |
| rw [Finset.sum_comm] |
| apply sum_congr rfl |
| intro i _ |
| apply sum_congr rfl |
| intro j _ |
| apply sum_congr rfl |
| intro k _ |
| ring |
|
|
| end BilinearFormula |
|
|
| end DeterministicThreeSum.Rectangular |
|
|
| namespace DeterministicThreeSum.Rectangular |
| open Finset |
| open scoped BigOperators |
| namespace BilinearFormula |
| variable {R I J O K : Type*} [CommRing R] [Fintype I] [Fintype J] [Fintype K] |
| variable {M N P : Type*} [AddCommGroup M] [Module R M] |
| [AddCommGroup N] [Module R N] [AddCommGroup P] [Module R P] |
|
|
| def evalBilinear (f : BilinearFormula R I J O K) (B : M →ₗ[R] N →ₗ[R] P) |
| (x : I → M) (y : J → N) (o : O) : P := |
| ∑ k, f.out k o • B (∑ i, f.left k i • x i) (∑ j, f.right k j • y j) |
|
|
| theorem evalBilinear_eq (f : BilinearFormula R I J O K) (B : M →ₗ[R] N →ₗ[R] P) |
| (x : I → M) (y : J → N) (o : O) : |
| f.evalBilinear B x y o = ∑ i, ∑ j, f.coeff i j o • B (x i) (y j) := by |
| simp only [evalBilinear, coeff, map_sum, map_smul, LinearMap.sum_apply, |
| LinearMap.smul_apply, Finset.smul_sum, Finset.sum_smul, smul_smul] |
| conv_lhs => rw [Finset.sum_comm]; arg 2; ext i; rw [Finset.sum_comm] |
| rw [Finset.sum_comm] |
| apply sum_congr rfl |
| intro i _ |
| apply sum_congr rfl |
| intro j _ |
| apply sum_congr rfl |
| intro k _ |
| congr 1 |
| ring |
|
|
| end BilinearFormula |
|
|
| def independentMatrixTensor {E A B C : Type*} [DecidableEq E] [DecidableEq A] |
| [DecidableEq B] [DecidableEq C] |
| (i : E × A × B) (j : E × B × C) (o : E × A × C) : ℤ := |
| if i.1 = j.1 ∧ j.1 = o.1 ∧ i.2.1 = o.2.1 ∧ i.2.2 = j.2.1 ∧ j.2.2 = o.2.2 then 1 else 0 |
|
|
| section Independent |
| variable {R E A B C K : Type*} [CommRing R] |
| [Fintype E] [Fintype A] [Fintype B] [Fintype C] [Fintype K] |
| [DecidableEq E] [DecidableEq A] [DecidableEq B] [DecidableEq C] |
| variable {M N P : Type*} [AddCommGroup M] [Module R M] |
| [AddCommGroup N] [Module R N] [AddCommGroup P] [Module R P] |
|
|
| lemma independent_evalBilinear |
| (f : BilinearFormula R (E × A × B) (E × B × C) (E × A × C) K) |
| (hf : ∀ i j o, f.coeff i j o = (independentMatrixTensor i j o : R)) |
| (mul : M →ₗ[R] N →ₗ[R] P) (x : E × A × B → M) (y : E × B × C → N) |
| (e : E) (a : A) (c : C) : |
| f.evalBilinear mul x y (e,a,c) = ∑ b, mul (x (e,a,b)) (y (e,b,c)) := by |
| classical |
| rw [BilinearFormula.evalBilinear_eq] |
| simp only [hf, independentMatrixTensor, Fintype.sum_prod_type] |
| simp [ite_and] |
|
|
| theorem independent_block_products {U V W : Type*} [Fintype V] |
| (f : BilinearFormula R (E × A × B) (E × B × C) (E × A × C) K) |
| (hf : ∀ i j o, f.coeff i j o = (independentMatrixTensor i j o : R)) |
| (x : E × A × B → Matrix U V R) (y : E × B × C → Matrix V W R) |
| (e : E) (a : A) (c : C) : |
| f.evalBilinear (mulLinearMap R) x y (e,a,c) = |
| ∑ b, x (e,a,b) * y (e,b,c) := by |
| exact independent_evalBilinear f hf _ x y e a c |
|
|
| def reindexIndependent {E' K' : Type*} |
| (f : BilinearFormula R (E × A × B) (E × B × C) (E × A × C) K) |
| (e : E' ≃ E) (u : K' ≃ K) : |
| BilinearFormula R (E' × A × B) (E' × B × C) (E' × A × C) K' where |
| left t i := f.left (u t) (e i.1,i.2) |
| right t j := f.right (u t) (e j.1,j.2) |
| out t o := f.out (u t) (e o.1,o.2) |
|
|
| omit [Fintype E] [Fintype A] [Fintype B] [Fintype C] in |
| lemma reindexIndependent_correct {E' K' : Type*} [Fintype K'] [DecidableEq E'] |
| (f : BilinearFormula R (E × A × B) (E × B × C) (E × A × C) K) |
| (hf : ∀ i j o, f.coeff i j o = (independentMatrixTensor i j o : R)) |
| (e : E' ≃ E) (u : K' ≃ K) (i : E' × A × B) (j : E' × B × C) |
| (o : E' × A × C) : |
| (reindexIndependent f e u).coeff i j o = (independentMatrixTensor i j o : R) := by |
| unfold BilinearFormula.coeff reindexIndependent |
| change (∑ t, f.left (u t) (e i.1,i.2)*f.right (u t) (e j.1,j.2)* |
| f.out (u t) (e o.1,o.2)) = _ |
| rw [u.sum_comp (fun z => f.left z (e i.1,i.2)*f.right z (e j.1,j.2)* |
| f.out z (e o.1,o.2))] |
| change f.coeff (e i.1,i.2) (e j.1,j.2) (e o.1,o.2) = _ |
| rw [hf] |
| simp only [independentMatrixTensor, Equiv.apply_eq_iff_eq] |
|
|
| end Independent |
| end DeterministicThreeSum.Rectangular |
|
|
| namespace DeterministicThreeSum.Rectangular |
| open Finset |
| open scoped BigOperators |
| noncomputable section |
|
|
| abbrev DigitBox (a j : ℕ) : Type := |
| Nat.rec (Fin 1) (fun _ W => Fin a × W) j |
|
|
| instance digitBoxZero (a : ℕ) : OfNat (DigitBox a 0) 0 := |
| inferInstanceAs (OfNat (Fin 1) 0) |
| instance digitBoxSubsingleton (a : ℕ) : Subsingleton (DigitBox a 0) := |
| inferInstanceAs (Subsingleton (Fin 1)) |
|
|
| instance digitBoxFintype (a j : ℕ) : Fintype (DigitBox a j) := by |
| induction j with |
| | zero => exact inferInstanceAs (Fintype (Fin 1)) |
| | succ j ih => |
| letI := ih |
| exact inferInstanceAs (Fintype (Fin a × DigitBox a j)) |
|
|
| lemma card_DigitBox (a j : ℕ) : Fintype.card (DigitBox a j) = a^j := by |
| induction j with |
| | zero => simp [DigitBox] |
| | succ j ih => |
| change Fintype.card (Fin a × DigitBox a j) = _ |
| rw [Fintype.card_prod, Fintype.card_fin, ih, pow_succ, mul_comm] |
|
|
| def batchCount (t k : ℕ) : ℕ := t ⌈/⌉ k |
|
|
| lemma batchCount_covers (t k : ℕ) (hk : 0 < k) : t ≤ k * batchCount t k := |
| (ceilDiv_le_iff_le_mul hk).mp le_rfl |
|
|
| variable {R : Type*} [CommRing R] {a b k r j t : ℕ} |
|
|
| abbrev FixedFormula (R : Type*) (a b k r : ℕ) := |
| BilinearFormula R (Fin k × Fin a × Fin b) (Fin k × Fin b × Fin a) |
| (Fin k × Fin a × Fin a) (Fin r) |
|
|
| abbrev LeftBatch (R : Type*) (a b j t : ℕ) := |
| Fin t → Matrix (DigitBox a j) (DigitBox b j) R |
| abbrev RightBatch (R : Type*) (a b j t : ℕ) := |
| Fin t → Matrix (DigitBox b j) (DigitBox a j) R |
| abbrev OutputBatch (R : Type*) (a j t : ℕ) := |
| Fin t → Matrix (DigitBox a j) (DigitBox a j) R |
|
|
| def paddedLeft (x : LeftBatch R a b (j+1) t) (q : Fin (batchCount t k)) |
| (i : Fin k × Fin a × Fin b) : Matrix (DigitBox a j) (DigitBox b j) R := |
| if h : q.val*k+i.1.val < t then |
| fun u v => x ⟨q.val*k+i.1.val,h⟩ (i.2.1,u) (i.2.2,v) |
| else 0 |
|
|
| def paddedRight (y : RightBatch R a b (j+1) t) (q : Fin (batchCount t k)) |
| (i : Fin k × Fin b × Fin a) : Matrix (DigitBox b j) (DigitBox a j) R := |
| if h : q.val*k+i.1.val < t then |
| fun u v => y ⟨q.val*k+i.1.val,h⟩ (i.2.1,u) (i.2.2,v) |
| else 0 |
|
|
| def childLeft (f : FixedFormula R a b k r) (x : LeftBatch R a b (j+1) t) : |
| LeftBatch R a b j (batchCount t k*r) := fun z => |
| let qs : Fin (batchCount t k) × Fin r := finProdFinEquiv.symm z |
| ∑ i, f.left qs.2 i • paddedLeft x qs.1 i |
|
|
| def childRight (f : FixedFormula R a b k r) (y : RightBatch R a b (j+1) t) : |
| RightBatch R a b j (batchCount t k*r) := fun z => |
| let qs : Fin (batchCount t k) × Fin r := finProdFinEquiv.symm z |
| ∑ i, f.right qs.2 i • paddedRight y qs.1 i |
|
|
| def parentBatch (hk : 0 < k) (e : Fin t) : Fin (batchCount t k) := |
| ⟨e.val/k, (Nat.div_lt_iff_lt_mul hk).mpr |
| (e.isLt.trans_le (by simpa [Nat.mul_comm] using batchCount_covers t k hk))⟩ |
|
|
| def parentSlot (hk : 0 < k) (e : Fin t) : Fin k := ⟨e.val%k,Nat.mod_lt e.val hk⟩ |
|
|
| lemma parent_index (hk : 0 < k) (e : Fin t) : |
| (parentBatch hk e).val*k+(parentSlot hk e).val = e.val := by |
| simpa only [parentBatch, parentSlot, Nat.mul_comm] using Nat.div_add_mod e.val k |
|
|
| def combineChildren (f : FixedFormula R a b k r) (hk : 0 < k) |
| (z : OutputBatch R a j (batchCount t k*r)) : OutputBatch R a (j+1) t := |
| fun e uv wv => ∑ s : Fin r, |
| f.out s (parentSlot hk e,uv.1,wv.1) * |
| z (finProdFinEquiv (parentBatch hk e,s)) uv.2 wv.2 |
|
|
| lemma paddedLeft_parent (hk : 0 < k) (x : LeftBatch R a b (j+1) t) |
| (e : Fin t) (u : Fin a) (v : Fin b) : |
| paddedLeft x (parentBatch hk e) (parentSlot hk e,u,v) = |
| fun i j => x e (u,i) (v,j) := by |
| unfold paddedLeft |
| erw [dite_eq_left (show (parentBatch hk e).val*k+(parentSlot hk e).val < t by |
| rw [parent_index]; exact e.isLt)] |
| simp only [parent_index, Fin.eta] |
| rfl |
|
|
| lemma paddedRight_parent (hk : 0 < k) (y : RightBatch R a b (j+1) t) |
| (e : Fin t) (u : Fin b) (v : Fin a) : |
| paddedRight y (parentBatch hk e) (parentSlot hk e,u,v) = |
| fun i j => y e (u,i) (v,j) := by |
| unfold paddedRight |
| erw [dite_eq_left (show (parentBatch hk e).val*k+(parentSlot hk e).val < t by |
| rw [parent_index]; exact e.isLt)] |
| simp only [parent_index, Fin.eta] |
| rfl |
|
|
| lemma combineChildren_correct (f : FixedFormula R a b k r) (hk : 0 < k) |
| (hf : ∀ i j o, f.coeff i j o = (independentMatrixTensor i j o : R)) |
| (x : LeftBatch R a b (j+1) t) (y : RightBatch R a b (j+1) t) : |
| combineChildren f hk (fun z => childLeft f x z * childRight f y z) = |
| fun e => x e * y e := by |
| funext e uv wv |
| have h := independent_block_products f hf |
| (paddedLeft x (parentBatch hk e)) (paddedRight y (parentBatch hk e)) |
| (parentSlot hk e) uv.1 wv.1 |
| have hv := congrFun (congrFun h uv.2) wv.2 |
| simp only [BilinearFormula.evalBilinear, Matrix.sum_apply, Matrix.smul_apply, |
| mulLinearMap, mulLeftLinearMap, LinearMap.coe_mk, AddHom.coe_mk, smul_eq_mul] at hv |
| change (∑ s, f.out s (parentSlot hk e,uv.1,wv.1) * |
| (childLeft f x (finProdFinEquiv (parentBatch hk e,s)) * |
| childRight f y (finProdFinEquiv (parentBatch hk e,s))) uv.2 wv.2) = _ |
| simp only [childLeft, childRight, Equiv.symm_apply_apply] |
| rw [hv] |
| simp only [Matrix.mul_apply, Fintype.sum_prod_type] |
| simp only [paddedLeft_parent, paddedRight_parent] |
|
|
| def multiplyBatch (f : FixedFormula R a b k r) (hk : 0 < k) : |
| (j t : ℕ) → LeftBatch R a b j t → RightBatch R a b j t → OutputBatch R a j t |
| | 0, _, x, y => fun e _ _ => x e 0 0 * y e 0 0 |
| | j+1, t, x, y => combineChildren f hk |
| (multiplyBatch f hk j (batchCount t k*r) (childLeft f x) (childRight f y)) |
|
|
| theorem multiplyBatch_correct (f : FixedFormula R a b k r) (hk : 0 < k) |
| (hf : ∀ i j o, f.coeff i j o = (independentMatrixTensor i j o : R)) |
| (j t : ℕ) (x : LeftBatch R a b j t) (y : RightBatch R a b j t) : |
| multiplyBatch f hk j t x y = fun e => x e * y e := by |
| induction j generalizing t with |
| | zero => |
| funext e i l |
| have hi : i = 0 := Subsingleton.elim _ _ |
| have hl : l = 0 := Subsingleton.elim _ _ |
| subst i; subst l |
| simp [multiplyBatch, Matrix.mul_apply] |
| | succ j ih => |
| rw [multiplyBatch, ih] |
| exact combineChildren_correct f hk hf x y |
|
|
| end |
| end DeterministicThreeSum.Rectangular |
|
|
| end OAI |
|
|
