File size: 4,572 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 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 148 149 150 151 152 | import OAI.LinearAlgebra.MatrixMultiplication.Tensor.ComplexTensor
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Matrix.Mul
namespace OAI
/-! Complex arithmetic programs and asymptotic matrix multiplication costs. -/
noncomputable section
open scoped BigOperators
namespace MatrixMultiplication.Foundation
namespace Arithmetic
inductive Gate (Input Register : Type*) where
| constant : ℂ → Gate Input Register
| input : Input → Gate Input Register
| add : Register → Register → Gate Input Register
| sub : Register → Register → Gate Input Register
| mul : Register → Register → Gate Input Register
namespace Gate
variable {Input Register : Type*}
def eval (inputs : Input → ℂ) (registers : Register → ℂ) : Gate Input Register → ℂ
| .constant z => z
| .input i => inputs i
| .add i j => registers i + registers j
| .sub i j => registers i - registers j
| .mul i j => registers i * registers j
def cost : Gate Input Register → ℕ
| .constant _ => 0
| .input _ => 0
| .add _ _ => 1
| .sub _ _ => 1
| .mul _ _ => 1
end Gate
inductive Program (Input : Type*) : ℕ → Type _ where
| nil : Program Input 0
| step {r : ℕ} : Program Input r → Gate Input (Fin r) → Program Input (r + 1)
namespace Program
variable {Input : Type*}
def eval : {r : ℕ} → Program Input r → (Input → ℂ) → Fin r → ℂ
| 0, .nil, _ => Fin.elim0
| _ + 1, .step p g, inputs =>
Fin.cases (g.eval inputs (p.eval inputs)) (p.eval inputs)
def cost : {r : ℕ} → Program Input r → ℕ
| 0, .nil => 0
| _ + 1, .step p g => p.cost + g.cost
@[simp] theorem eval_step_zero {r : ℕ} (p : Program Input r)
(g : Gate Input (Fin r)) (inputs : Input → ℂ) :
(p.step g).eval inputs 0 = g.eval inputs (p.eval inputs) := rfl
@[simp] theorem eval_step_succ {r : ℕ} (p : Program Input r)
(g : Gate Input (Fin r)) (inputs : Input → ℂ) (i : Fin r) :
(p.step g).eval inputs i.succ = p.eval inputs i := rfl
@[simp] theorem cost_step {r : ℕ} (p : Program Input r)
(g : Gate Input (Fin r)) : (p.step g).cost = p.cost + g.cost := rfl
end Program
abbrev MatrixInput (n : ℕ) := (Fin n × Fin n) ⊕ (Fin n × Fin n)
def matrixInputs {n : ℕ} (A B : Matrix (Fin n) (Fin n) ℂ) : MatrixInput n → ℂ
| .inl (i, j) => A i j
| .inr (j, k) => B j k
structure MatrixAlgorithm (n : ℕ) where
registers : ℕ
program : Program (MatrixInput n) registers
output : Fin n → Fin n → Fin registers
namespace MatrixAlgorithm
def eval {n : ℕ} (P : MatrixAlgorithm n)
(A B : Matrix (Fin n) (Fin n) ℂ) : Matrix (Fin n) (Fin n) ℂ :=
fun i k => P.program.eval (matrixInputs A B) (P.output i k)
def Correct {n : ℕ} (P : MatrixAlgorithm n) : Prop :=
∀ A B : Matrix (Fin n) (Fin n) ℂ, P.eval A B = A * B
def cost {n : ℕ} (P : MatrixAlgorithm n) : ℕ := P.program.cost
theorem correct_iff_entries {n : ℕ} (P : MatrixAlgorithm n) :
P.Correct ↔ ∀ (A B : Matrix (Fin n) (Fin n) ℂ) (i k : Fin n),
P.program.eval (matrixInputs A B) (P.output i k) = ∑ j, A i j * B j k := by
constructor
· intro h A B i k
exact congrFun (congrFun (h A B) i) k
· intro h A B
funext i k
exact h A B i k
end MatrixAlgorithm
def scalarAlgorithm : MatrixAlgorithm 1 where
registers := 3
program := ((Program.nil.step (.input (.inl (0, 0)))).step
(.input (.inr (0, 0)))).step (.mul 1 0)
output := fun _ _ => 0
theorem scalarAlgorithm_correct : scalarAlgorithm.Correct := by
intro A B
funext i k
have hi : i = 0 := Subsingleton.elim _ _
have hk : k = 0 := Subsingleton.elim _ _
subst i
subst k
change A 0 0 * B 0 0 = (A * B) 0 0
simp [Matrix.mul_apply]
@[simp] theorem scalarAlgorithm_cost : scalarAlgorithm.cost = 1 := rfl
def AdmissibleExponent (τ : ℝ) : Prop :=
∀ ε : ℝ, 0 < ε → ∃ C : ℝ, 0 < C ∧
∀ n : ℕ, 1 ≤ n → ∃ P : MatrixAlgorithm n,
P.Correct ∧ (P.cost : ℝ) ≤ C * (n : ℝ) ^ (τ + ε)
noncomputable def omega : ℝ := sInf {τ : ℝ | AdmissibleExponent τ}
end Arithmetic
namespace Tensor
def matrixMultiplication (a b c : ℕ) :
Tensor ℂ (Fin a × Fin b) (Fin b × Fin c) (Fin c × Fin a) :=
fun x y z => if x.2 = y.1 ∧ y.2 = z.1 ∧ z.2 = x.1 then 1 else 0
@[simp] theorem matrixMultiplication_matching (a b c : ℕ)
(i : Fin a) (j : Fin b) (k : Fin c) :
matrixMultiplication a b c (i, j) (j, k) (k, i) = 1 := by
simp [matrixMultiplication]
end Tensor
end MatrixMultiplication.Foundation
end
end OAI
|