File size: 12,005 Bytes
f18e7de | 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 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 | import OAI.LinearAlgebra.MatrixMultiplication.Rectangular.Recursion
import OAI.LinearAlgebra.MatrixMultiplication.Rectangular.Growth
import OAI.LinearAlgebra.MatrixMultiplication.Arithmetic.RecursiveBlockPrograms
import OAI.LinearAlgebra.MatrixMultiplication.Arithmetic.LowerBound
import OAI.LinearAlgebra.MatrixMultiplication.Tensor.FieldCoefficientExtraction
import OAI.LinearAlgebra.MatrixMultiplication.Rectangular.ComplexASI
namespace OAI
/-! Rectangular matrix multiplication algorithms and their asymptotic exponents. -/
noncomputable section
namespace MatrixMultiplication
open MatrixMultiplication.Foundation
namespace Arithmetic
variable {F : Type*} [Field F]
theorem rectangularAdmissibleExponent_of_rankAtMost
{a b R : ℕ} (ha : 2 ≤ a) {k τ : ℝ} (hk : 0 ≤ k)
(hab : (a : ℝ) ^ k ≤ (b : ℝ))
(hRank : MatrixMultiplication.Foundation.Tensor.RankAtMost
(MatrixMultiplication.Foundation.Tensor.matrixCoefficients (K := F) (Fin a) (Fin b) (Fin a)) R)
(hτ : 0 ≤ τ) (hR : (R : ℝ) ≤ (a : ℝ) ^ τ)
(hin : (a * b : ℕ) ≤ (a : ℝ) ^ τ)
(hout : (a : ℝ) ^ (2 : ℕ) ≤ (a : ℝ) ^ τ) :
RectangularAdmissibleExponent F k τ := by
apply rectangularAdmissibleExponent_of_block_step
(K := 2 * R * (2 * (a * b) + a ^ 2)) ha hk hab hτ hR hin hout
· exact ⟨scalarAlgorithm F, scalarAlgorithm_correct F, (scalarAlgorithm_cost F).le⟩
· intro m p P hP
obtain ⟨Q, hQ, hcost⟩ := RecursiveBlock.rank_block_step hRank P hP
refine ⟨Q, hQ, ?_⟩
rw [hcost]
nlinarith [Nat.zero_le (2 * R * (2 * (a * b) * m ^ 2 + a ^ 2 * (m * p)))]
theorem rectangular_rpow_omega_le_of_rankAtMost
{a b R : ℕ} {B k : ℝ} (ha : 2 ≤ a) (hk : 0 ≤ k)
(hab : (a : ℝ) ^ k ≤ (b : ℝ))
(hRank : MatrixMultiplication.Foundation.Tensor.RankAtMost
(MatrixMultiplication.Foundation.Tensor.matrixCoefficients (K := F) (Fin a) (Fin b) (Fin a)) R)
(hout : (a : ℝ) ^ (2 : ℕ) ≤ B) (hin : (a * b : ℕ) ≤ B)
(hR : (R : ℝ) ≤ B) :
(a : ℝ) ^ rectangularOmega F k ≤ B := by
have ha1 : 1 < (a : ℝ) := by exact_mod_cast (by omega : 1 < a)
have ha0 : 0 < (a : ℝ) := lt_trans zero_lt_one ha1
have hB : 0 < B := (sq_pos_of_pos ha0).trans_le hout
have hpow : (a : ℝ) ^ Real.logb a B = B :=
Real.rpow_logb ha0 (ne_of_gt ha1) hB
have hτ : 2 ≤ Real.logb (a : ℝ) B := by
apply (Real.le_logb_iff_rpow_le ha1 hB).mpr
simpa only [Real.rpow_two] using hout
have hadm := rectangularAdmissibleExponent_of_rankAtMost ha hk hab hRank
(by linarith : 0 ≤ Real.logb (a : ℝ) B)
(hR.trans_eq hpow.symm) (hin.trans_eq hpow.symm) (hout.trans_eq hpow.symm)
exact (Real.rpow_le_rpow_of_exponent_le ha1.le
(rectangularOmega_le_of_admissibleExponent hadm)).trans_eq hpow
theorem rectangular_rpow_omega_le_of_rank_growth
{a b : ℕ} {q C k : ℝ} (ha : 2 ≤ a) (hk : 0 ≤ k)
(hab : (a : ℝ) ^ k ≤ (b : ℝ))
(hout : (a : ℝ) ^ (2 : ℕ) ≤ q) (hin : (a * b : ℕ) ≤ q)
(R : ℕ → ℕ)
(hRank : ∀ t, MatrixMultiplication.Foundation.Tensor.RankAtMost
(MatrixMultiplication.Foundation.Tensor.matrixCoefficients (K := F)
(Fin (a ^ t)) (Fin (b ^ t)) (Fin (a ^ t))) (R t))
(hcost : ∀ t, (R t : ℝ) ≤ C * q ^ t) :
(a : ℝ) ^ rectangularOmega F k ≤ q := by
have ha0 : 0 ≤ (a : ℝ) := Nat.cast_nonneg a
have hq0 : 0 ≤ q := (sq_nonneg (a : ℝ)).trans hout
apply power_le_of_forall_pow_le_mul_pow hq0 (C := max 1 C)
intro t ht
have hat : 2 ≤ a ^ t := ha.trans (le_self_pow (by omega) (Nat.ne_of_gt ht))
have habt : ((a ^ t : ℕ) : ℝ) ^ k ≤ ((b ^ t : ℕ) : ℝ) := by
rw [Nat.cast_pow, Nat.cast_pow, ← Real.rpow_pow_comm ha0]
exact pow_le_pow_left₀ (Real.rpow_nonneg (Nat.cast_nonneg a) k) hab t
have hbase : ((a ^ t : ℕ) : ℝ) ^ (2 : ℕ) ≤ max 1 C * q ^ t := by
calc
((a ^ t : ℕ) : ℝ) ^ (2 : ℕ) = ((a : ℝ) ^ (2 : ℕ)) ^ t := by
rw [Nat.cast_pow, ← pow_mul, ← pow_mul, Nat.mul_comm t 2]
_ ≤ q ^ t := by gcongr
_ ≤ max 1 C * q ^ t := by
simpa only [one_mul] using
mul_le_mul_of_nonneg_right (le_max_left (1 : ℝ) C) (pow_nonneg hq0 t)
have hinput : ((a ^ t * b ^ t : ℕ) : ℝ) ≤ max 1 C * q ^ t := by
calc
((a ^ t * b ^ t : ℕ) : ℝ) = (((a * b : ℕ) : ℝ)) ^ t := by
simp only [Nat.cast_mul, Nat.cast_pow, mul_pow]
_ ≤ q ^ t := pow_le_pow_left₀ (Nat.cast_nonneg _) hin t
_ ≤ max 1 C * q ^ t := by
simpa only [one_mul] using
mul_le_mul_of_nonneg_right (le_max_left (1 : ℝ) C) (pow_nonneg hq0 t)
have hcost' : (R t : ℝ) ≤ max 1 C * q ^ t :=
(hcost t).trans (mul_le_mul_of_nonneg_right (le_max_right (1 : ℝ) C)
(pow_nonneg hq0 t))
have h := rectangular_rpow_omega_le_of_rankAtMost hat hk habt
(hRank t) hbase hinput hcost'
simpa only [Nat.cast_pow, ← Real.rpow_pow_comm ha0] using h
theorem equalRectangular_inequality {a b L r : ℕ} {k : ℝ}
(ha : 2 ≤ a) (hk : 0 ≤ k) (hab : (a : ℝ) ^ k ≤ (b : ℝ))
(hbatch : MatrixMultiplication.Foundation.Tensor.RankAtMost
(MatrixMultiplication.Foundation.Tensor.directSum (fun _ : Fin L =>
MatrixMultiplication.Foundation.Tensor.matrixCoefficients (K := F)
(Fin a) (Fin b) (Fin a))) r) :
(L : ℝ) * (a : ℝ) ^ rectangularOmega F k ≤ (r : ℝ) := by
by_cases hL0 : L = 0
· subst L
simp
have hL : 0 < L := Nat.pos_of_ne_zero hL0
have ha0 : 0 < a := by omega
have hb0 : 0 < b := by
have hbR : (0 : ℝ) < (b : ℝ) :=
(Real.rpow_pos_of_pos (by exact_mod_cast ha0) k).trans_le hab
exact_mod_cast hbR
have hlower := Tensor.rectangular_directSum_rank_lower ha0 hb0 hbatch
have hLR : 0 < (L : ℝ) := by exact_mod_cast hL
have hout : (a : ℝ) ^ (2 : ℕ) ≤ (r : ℝ) / (L : ℝ) := by
apply (le_div_iff₀ hLR).mpr
have hh : (L : ℝ) * (a : ℝ) ^ (2 : ℕ) ≤ (r : ℝ) := by exact_mod_cast hlower.1
simpa only [mul_comm] using hh
have hin : ((a * b : ℕ) : ℝ) ≤ (r : ℝ) / (L : ℝ) := by
apply (le_div_iff₀ hLR).mpr
have hh : (L : ℝ) * ((a * b : ℕ) : ℝ) ≤ (r : ℝ) := by exact_mod_cast hlower.2
simpa only [mul_comm] using hh
have haR : (2 : ℝ) ≤ a := by exact_mod_cast ha
have hq : 1 < (r : ℝ) / (L : ℝ) := by nlinarith
have hcost := affine_recurrence_bound (fun t => (batchRank L r t : ℝ))
((r : ℝ) / (L : ℝ)) (r : ℝ) hq (Nat.cast_nonneg r)
(fun t => batchRank_succ_le_affine hL r t)
have hbound : (a : ℝ) ^ rectangularOmega F k ≤ (r : ℝ) / (L : ℝ) := by
apply rectangular_rpow_omega_le_of_rank_growth
(C := (batchRank L r 0 : ℝ) + (r : ℝ) / ((r : ℝ) / (L : ℝ) - 1))
ha hk hab hout hin (batchRank L r)
· exact Tensor.rectangular_pow_batchRank hL hbatch
· intro t
exact (hcost t).trans_eq (mul_comm _ _)
simpa only [mul_comm] using (le_div_iff₀ hLR).mp hbound
theorem power_le_of_forall_pow_le_square_linear_mul_pow (d : ℕ) {x r : ℝ}
(hr : 0 ≤ r)
(h : ∀ n : ℕ, 0 < n → x ^ n ≤ ((d * n + 1 : ℕ) : ℝ) ^ 2 * r ^ n) :
x ≤ r := by
apply power_le_of_forall_pow_le_linear_mul_pow (2 * d) hr
intro n hn
apply le_of_pow_le_pow_left₀ (by decide : (2 : ℕ) ≠ 0)
(mul_nonneg (Nat.cast_nonneg _) (pow_nonneg hr n))
have he := h (n * 2) (Nat.mul_pos hn (by decide))
have hcount : d * (n * 2) + 1 = 2 * d * n + 1 := by ring
simpa only [pow_mul, hcount, mul_pow] using he
theorem equalRectangular_inequality_of_polynomialApproximation
{a b L r d D : ℕ} {k : ℝ}
(ha : 2 ≤ a) (hk : 0 ≤ k) (hab : (a : ℝ) ^ k ≤ (b : ℝ))
(P : MatrixMultiplication.Foundation.Tensor.PolynomialApproximation
(MatrixMultiplication.Foundation.Tensor.directSum (fun _ : Fin L =>
MatrixMultiplication.Foundation.Tensor.matrixCoefficients (K := F)
(Fin a) (Fin b) (Fin a))) r d D) :
(L : ℝ) * (a : ℝ) ^ rectangularOmega F k ≤ (r : ℝ) := by
apply power_le_of_forall_pow_le_square_linear_mul_pow d (Nat.cast_nonneg r)
intro t ht
have hat : 2 ≤ a ^ t := ha.trans (le_self_pow (by omega) (Nat.ne_of_gt ht))
have habt : ((a ^ t : ℕ) : ℝ) ^ k ≤ ((b ^ t : ℕ) : ℝ) := by
rw [Nat.cast_pow, Nat.cast_pow, ← Real.rpow_pow_comm (Nat.cast_nonneg a)]
exact pow_le_pow_left₀ (Real.rpow_nonneg (Nat.cast_nonneg a) k) hab t
have h := equalRectangular_inequality hat hk habt
(Tensor.rectangular_directSum_power_rank (FieldCoefficientExtraction.rank_power P t))
simpa only [Nat.cast_pow, Nat.cast_mul, mul_pow,
← Real.rpow_pow_comm (Nat.cast_nonneg a)] using h
theorem equalRectangular_log_inequality_of_polynomialApproximation
{a b L r d D : ℕ} {k : ℝ}
(ha : 2 ≤ a) (hL : 0 < L) (hk : 0 ≤ k)
(hab : (a : ℝ) ^ k ≤ (b : ℝ))
(P : MatrixMultiplication.Foundation.Tensor.PolynomialApproximation
(MatrixMultiplication.Foundation.Tensor.directSum (fun _ : Fin L =>
MatrixMultiplication.Foundation.Tensor.matrixCoefficients (K := F)
(Fin a) (Fin b) (Fin a))) r d D) :
rectangularOmega F k * Real.log (a : ℝ) ≤ Real.log (r : ℝ) - Real.log (L : ℝ) := by
have ha0 : (0 : ℝ) < a := by exact_mod_cast (by omega : 0 < a)
have hL0 : (0 : ℝ) < L := by exact_mod_cast hL
have hpow := Real.rpow_pos_of_pos ha0 (rectangularOmega F k)
have hbound := equalRectangular_inequality_of_polynomialApproximation ha hk hab P
have hlog := Real.log_le_log (mul_pos hL0 hpow) hbound
rw [Real.log_mul (ne_of_gt hL0) (ne_of_gt hpow), Real.log_rpow ha0] at hlog
linarith
theorem equalSquare_inequality_of_polynomialApproximation
{n L r d D : ℕ} (hn : 1 ≤ n)
(P : MatrixMultiplication.Foundation.Tensor.PolynomialApproximation
(MatrixMultiplication.Foundation.Tensor.directSum (fun _ : Fin L =>
MatrixMultiplication.Foundation.Tensor.matrixCoefficients (K := F)
(Fin n) (Fin n) (Fin n))) r d D) :
(L : ℝ) * (n : ℝ) ^ omega F ≤ (r : ℝ) := by
by_cases hn1 : n = 1
· subst n
simp only [Nat.cast_one, Real.one_rpow, mul_one]
apply power_le_of_forall_pow_le_square_linear_mul_pow d (Nat.cast_nonneg r)
intro t ht
have hrank := Tensor.rectangular_directSum_power_rank
(FieldCoefficientExtraction.rank_power P t)
have hlower := MatrixMultiplication.Foundation.Tensor.directSum_square_rank_lower
(L ^ t) (1 ^ t) ((d * t + 1) ^ 2 * r ^ t) (by simp) hrank
have hcast := (Nat.cast_le (α := ℝ)).mpr hlower
simpa only [one_pow, mul_one, Nat.cast_mul, Nat.cast_pow] using hcast
· have h := equalRectangular_inequality_of_polynomialApproximation
(by omega : 2 ≤ n) (by norm_num : (0 : ℝ) ≤ 1)
(by simp : (n : ℝ) ^ (1 : ℝ) ≤ (n : ℝ)) P
simpa only [rectangularOmega_one] using h
theorem equalVolume_inequality_of_polynomialApproximation
{a b c L r d D : ℕ} (ha : 1 ≤ a) (hb : 1 ≤ b) (hc : 1 ≤ c)
(P : MatrixMultiplication.Foundation.Tensor.PolynomialApproximation
(MatrixMultiplication.Foundation.Tensor.directSum (fun _ : Fin L =>
MatrixMultiplication.Foundation.Tensor.matrixCoefficients (K := F)
(Fin a) (Fin b) (Fin c))) r d D) :
(L : ℝ) * ((a * b * c : ℕ) : ℝ) ^ (omega F / 3) ≤ (r : ℝ) := by
let tags : Fin (L ^ 3) ≃ (Fin L × Fin L) × Fin L :=
Fintype.equivOfCardEq (by simp [pow_succ])
let indices : Fin (a * b * c) ≃ Fin a × Fin b × Fin c :=
Fintype.equivOfCardEq (by simp [mul_assoc])
have Q := P.matrixCoefficients_directSum_symmetrized.matrixCoefficients_directSum_of_injective
tags tags.injective indices indices.injective
have h := equalSquare_inequality_of_polynomialApproximation
(Nat.mul_pos (Nat.mul_pos ha hb) hc) Q
apply mul_rpow_third_le_of_cube (Nat.cast_nonneg (a * b * c)) (Nat.cast_nonneg r)
simpa only [Nat.cast_pow] using h
end Arithmetic
end MatrixMultiplication
end
end OAI
|