File size: 2,962 Bytes
4a56cd6 | 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 | import Mathlib
namespace OAI
open scoped BigOperators Topology Polynomial
namespace MatrixAllFields
noncomputable section
open scoped BigOperators
namespace MatrixMultiplication.Arithmetic
inductive Gate (F Input Register : Type*) where
| constant : F β Gate F Input Register
| input : Input β Gate F Input Register
| add : Register β Register β Gate F Input Register
| sub : Register β Register β Gate F Input Register
| mul : Register β Register β Gate F Input Register
namespace Gate
variable {F Input Register : Type*}
def eval [Field F] (inputs : Input β F) (registers : Register β F) :
Gate F Input Register β F
| .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 F Input Register β β
| .constant _ => 0
| .input _ => 0
| .add _ _ => 1
| .sub _ _ => 1
| .mul _ _ => 1
end Gate
inductive Program (F Input : Type*) : β β Type _ where
| nil : Program F Input 0
| step {r : β} : Program F Input r β Gate F Input (Fin r) β Program F Input (r + 1)
namespace Program
variable {F Input : Type*}
def eval [Field F] : {r : β} β Program F Input r β (Input β F) β Fin r β F
| 0, .nil, _ => Fin.elim0
| _ + 1, .step p g, inputs =>
Fin.cases (g.eval inputs (p.eval inputs)) (p.eval inputs)
def cost : {r : β} β Program F Input r β β
| 0, .nil => 0
| _ + 1, .step p g => p.cost + g.cost
end Program
abbrev MatrixInput (a b c : β) := (Fin a Γ Fin b) β (Fin b Γ Fin c)
def matrixInputs {F : Type*} {a b c : β}
(A : Matrix (Fin a) (Fin b) F) (B : Matrix (Fin b) (Fin c) F) :
MatrixInput a b c β F
| .inl (i, j) => A i j
| .inr (j, k) => B j k
structure MatrixAlgorithm (F : Type*) (a b c : β) where
registers : β
program : Program F (MatrixInput a b c) registers
output : Fin a β Fin c β Fin registers
namespace MatrixAlgorithm
variable {F : Type*} [Field F] {a b c : β}
def eval (P : MatrixAlgorithm F a b c)
(A : Matrix (Fin a) (Fin b) F) (B : Matrix (Fin b) (Fin c) F) :
Matrix (Fin a) (Fin c) F :=
fun i k => P.program.eval (matrixInputs A B) (P.output i k)
def Correct (P : MatrixAlgorithm F a b c) : Prop :=
β (A : Matrix (Fin a) (Fin b) F) (B : Matrix (Fin b) (Fin c) F), P.eval A B = A * B
def cost (P : MatrixAlgorithm F a b c) : β := P.program.cost
end MatrixAlgorithm
/-- Positive slack, one uniform constant, and a correct program at every size. -/
def AdmissibleExponent (F : Type*) [Field F] (Ο : β) : Prop :=
β Ξ΅ : β, 0 < Ξ΅ β β C : β, 0 < C β§
β n : β, 1 β€ n β β P : MatrixAlgorithm F n n n,
P.Correct β§ (P.cost : β) β€ C * (n : β) ^ (Ο + Ξ΅)
def omega (F : Type*) [Field F] : β := sInf {Ο : β | AdmissibleExponent F Ο}
end MatrixMultiplication.Arithmetic
end
end MatrixAllFields
end OAI
|