File size: 5,002 Bytes
cdec422 | 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 | import OAI.LinearAlgebra.MatrixMultiplication.Arithmetic.ProgramComposition
namespace OAI
/-! Division-free arithmetic programs over a field and their operation counts. -/
noncomputable section
open scoped BigOperators
namespace MatrixMultiplication.Arithmetic
variable {F : Type*} [Field F]
def zeroPadMatrix {a b : ℕ} (A B : ℕ) (M : Matrix (Fin a) (Fin b) F) :
Matrix (Fin A) (Fin B) F :=
fun i j => if hi : i.val < a then
if hj : j.val < b then M ⟨i.val, hi⟩ ⟨j.val, hj⟩ else 0
else 0
@[simp] theorem zeroPadMatrix_castLE {a b A B : ℕ} (ha : a ≤ A) (hb : b ≤ B)
(M : Matrix (Fin a) (Fin b) F) (i : Fin a) (j : Fin b) :
zeroPadMatrix A B M (Fin.castLE ha i) (Fin.castLE hb j) = M i j := by
simp [zeroPadMatrix, i.is_lt, j.is_lt]
theorem sum_fin_castLE_of_zero {n m : ℕ} (h : n ≤ m) (f : Fin m → F)
(hf : ∀ j : Fin m, n ≤ j.val → f j = 0) :
(∑ j : Fin m, f j) = ∑ j : Fin n, f (Fin.castLE h j) := by
symm
refine Fintype.sum_of_injective (Fin.castLE h) ?_
(fun j : Fin n => f (Fin.castLE h j)) f ?_ (fun _ => rfl)
· intro i j hij
exact Fin.ext (congrArg (fun v : Fin m => v.val) hij)
· intro j hj
exact hf j (le_of_not_gt fun hsmall => hj ⟨⟨j.val, hsmall⟩, Fin.ext rfl⟩)
theorem zeroPadMatrix_mul {a b c A B C : ℕ} (ha : a ≤ A) (hb : b ≤ B) (hc : c ≤ C)
(M : Matrix (Fin a) (Fin b) F) (N : Matrix (Fin b) (Fin c) F)
(i : Fin a) (k : Fin c) :
(zeroPadMatrix A B M * zeroPadMatrix B C N) (Fin.castLE ha i) (Fin.castLE hc k) =
(M * N) i k := by
rw [Matrix.mul_apply, Matrix.mul_apply]
calc
(∑ j : Fin B,
zeroPadMatrix A B M (Fin.castLE ha i) j *
zeroPadMatrix B C N j (Fin.castLE hc k)) =
∑ j : Fin b,
zeroPadMatrix A B M (Fin.castLE ha i) (Fin.castLE hb j) *
zeroPadMatrix B C N (Fin.castLE hb j) (Fin.castLE hc k) := by
apply sum_fin_castLE_of_zero hb
intro j hj
simp [zeroPadMatrix, not_lt_of_ge hj]
_ = ∑ j : Fin b, M i j * N j k := by simp
def padSource {a b c A B C : ℕ} : MatrixInput A B C → MatrixInput a b c ⊕ F
| .inl (i, j) => if hi : i.val < a then
if hj : j.val < b then .inl (.inl (⟨i.val, hi⟩, ⟨j.val, hj⟩)) else .inr 0
else .inr 0
| .inr (j, k) => if hj : j.val < b then
if hk : k.val < c then .inl (.inr (⟨j.val, hj⟩, ⟨k.val, hk⟩)) else .inr 0
else .inr 0
theorem padSource_eval {a b c A B C : ℕ}
(M : Matrix (Fin a) (Fin b) F) (N : Matrix (Fin b) (Fin c) F) :
(fun x : MatrixInput A B C => Sum.elim (matrixInputs M N) id (padSource x)) =
matrixInputs (zeroPadMatrix A B M) (zeroPadMatrix B C N) := by
funext x
rcases x with ⟨i, j⟩ | ⟨j, k⟩
· by_cases hi : i.val < a <;> by_cases hj : j.val < b <;>
simp [padSource, matrixInputs, zeroPadMatrix, hi, hj]
· by_cases hj : j.val < b <;> by_cases hk : k.val < c <;>
simp [padSource, matrixInputs, zeroPadMatrix, hj, hk]
namespace MatrixAlgorithm
def pad {a b c A B C : ℕ} (ha : a ≤ A) (_hb : b ≤ B) (hc : c ≤ C)
(P : MatrixAlgorithm F A B C) : MatrixAlgorithm F a b c where
registers := P.registers
program := P.program.mapSource (padSource (a := a) (b := b) (c := c))
output := fun i k => P.output (Fin.castLE ha i) (Fin.castLE hc k)
theorem pad_correct {a b c A B C : ℕ} (ha : a ≤ A) (hb : b ≤ B) (hc : c ≤ C)
{P : MatrixAlgorithm F A B C} (hP : P.Correct) : (pad ha hb hc P).Correct := by
intro M N
funext i k
change (P.program.mapSource (padSource (a := a) (b := b) (c := c))).eval
(matrixInputs M N) (P.output (Fin.castLE ha i) (Fin.castLE hc k)) = (M * N) i k
rw [Program.eval_mapSource, padSource_eval]
have hentry := congrFun (congrFun
(hP (zeroPadMatrix A B M) (zeroPadMatrix B C N)) (Fin.castLE ha i)) (Fin.castLE hc k)
exact hentry.trans (zeroPadMatrix_mul ha hb hc M N i k)
@[simp] theorem pad_cost_eq {a b c A B C : ℕ} (ha : a ≤ A) (hb : b ≤ B) (hc : c ≤ C)
(P : MatrixAlgorithm F A B C) : (pad ha hb hc P).cost = P.cost :=
Program.cost_mapSource (padSource (a := a) (b := b) (c := c)) P.program
theorem exists_restrict {a b c A B C : ℕ} (ha : a ≤ A) (hb : b ≤ B) (hc : c ≤ C)
(P : MatrixAlgorithm F A B C) (hP : P.Correct) :
∃ Q : MatrixAlgorithm F a b c, Q.Correct ∧ Q.cost ≤ P.cost :=
⟨pad ha hb hc P, pad_correct ha hb hc hP, (pad_cost_eq ha hb hc P).le⟩
end MatrixAlgorithm
theorem RectangularAdmissibleExponent.mono_aspect {k l τ : ℝ}
(h : RectangularAdmissibleExponent F l τ) (hkl : k ≤ l) :
RectangularAdmissibleExponent F k τ := by
intro ε hε
obtain ⟨C, hC, hbound⟩ := h ε hε
refine ⟨C, hC, ?_⟩
intro n hn
obtain ⟨P, hP, hcost⟩ := hbound n hn
obtain ⟨Q, hQ, hcostQ⟩ := MatrixAlgorithm.exists_restrict (le_refl n)
(innerSize_mono hn hkl) (le_refl n) P hP
exact ⟨Q, hQ, (Nat.cast_le.mpr hcostQ).trans hcost⟩
end MatrixMultiplication.Arithmetic
end
end OAI
|