File size: 3,893 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 | import OAI.LinearAlgebra.MatrixMultiplication.ComplexArithmetic.ProgramComposition
namespace OAI
/-! Complex arithmetic programs and asymptotic matrix multiplication costs. -/
noncomputable section
open scoped BigOperators
namespace MatrixMultiplication.Foundation.Arithmetic
def zeroPadMatrix {n : ℕ} (m : ℕ) (A : Matrix (Fin n) (Fin n) ℂ) :
Matrix (Fin m) (Fin m) ℂ :=
fun i j => if hi : i.val < n then
if hj : j.val < n then A ⟨i.val, hi⟩ ⟨j.val, hj⟩ else 0
else 0
@[simp] theorem zeroPadMatrix_castLE {n m : ℕ} (h : n ≤ m)
(A : Matrix (Fin n) (Fin n) ℂ) (i j : Fin n) :
zeroPadMatrix m A (Fin.castLE h i) (Fin.castLE h j) = A 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 → ℂ)
(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 {n m : ℕ} (h : n ≤ m)
(A B : Matrix (Fin n) (Fin n) ℂ) (i k : Fin n) :
(zeroPadMatrix m A * zeroPadMatrix m B) (Fin.castLE h i) (Fin.castLE h k) =
(A * B) i k := by
rw [Matrix.mul_apply, Matrix.mul_apply]
calc
(∑ j : Fin m,
zeroPadMatrix m A (Fin.castLE h i) j *
zeroPadMatrix m B j (Fin.castLE h k)) =
∑ j : Fin n,
zeroPadMatrix m A (Fin.castLE h i) (Fin.castLE h j) *
zeroPadMatrix m B (Fin.castLE h j) (Fin.castLE h k) := by
apply sum_fin_castLE_of_zero h
intro j hj
simp [zeroPadMatrix, not_lt_of_ge hj]
_ = ∑ j : Fin n, A i j * B j k := by simp
def padSource {n m : ℕ} : MatrixInput m → MatrixInput n ⊕ ℂ
| .inl (i, j) => if hi : i.val < n then
if hj : j.val < n then .inl (.inl (⟨i.val, hi⟩, ⟨j.val, hj⟩)) else .inr 0
else .inr 0
| .inr (i, j) => if hi : i.val < n then
if hj : j.val < n then .inl (.inr (⟨i.val, hi⟩, ⟨j.val, hj⟩)) else .inr 0
else .inr 0
theorem padSource_eval {n m : ℕ} (A B : Matrix (Fin n) (Fin n) ℂ) :
(fun x : MatrixInput m => Sum.elim (matrixInputs A B) id (padSource x)) =
matrixInputs (zeroPadMatrix m A) (zeroPadMatrix m B) := by
funext x
rcases x with ⟨i, j⟩ | ⟨i, j⟩
all_goals
by_cases hi : i.val < n <;> by_cases hj : j.val < n <;>
simp [padSource, matrixInputs, zeroPadMatrix, hi, hj]
namespace MatrixAlgorithm
def pad {n m : ℕ} (h : n ≤ m) (P : MatrixAlgorithm m) : MatrixAlgorithm n where
registers := P.registers
program := P.program.mapSource (padSource (n := n))
output := fun i k => P.output (Fin.castLE h i) (Fin.castLE h k)
theorem pad_correct {n m : ℕ} (h : n ≤ m) {P : MatrixAlgorithm m}
(hP : P.Correct) : (pad h P).Correct := by
intro A B
funext i k
change (P.program.mapSource (padSource (n := n))).eval (matrixInputs A B)
(P.output (Fin.castLE h i) (Fin.castLE h k)) = (A * B) i k
rw [Program.eval_mapSource, padSource_eval]
have hentry := congrFun (congrFun
(hP (zeroPadMatrix m A) (zeroPadMatrix m B)) (Fin.castLE h i)) (Fin.castLE h k)
exact hentry.trans (zeroPadMatrix_mul h A B i k)
@[simp] theorem pad_cost_eq {n m : ℕ} (h : n ≤ m) (P : MatrixAlgorithm m) :
(pad h P).cost = P.cost :=
Program.cost_mapSource (padSource (n := n)) P.program
theorem exists_restrict {n m : ℕ} (h : n ≤ m) (P : MatrixAlgorithm m)
(hP : P.Correct) : ∃ Q : MatrixAlgorithm n, Q.Correct ∧ Q.cost ≤ P.cost :=
⟨pad h P, pad_correct h hP, (pad_cost_eq h P).le⟩
end MatrixAlgorithm
end MatrixMultiplication.Foundation.Arithmetic
end
end OAI
|