File size: 3,650 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 | import OAI.LinearAlgebra.MatrixMultiplication.Model
import OAI.LinearAlgebra.MatrixMultiplication.ComplexArithmetic.Complexity
import Mathlib.Algebra.Order.Floor.Semiring
namespace OAI
/-! Division-free arithmetic programs over a field and their operation counts. -/
noncomputable section
open scoped BigOperators
namespace MatrixMultiplication.Arithmetic
namespace Gate
variable {F Input Register : Type*}
end Gate
namespace Program
variable {F Input : Type*}
@[simp] theorem eval_step_zero [Field F] {r : ℕ} (p : Program F Input r)
(g : Gate F Input (Fin r)) (inputs : Input → F) :
(p.step g).eval inputs 0 = g.eval inputs (p.eval inputs) := rfl
@[simp] theorem eval_step_succ [Field F] {r : ℕ} (p : Program F Input r)
(g : Gate F Input (Fin r)) (inputs : Input → F) (i : Fin r) :
(p.step g).eval inputs i.succ = p.eval inputs i := rfl
@[simp] theorem cost_step {r : ℕ} (p : Program F Input r)
(g : Gate F Input (Fin r)) : (p.step g).cost = p.cost + g.cost := rfl
end Program
namespace MatrixAlgorithm
variable {F : Type*} [Field F] {a b c : ℕ}
theorem correct_iff_entries (P : MatrixAlgorithm F a b c) :
P.Correct ↔ ∀ (A : Matrix (Fin a) (Fin b) F) (B : Matrix (Fin b) (Fin c) F)
(i : Fin a) (k : Fin c),
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 (F : Type*) [Field F] : MatrixAlgorithm F 1 1 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 (F : Type*) [Field F] : (scalarAlgorithm F).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 (F : Type*) [Field F] : (scalarAlgorithm F).cost = 1 := rfl
theorem one_le_innerSize {n : ℕ} (hn : 1 ≤ n) (k : ℝ) : 1 ≤ innerSize n k := by
apply Nat.one_le_ceil_iff.mpr
exact Real.rpow_pos_of_pos (by exact_mod_cast (lt_of_lt_of_le Nat.zero_lt_one hn)) k
@[simp] theorem innerSize_zero (n : ℕ) : innerSize n 0 = 1 := by
simp [innerSize]
@[simp] theorem innerSize_one (n : ℕ) : innerSize n 1 = n := by
simp [innerSize]
theorem innerSize_mono {n : ℕ} (hn : 1 ≤ n) {k l : ℝ} (hkl : k ≤ l) :
innerSize n k ≤ innerSize n l := by
exact Nat.ceil_mono (Real.rpow_le_rpow_of_exponent_le (by exact_mod_cast hn) hkl)
theorem innerSize_le_pow {a b n t : ℕ} {k : ℝ} (hk : 0 ≤ k)
(hn : n ≤ a ^ t) (hab : (a : ℝ) ^ k ≤ b) : innerSize n k ≤ b ^ t := by
apply Nat.ceil_le.mpr
calc
(n : ℝ) ^ k ≤ ((a ^ t : ℕ) : ℝ) ^ k :=
Real.rpow_le_rpow (Nat.cast_nonneg n) (by exact_mod_cast hn) hk
_ = ((a : ℝ) ^ k) ^ t := by
rw [Nat.cast_pow, ← Real.rpow_pow_comm (Nat.cast_nonneg a)]
_ ≤ (b : ℝ) ^ t := pow_le_pow_left₀ (Real.rpow_nonneg (Nat.cast_nonneg a) k) hab t
_ = ((b ^ t : ℕ) : ℝ) := by rw [Nat.cast_pow]
theorem innerSize_cast_le {n : ℕ} (hn : 1 ≤ n) {k : ℝ} (hk : 0 ≤ k) :
(innerSize n k : ℝ) ≤ 2 * (n : ℝ) ^ k := by
have hpow : 1 ≤ (n : ℝ) ^ k := Real.one_le_rpow (by exact_mod_cast hn) hk
have hceil := (Nat.ceil_lt_add_one (Real.rpow_nonneg (Nat.cast_nonneg n) k)).le
change (⌈(n : ℝ) ^ k⌉₊ : ℝ) ≤ _
linarith
end MatrixMultiplication.Arithmetic
end
end OAI
|