Download data/lean/OAI/LinearAlgebra/MatrixFields/Construction/ComplexRectangularASI.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 41.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixFields/Construction/ComplexRectangularASI.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/LinearAlgebra/MatrixFields/Construction/ComplexRectangularASI.lean
-
curl -L -o ComplexRectangularASI.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/LinearAlgebra/MatrixFields/Construction/ComplexRectangularASI.lean
41.1 kB
| import Mathlib | |
| import OAI.LinearAlgebra.MatrixFields.Arithmetic.ComplexArithmeticExponent | |
| import OAI.LinearAlgebra.MatrixFields.Arithmetic.ComplexArithmeticGrowth | |
| import OAI.LinearAlgebra.MatrixFields.Entropy.ComplexAsymptoticRecurrence | |
| import OAI.LinearAlgebra.MatrixFields.Entropy.ComplexPolynomialPowerGrowth | |
| namespace OAI | |
| namespace MatrixAllFields | |
| open scoped BigOperators Topology Polynomial | |
| section | |
| noncomputable section | |
| open scoped BigOperators | |
| namespace MatrixMultiplication.Foundation | |
| namespace Tensor | |
| variable {F X Y Z : Type*} [Field F] | |
| theorem coeff_eq_sum_eval {ΞΉ : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ] | |
| (nodes : ΞΉ β F) (hnodes : Function.Injective nodes) | |
| (p : Polynomial F) (d : β) (hdegree : p.degree < Fintype.card ΞΉ) : | |
| p.coeff d = β i, p.eval (nodes i) * | |
| (Lagrange.basis Finset.univ nodes i).coeff d := by | |
| have hinj : Set.InjOn nodes (β(Finset.univ : Finset ΞΉ)) := hnodes.injOn | |
| have hinterp := Lagrange.eq_interpolate hinj (by simpa using hdegree) | |
| (f := p) | |
| calc | |
| p.coeff d = (Lagrange.interpolate Finset.univ nodes | |
| (fun i => p.eval (nodes i))).coeff d := congrArg (fun q => q.coeff d) hinterp | |
| _ = _ := by | |
| simp only [Lagrange.interpolate_apply, Polynomial.finsetSum_coeff, | |
| Polynomial.coeff_C_mul] | |
| theorem RankAtMost.coeff {ΞΉ : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ] | |
| (nodes : ΞΉ β F) (hnodes : Function.Injective nodes) | |
| {P : Tensor (Polynomial F) X Y Z} {r : β} (hP : RankAtMost P r) | |
| (d : β) (hdegree : β x y z, (P x y z).degree < Fintype.card ΞΉ) : | |
| RankAtMost (fun x y z => (P x y z).coeff d) (Fintype.card ΞΉ * r) := by | |
| rcases hP with β¨a, b, c, rflβ© | |
| let w : ΞΉ β F := fun i => (Lagrange.basis Finset.univ nodes i).coeff d | |
| let aa : (ΞΉ Γ Fin r) β X β F := fun i x => w i.1 * (a i.2 x).eval (nodes i.1) | |
| let bb : (ΞΉ Γ Fin r) β Y β F := fun i y => (b i.2 y).eval (nodes i.1) | |
| let cc : (ΞΉ Γ Fin r) β Z β F := fun i z => (c i.2 z).eval (nodes i.1) | |
| have heq : (fun x y z => (β j, rankOne (a j) (b j) (c j) x y z).coeff d) = | |
| fun x y z => β i, rankOne (aa i) (bb i) (cc i) x y z := by | |
| funext x y z | |
| rw [coeff_eq_sum_eval nodes hnodes _ d (hdegree x y z)] | |
| simp only [Fintype.sum_prod_type, rankOne, Polynomial.eval_finsetSum, | |
| Polynomial.eval_mul, Finset.sum_mul] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| apply Finset.sum_congr rfl | |
| intro j hj | |
| dsimp [aa, bb, cc, w] | |
| ring | |
| rw [heq] | |
| simpa only [Fintype.card_prod, Fintype.card_fin] using rankAtMost_sum_rankOne aa bb cc | |
| structure PolynomialApproximation (T : Tensor F X Y Z) (r d D : β) where | |
| polynomial : Tensor (Polynomial F) X Y Z | |
| rank_bound : RankAtMost polynomial r | |
| vanishes : β x y z k, k < d β (polynomial x y z).coeff k = 0 | |
| leading : β x y z, (polynomial x y z).coeff d = T x y z | |
| degree_bound : β x y z, (polynomial x y z).degree β€ D | |
| namespace PolynomialApproximation | |
| variable {T : Tensor F X Y Z} {r d D : β} | |
| def normalized (A : PolynomialApproximation T r d D) : | |
| Tensor (Polynomial F) X Y Z := | |
| fun x y z => Classical.choose (Polynomial.X_pow_dvd_iff.mpr (A.vanishes x y z)) | |
| theorem polynomial_eq (A : PolynomialApproximation T r d D) (x : X) (y : Y) (z : Z) : | |
| A.polynomial x y z = Polynomial.X ^ d * A.normalized x y z := | |
| Classical.choose_spec (Polynomial.X_pow_dvd_iff.mpr (A.vanishes x y z)) | |
| theorem normalized_constant (A : PolynomialApproximation T r d D) | |
| (x : X) (y : Y) (z : Z) : (A.normalized x y z).coeff 0 = T x y z := by | |
| have h := A.leading x y z | |
| rw [A.polynomial_eq] at h | |
| simpa only [Polynomial.coeff_X_pow_mul', le_refl, ite_true, Nat.sub_self] using h | |
| theorem power_polynomial_eq (A : PolynomialApproximation T r d D) (n : β) | |
| (x : Fin n β X) (y : Fin n β Y) (z : Fin n β Z) : | |
| Tensor.power A.polynomial n x y z = | |
| Polynomial.X ^ (d * n) * Tensor.power A.normalized n x y z := by | |
| simp [Tensor.power, A.polynomial_eq, Finset.prod_mul_distrib, β pow_mul] | |
| def power (A : PolynomialApproximation T r d D) (n : β) : | |
| PolynomialApproximation (Tensor.power T n) (r ^ n) (d * n) (D * n) where | |
| polynomial := Tensor.power A.polynomial n | |
| rank_bound := A.rank_bound.power n | |
| vanishes := by | |
| intro x y z k hk | |
| rw [A.power_polynomial_eq] | |
| simp only [Polynomial.coeff_X_pow_mul', Nat.not_le_of_lt hk, ite_false] | |
| leading := by | |
| intro x y z | |
| rw [A.power_polynomial_eq] | |
| simp only [Polynomial.coeff_X_pow_mul', le_refl, ite_true, Nat.sub_self, | |
| Tensor.power, Polynomial.coeff_zero_prod, A.normalized_constant] | |
| degree_bound := by | |
| intro x y z | |
| apply Polynomial.degree_le_of_natDegree_le | |
| calc | |
| (Tensor.power A.polynomial n x y z).natDegree β€ | |
| β i, (A.polynomial (x i) (y i) (z i)).natDegree := | |
| Polynomial.natDegree_prod_le _ _ | |
| _ β€ β _i : Fin n, D := by | |
| apply Finset.sum_le_sum | |
| intro i hi | |
| exact Polynomial.natDegree_le_of_degree_le (A.degree_bound (x i) (y i) (z i)) | |
| _ = D * n := by simp [Nat.mul_comm] | |
| theorem rank_power [CharZero F] (A : PolynomialApproximation T r d D) (n : β) : | |
| RankAtMost (Tensor.power T n) ((D * n + 1) * r ^ n) := by | |
| let nodes : Fin (D * n + 1) β F := fun i => (i.val : F) | |
| have hinj : Function.Injective nodes := by | |
| intro i j h | |
| apply Fin.ext | |
| exact Nat.cast_injective h | |
| have hdegree (x : Fin n β X) (y : Fin n β Y) (z : Fin n β Z) : | |
| ((A.power n).polynomial x y z).degree < Fintype.card (Fin (D * n + 1)) := by | |
| simp only [Fintype.card_fin] | |
| exact lt_of_le_of_lt ((A.power n).degree_bound x y z) | |
| (WithBot.coe_lt_coe.mpr (Nat.lt_succ_self (D * n))) | |
| have h := (A.power n).rank_bound.coeff nodes hinj (d * n) hdegree | |
| have heq : (fun x y z => ((A.power n).polynomial x y z).coeff (d * n)) = | |
| Tensor.power T n := by | |
| funext x y z | |
| exact (A.power n).leading x y z | |
| rw [heq, Fintype.card_fin] at h | |
| exact h | |
| theorem rank_normalized_eval (A : PolynomialApproximation T r d D) | |
| (t : F) (ht : t β 0) : | |
| RankAtMost (fun x y z => (A.normalized x y z).eval t) r := by | |
| have h := (A.rank_bound.map (Polynomial.evalRingHom t)).scale ((t ^ d)β»ΒΉ) | |
| change RankAtMost (fun x y z => (t ^ d)β»ΒΉ * (A.polynomial x y z).eval t) r at h | |
| have heq : (fun x y z => (t ^ d)β»ΒΉ * (A.polynomial x y z).eval t) = | |
| fun x y z => (A.normalized x y z).eval t := by | |
| funext x y z | |
| rw [A.polynomial_eq, Polynomial.eval_mul, Polynomial.eval_pow, Polynomial.eval_X] | |
| rw [β mul_assoc, inv_mul_cancelβ (pow_ne_zero d ht), one_mul] | |
| rw [heq] at h | |
| exact h | |
| theorem borderRankAtMost [Fintype X] [Fintype Y] [Fintype Z] | |
| {S : Tensor β X Y Z} (A : PolynomialApproximation S r d D) : | |
| BorderRankAtMost S r := by | |
| let f : β β Tensor β X Y Z := fun t x y z => (A.normalized x y z).eval t | |
| have hf : Continuous f := by | |
| apply continuous_pi | |
| intro x | |
| apply continuous_pi | |
| intro y | |
| apply continuous_pi | |
| intro z | |
| exact (A.normalized x y z).continuous | |
| have hclosed : IsClosed {t : β | BorderRankAtMost (f t) r} := | |
| isClosed_closure.preimage hf | |
| have hsubset : ({0}αΆ : Set β) β {t : β | BorderRankAtMost (f t) r} := by | |
| intro t ht | |
| exact (A.rank_normalized_eval t (by simpa using ht)).borderRankAtMost | |
| have hz := closure_minimal hsubset hclosed ((dense_compl_singleton (0 : β)) 0) | |
| have heq : f 0 = S := by | |
| funext x y z | |
| simp only [f, β Polynomial.coeff_zero_eq_eval_zero, A.normalized_constant] | |
| change BorderRankAtMost (f 0) r at hz | |
| rw [heq] at hz | |
| exact hz | |
| end PolynomialApproximation | |
| end Tensor | |
| end MatrixMultiplication.Foundation | |
| end | |
| end | |
| end MatrixAllFields | |
| namespace MatrixAllFields | |
| open scoped BigOperators Topology Polynomial | |
| section | |
| namespace MatrixMultiplication.Foundation | |
| def batchCount (R k : β) : β := (R + k - 1) / k | |
| @[simp] theorem batchCount_zero (k : β) : batchCount 0 k = 0 := by | |
| unfold batchCount | |
| by_cases hk : k = 0 | |
| Β· simp [hk] | |
| Β· apply Nat.div_eq_of_lt | |
| omega | |
| theorem le_batchCount_mul (R : β) {k : β} (hk : 0 < k) : | |
| R β€ batchCount R k * k := by | |
| have hdiv := Nat.div_add_mod (R + k - 1) k | |
| have hmod := Nat.mod_lt (R + k - 1) hk | |
| rw [Nat.mul_comm k ((R + k - 1) / k)] at hdiv | |
| unfold batchCount | |
| omega | |
| theorem batchCount_le_iff {R k B : β} (hk : 0 < k) : | |
| batchCount R k β€ B β R β€ B * k := by | |
| unfold batchCount | |
| rw [Nat.div_le_iff_le_mul hk] | |
| omega | |
| theorem batchCount_mul_lt (R : β) {k : β} (hk : 0 < k) : | |
| batchCount R k * k < R + k := by | |
| have hmul := Nat.div_mul_le_self (R + k - 1) k | |
| unfold batchCount | |
| omega | |
| theorem batchCount_pos_iff {R k : β} (hk : 0 < k) : | |
| 0 < batchCount R k β 0 < R := by | |
| have hzero := batchCount_le_iff (R := R) (B := 0) hk | |
| simp only [Nat.zero_mul] at hzero | |
| omega | |
| theorem batchCount_cast_lt (R : β) {k : β} (hk : 0 < k) : | |
| (batchCount R k : β) < (R : β) / (k : β) + 1 := by | |
| have hkR : (0 : β) < (k : β) := Nat.cast_pos.mpr hk | |
| have hmul : (batchCount R k : β) * (k : β) < (R : β) + (k : β) := by | |
| simpa only [Nat.cast_mul, Nat.cast_add] using | |
| (Nat.cast_lt (Ξ± := β)).mpr (batchCount_mul_lt R hk) | |
| calc | |
| (batchCount R k : β) < ((R : β) + (k : β)) / (k : β) := | |
| (lt_div_iffβ hkR).mpr hmul | |
| _ = (R : β) / (k : β) + 1 := by rw [add_div, div_self (ne_of_gt hkR)] | |
| theorem batchCount_cast_le (R : β) {k : β} (hk : 0 < k) : | |
| (batchCount R k : β) β€ (R : β) / (k : β) + 1 := | |
| (batchCount_cast_lt R hk).le | |
| theorem batchCount_mul_cast_le (R r : β) {k : β} (hk : 0 < k) : | |
| ((batchCount R k * r : β) : β) β€ | |
| (r : β) / (k : β) * (R : β) + (r : β) := by | |
| calc | |
| ((batchCount R k * r : β) : β) = (batchCount R k : β) * (r : β) := by | |
| rw [Nat.cast_mul] | |
| _ β€ ((R : β) / (k : β) + 1) * (r : β) := | |
| mul_le_mul_of_nonneg_right (batchCount_cast_le R hk) (Nat.cast_nonneg r) | |
| _ = (r : β) / (k : β) * (R : β) + (r : β) := by | |
| simp only [div_eq_mul_inv] | |
| ring | |
| def batchRank (k r : β) : β β β | |
| | 0 => 1 | |
| | t + 1 => batchCount (batchRank k r t) k * r | |
| @[simp] theorem batchRank_zero (k r : β) : batchRank k r 0 = 1 := rfl | |
| @[simp] theorem batchRank_succ (k r t : β) : | |
| batchRank k r (t + 1) = batchCount (batchRank k r t) k * r := rfl | |
| theorem batchRank_succ_le_affine {k : β} (hk : 0 < k) (r t : β) : | |
| (batchRank k r (t + 1) : β) β€ | |
| (r : β) / (k : β) * (batchRank k r t : β) + (r : β) := by | |
| rw [batchRank_succ] | |
| exact batchCount_mul_cast_le (batchRank k r t) r hk | |
| theorem batchRank_pos {k r : β} (hk : 0 < k) (hr : 0 < r) : | |
| β t, 0 < batchRank k r t := by | |
| intro t | |
| induction t with | |
| | zero => simp | |
| | succ t ih => | |
| rw [batchRank_succ] | |
| exact Nat.mul_pos ((batchCount_pos_iff hk).mpr ih) hr | |
| namespace Tensor | |
| variable {K X Y Z U V W A B : Type*} [CommSemiring K] | |
| theorem RankAtMost.repeat_batch_ceiling {S : Tensor K U V W} {k r R : β} | |
| (hbatch : RankAtMost (directSum (fun _ : Fin k => S)) r) (hk : 0 < k) : | |
| RankAtMost (directSum (fun _ : Fin R => S)) (batchCount R k * r) := | |
| hbatch.repeat_batch (le_batchCount_mul R hk) | |
| theorem RankAtMost.batch_product_ceiling [Fintype U] [Fintype V] [Fintype W] | |
| {T : Tensor K X Y Z} {S : Tensor K U V W} {R k r : β} | |
| (hT : RankAtMost T R) | |
| (hbatch : RankAtMost (directSum (fun _ : Fin k => S)) r) (hk : 0 < k) : | |
| RankAtMost (Tensor.product T S) (batchCount R k * r) := | |
| hT.batch_product hbatch (le_batchCount_mul R hk) | |
| theorem matrixCoefficients_batch_rank_ceiling [DecidableEq A] [DecidableEq B] [Fintype B] | |
| {R k r : β} | |
| (houter : RankAtMost (matrixCoefficients (K := K) A A A) R) | |
| (hbatch : RankAtMost (directSum (fun _ : Fin k => matrixCoefficients (K := K) B B B)) r) | |
| (hk : 0 < k) : | |
| RankAtMost (matrixCoefficients (K := K) (A Γ B) (A Γ B) (A Γ B)) | |
| (batchCount R k * r) := | |
| matrixCoefficients_batch_rank houter hbatch (le_batchCount_mul R hk) | |
| end Tensor | |
| end MatrixMultiplication.Foundation | |
| end | |
| end MatrixAllFields | |
| namespace MatrixAllFields | |
| open scoped BigOperators Topology Polynomial | |
| section | |
| noncomputable section | |
| namespace MatrixMultiplication.Foundation | |
| namespace Tensor | |
| theorem matrixCoefficients_rank_of_injective {K A B : Type*} [CommSemiring K] | |
| [DecidableEq A] [DecidableEq B] {R : β} | |
| (h : RankAtMost (matrixCoefficients (K := K) A A A) R) | |
| (f : B β A) (hf : Function.Injective f) : | |
| RankAtMost (matrixCoefficients (K := K) B B B) R := by | |
| have hp := h.pullback (fun x : B Γ B => (f x.1, f x.2)) | |
| (fun y : B Γ B => (f y.1, f y.2)) | |
| (fun z : B Γ B => (f z.1, f z.2)) | |
| convert hp using 1 | |
| funext x y z | |
| simp only [pullback, matrixCoefficients, hf.eq_iff] | |
| theorem matrixCoefficients_directSum_rank_of_injective | |
| {K ΞΉ ΞΊ A B : Type*} [CommSemiring K] | |
| [DecidableEq ΞΉ] [DecidableEq ΞΊ] [DecidableEq A] [DecidableEq B] {R : β} | |
| (h : RankAtMost (directSum (fun _ : ΞΉ => matrixCoefficients (K := K) A A A)) R) | |
| (f : ΞΊ β ΞΉ) (hf : Function.Injective f) (g : B β A) (hg : Function.Injective g) : | |
| RankAtMost (directSum (fun _ : ΞΊ => matrixCoefficients (K := K) B B B)) R := by | |
| have hp := h.pullback | |
| (fun x : ΞΊ Γ (B Γ B) => (f x.1, (g x.2.1, g x.2.2))) | |
| (fun y : ΞΊ Γ (B Γ B) => (f y.1, (g y.2.1, g y.2.2))) | |
| (fun z : ΞΊ Γ (B Γ B) => (f z.1, (g z.2.1, g z.2.2))) | |
| convert hp using 1 | |
| funext x y z | |
| simp only [pullback, directSum, matrixCoefficients, hf.eq_iff, hg.eq_iff] | |
| theorem matrixCoefficients_directSum_power_rank {K : Type*} [CommSemiring K] | |
| {n k R t : β} | |
| (h : RankAtMost (power (directSum | |
| (fun _ : Fin k => matrixCoefficients (K := K) (Fin n) (Fin n) (Fin n))) t) R) : | |
| RankAtMost (directSum (fun _ : Fin (k ^ t) => | |
| matrixCoefficients (K := K) (Fin (n ^ t)) (Fin (n ^ t)) (Fin (n ^ t)))) R := by | |
| have hmatrix := matrixCoefficients_directSum_rank_of_power h | |
| let tags : Fin (k ^ t) β (Fin t β Fin k) := Fintype.equivOfCardEq (by simp) | |
| let indices : Fin (n ^ t) β (Fin t β Fin n) := Fintype.equivOfCardEq (by simp) | |
| exact matrixCoefficients_directSum_rank_of_injective hmatrix | |
| tags tags.injective indices indices.injective | |
| theorem PolynomialApproximation.square_directSum_power_rank | |
| {n k r d D : β} | |
| (A : PolynomialApproximation | |
| (directSum (fun _ : Fin k => matrixMultiplication n n n)) r d D) (t : β) : | |
| RankAtMost (directSum (fun _ : Fin (k ^ t) => | |
| matrixMultiplication (n ^ t) (n ^ t) (n ^ t))) ((D * t + 1) * r ^ t) := | |
| matrixCoefficients_directSum_power_rank (A.rank_power t) | |
| theorem matrixCoefficients_fin_one_rank {K : Type*} [CommSemiring K] : | |
| RankAtMost (matrixCoefficients (K := K) (Fin 1) (Fin 1) (Fin 1)) 1 := by | |
| have heq : matrixCoefficients (K := K) (Fin 1) (Fin 1) (Fin 1) = | |
| rankOne (fun _ => 1) (fun _ => 1) (fun _ => 1) := by | |
| funext x y z | |
| have hxy : x.2 = y.1 := Subsingleton.elim _ _ | |
| have hyz : y.2 = z.1 := Subsingleton.elim _ _ | |
| have hzx : z.2 = x.1 := Subsingleton.elim _ _ | |
| simp [matrixCoefficients, rankOne, hxy, hyz, hzx] | |
| rw [heq] | |
| exact rankOne_rankAtMost _ _ _ | |
| theorem matrixCoefficients_pow_batchRank {K : Type*} [CommSemiring K] | |
| {n k r : β} (hk : 0 < k) | |
| (hbatch : RankAtMost | |
| (directSum (fun _ : Fin k => matrixCoefficients (K := K) (Fin n) (Fin n) (Fin n))) r) : | |
| β t : β, RankAtMost | |
| (matrixCoefficients (K := K) (Fin (n ^ t)) (Fin (n ^ t)) (Fin (n ^ t))) | |
| (batchRank k r t) := by | |
| intro t | |
| induction t with | |
| | zero => | |
| simp only [batchRank_zero] | |
| exact matrixCoefficients_fin_one_rank | |
| | succ t ih => | |
| let e : Fin (n ^ (t + 1)) β Fin (n ^ t) Γ Fin n := | |
| Fintype.equivOfCardEq (by simp [pow_succ]) | |
| have hp := matrixCoefficients_batch_rank_ceiling ih hbatch hk | |
| have hr := matrixCoefficients_rank_of_injective hp e e.injective | |
| simpa only [batchRank_succ] using hr | |
| end Tensor | |
| namespace Arithmetic | |
| theorem rpow_omega_le_of_rankAtMost {n R : β} {B : β} (hn : 2 β€ n) | |
| (hRank : Tensor.RankAtMost (Tensor.matrixMultiplication n n n) R) | |
| (hquad : (n : β) ^ 2 β€ B) (hR : (R : β) β€ B) : | |
| (n : β) ^ omega β€ B := by | |
| have hn1 : 1 < (n : β) := by exact_mod_cast (show 1 < n by omega) | |
| have hn0 : 0 < (n : β) := lt_trans zero_lt_one hn1 | |
| have hB : 0 < B := (sq_pos_of_pos hn0).trans_le hquad | |
| have hpow : (n : β) ^ Real.logb n B = B := | |
| Real.rpow_logb hn0 (ne_of_gt hn1) hB | |
| have hΟ : 2 β€ Real.logb (n : β) B := by | |
| apply (Real.le_logb_iff_rpow_le hn1 hB).mpr | |
| simpa only [Real.rpow_two] using hquad | |
| have hadmissible := admissibleExponent_of_rankAtMost hn hRank hΟ (hR.trans_eq hpow.symm) | |
| exact (Real.rpow_le_rpow_of_exponent_le hn1.le | |
| (omega_le_of_admissibleExponent hadmissible)).trans_eq hpow | |
| theorem rpow_omega_le_of_rank_growth {n : β} {q C : β} (hn : 2 β€ n) | |
| (hquad : (n : β) ^ 2 β€ q) (R : β β β) | |
| (hRank : β t : β, Tensor.RankAtMost | |
| (Tensor.matrixMultiplication (n ^ t) (n ^ t) (n ^ t)) (R t)) | |
| (hcost : β t : β, (R t : β) β€ C * q ^ t) : | |
| (n : β) ^ omega β€ q := by | |
| have hn0 : 0 β€ (n : β) := Nat.cast_nonneg n | |
| have hq0 : 0 β€ q := (sq_nonneg (n : β)).trans hquad | |
| apply power_le_of_forall_pow_le_mul_pow hq0 (C := max 1 C) | |
| intro t ht | |
| have hnt : 2 β€ n ^ t := hn.trans (le_self_pow (by omega) (Nat.ne_of_gt ht)) | |
| have hbase : ((n ^ t : β) : β) ^ 2 β€ max 1 C * q ^ t := by | |
| calc | |
| ((n ^ t : β) : β) ^ 2 = ((n : β) ^ 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 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 := rpow_omega_le_of_rankAtMost hnt (hRank t) hbase hcost' | |
| simpa only [Nat.cast_pow, β Real.rpow_pow_comm hn0] using h | |
| theorem equalSummand_inequality_of_quadratic_bound {n k r : β} | |
| (hn : 2 β€ n) (hk : 0 < k) | |
| (hbatch : Tensor.RankAtMost | |
| (Tensor.directSum (fun _ : Fin k => Tensor.matrixMultiplication n n n)) r) | |
| (hquad : (n : β) ^ 2 β€ (r : β) / (k : β)) : | |
| (k : β) * (n : β) ^ omega β€ (r : β) := by | |
| have hnreal : (2 : β) β€ n := by exact_mod_cast hn | |
| have hq : 1 < (r : β) / (k : β) := by nlinarith | |
| have hRank := Tensor.matrixCoefficients_pow_batchRank hk hbatch | |
| have hcost := affine_recurrence_bound (fun t => (batchRank k r t : β)) | |
| ((r : β) / (k : β)) (r : β) hq (Nat.cast_nonneg r) | |
| (fun t => batchRank_succ_le_affine hk r t) | |
| have hbound : (n : β) ^ omega β€ (r : β) / (k : β) := by | |
| apply rpow_omega_le_of_rank_growth | |
| (C := (batchRank k r 0 : β) + (r : β) / ((r : β) / (k : β) - 1)) | |
| hn hquad (batchRank k r) | |
| Β· exact hRank | |
| Β· intro t | |
| exact (hcost t).trans_eq (mul_comm _ _) | |
| have hkreal : 0 < (k : β) := by exact_mod_cast hk | |
| simpa only [mul_comm] using (le_div_iffβ hkreal).mp hbound | |
| theorem equalSummand_inequality {n k r : β} (hn : 1 β€ n) | |
| (hbatch : Tensor.RankAtMost | |
| (Tensor.directSum (fun _ : Fin k => Tensor.matrixMultiplication n n n)) r) : | |
| (k : β) * (n : β) ^ omega β€ (r : β) := by | |
| have hlower := Tensor.directSum_square_rank_lower k n r (by omega) hbatch | |
| by_cases hn1 : n = 1 | |
| Β· subst n | |
| simpa only [Nat.cast_one, Real.one_rpow, mul_one, one_pow] using | |
| (show (k : β) β€ (r : β) by exact_mod_cast (by simpa using hlower : k β€ r)) | |
| by_cases hk0 : k = 0 | |
| Β· subst k | |
| simp | |
| have hk : 0 < k := Nat.pos_of_ne_zero hk0 | |
| apply equalSummand_inequality_of_quadratic_bound (by omega) hk hbatch | |
| have hkreal : 0 < (k : β) := by exact_mod_cast hk | |
| apply (le_div_iffβ hkreal).mpr | |
| have hlower_real : (k : β) * (n : β) ^ 2 β€ (r : β) := by exact_mod_cast hlower | |
| simpa only [mul_comm] using hlower_real | |
| theorem equalSummand_inequality_of_polynomialApproximation {n k r d D : β} | |
| (hn : 1 β€ n) | |
| (A : Tensor.PolynomialApproximation | |
| (Tensor.directSum (fun _ : Fin k => Tensor.matrixMultiplication n n n)) r d D) : | |
| (k : β) * (n : β) ^ omega β€ (r : β) := by | |
| apply power_le_of_forall_pow_le_linear_mul_pow D (Nat.cast_nonneg r) | |
| intro t ht | |
| have hnt : 1 β€ n ^ t := pow_pos (by omega : 0 < n) t | |
| have h := equalSummand_inequality hnt (A.square_directSum_power_rank t) | |
| simpa only [Nat.cast_pow, Nat.cast_mul, mul_pow, | |
| β Real.rpow_pow_comm (Nat.cast_nonneg n)] using h | |
| end Arithmetic | |
| end MatrixMultiplication.Foundation | |
| end | |
| end | |
| end MatrixAllFields | |
| namespace MatrixAllFields | |
| open scoped BigOperators Topology Polynomial | |
| section | |
| noncomputable section | |
| namespace MatrixMultiplication | |
| open MatrixMultiplication.Foundation | |
| namespace Tensor | |
| open MatrixMultiplication.Foundation.Tensor | |
| theorem rectangular_rank_of_injective | |
| {K A B C A' B' C' : Type*} [CommSemiring K] | |
| [DecidableEq A] [DecidableEq B] [DecidableEq C] | |
| [DecidableEq A'] [DecidableEq B'] [DecidableEq C'] {R : β} | |
| (h : RankAtMost (matrixCoefficients (K := K) A B C) R) | |
| (f : A' β A) (hf : Function.Injective f) | |
| (g : B' β B) (hg : Function.Injective g) | |
| (j : C' β C) (hj : Function.Injective j) : | |
| RankAtMost (matrixCoefficients (K := K) A' B' C') R := by | |
| have hp := h.pullback (fun x : A' Γ B' => (f x.1, g x.2)) | |
| (fun y : B' Γ C' => (g y.1, j y.2)) | |
| (fun z : C' Γ A' => (j z.1, f z.2)) | |
| convert hp using 1 | |
| funext x y z | |
| simp only [pullback, matrixCoefficients, hf.eq_iff, hg.eq_iff, hj.eq_iff] | |
| theorem rectangular_directSum_rank_of_injective | |
| {K ΞΉ ΞΊ A B C A' B' C' : Type*} [CommSemiring K] | |
| [DecidableEq ΞΉ] [DecidableEq ΞΊ] | |
| [DecidableEq A] [DecidableEq B] [DecidableEq C] | |
| [DecidableEq A'] [DecidableEq B'] [DecidableEq C'] {R : β} | |
| (h : RankAtMost (directSum (fun _ : ΞΉ => matrixCoefficients (K := K) A B C)) R) | |
| (e : ΞΊ β ΞΉ) (he : Function.Injective e) | |
| (f : A' β A) (hf : Function.Injective f) | |
| (g : B' β B) (hg : Function.Injective g) | |
| (j : C' β C) (hj : Function.Injective j) : | |
| RankAtMost (directSum (fun _ : ΞΊ => matrixCoefficients (K := K) A' B' C')) R := by | |
| have hp := h.pullback | |
| (fun x : ΞΊ Γ (A' Γ B') => (e x.1, (f x.2.1, g x.2.2))) | |
| (fun y : ΞΊ Γ (B' Γ C') => (e y.1, (g y.2.1, j y.2.2))) | |
| (fun z : ΞΊ Γ (C' Γ A') => (e z.1, (j z.2.1, f z.2.2))) | |
| convert hp using 1 | |
| funext x y z | |
| simp only [pullback, directSum, matrixCoefficients, | |
| he.eq_iff, hf.eq_iff, hg.eq_iff, hj.eq_iff] | |
| theorem rectangular_directSum_power_rank {K : Type*} [CommSemiring K] | |
| {a b c L R t : β} | |
| (h : RankAtMost (power (directSum (fun _ : Fin L => | |
| matrixCoefficients (K := K) (Fin a) (Fin b) (Fin c))) t) R) : | |
| RankAtMost (directSum (fun _ : Fin (L ^ t) => | |
| matrixCoefficients (K := K) (Fin (a ^ t)) (Fin (b ^ t)) (Fin (c ^ t)))) R := by | |
| have hmatrix := matrixCoefficients_directSum_rank_of_power h | |
| let tags : Fin (L ^ t) β (Fin t β Fin L) := Fintype.equivOfCardEq (by simp) | |
| let rows : Fin (a ^ t) β (Fin t β Fin a) := Fintype.equivOfCardEq (by simp) | |
| let inner : Fin (b ^ t) β (Fin t β Fin b) := Fintype.equivOfCardEq (by simp) | |
| let cols : Fin (c ^ t) β (Fin t β Fin c) := Fintype.equivOfCardEq (by simp) | |
| exact rectangular_directSum_rank_of_injective hmatrix tags tags.injective | |
| rows rows.injective inner inner.injective cols cols.injective | |
| theorem rectangular_pow_batchRank {K : Type*} [CommSemiring K] | |
| {a b c L r : β} (hL : 0 < L) | |
| (hbatch : RankAtMost (directSum (fun _ : Fin L => | |
| matrixCoefficients (K := K) (Fin a) (Fin b) (Fin c))) r) : | |
| β t : β, RankAtMost | |
| (matrixCoefficients (K := K) (Fin (a ^ t)) (Fin (b ^ t)) (Fin (c ^ t))) | |
| (batchRank L r t) := by | |
| intro t | |
| induction t with | |
| | zero => | |
| simp only [batchRank_zero] | |
| exact matrixCoefficients_fin_one_rank | |
| | succ t ih => | |
| let rows : Fin (a ^ (t + 1)) β Fin (a ^ t) Γ Fin a := | |
| Fintype.equivOfCardEq (by simp [pow_succ]) | |
| let inner : Fin (b ^ (t + 1)) β Fin (b ^ t) Γ Fin b := | |
| Fintype.equivOfCardEq (by simp [pow_succ]) | |
| let cols : Fin (c ^ (t + 1)) β Fin (c ^ t) Γ Fin c := | |
| Fintype.equivOfCardEq (by simp [pow_succ]) | |
| have hp := matrixCoefficients_rank_of_product (ih.batch_product_ceiling hbatch hL) | |
| have hr := rectangular_rank_of_injective hp | |
| rows rows.injective inner inner.injective cols cols.injective | |
| simpa only [batchRank_succ] using hr | |
| theorem rectangular_polynomial_power_rank {K : Type*} [Field K] [CharZero K] | |
| {a b c L r d D : β} | |
| (P : PolynomialApproximation (directSum (fun _ : Fin L => | |
| matrixCoefficients (K := K) (Fin a) (Fin b) (Fin c))) r d D) (t : β) : | |
| RankAtMost (directSum (fun _ : Fin (L ^ t) => | |
| matrixCoefficients (K := K) (Fin (a ^ t)) (Fin (b ^ t)) (Fin (c ^ t)))) | |
| ((D * t + 1) * r ^ t) := | |
| rectangular_directSum_power_rank (P.rank_power t) | |
| theorem rectangular_directSum_cyclic_rank | |
| {K ΞΉ A B C : Type*} [CommSemiring K] | |
| [DecidableEq ΞΉ] [DecidableEq A] [DecidableEq B] [DecidableEq C] {r : β} | |
| (h : RankAtMost (directSum (fun _ : ΞΉ => matrixCoefficients (K := K) A B C)) r) : | |
| RankAtMost (directSum (fun _ : ΞΉ => matrixCoefficients (K := K) B C A)) r := by | |
| rcases h with β¨a, b, c, heqβ© | |
| refine β¨b, c, a, ?_β© | |
| funext x y z | |
| have hcyc : directSum (fun _ : ΞΉ => matrixCoefficients (K := K) B C A) x y z = | |
| directSum (fun _ : ΞΉ => matrixCoefficients (K := K) A B C) z x y := by | |
| have htags : (x.1 = y.1 β§ x.1 = z.1) β (z.1 = x.1 β§ z.1 = y.1) := by | |
| constructor | |
| Β· rintro β¨hxy, hxzβ© | |
| exact β¨hxz.symm, hxz.symm.trans hxyβ© | |
| Β· rintro β¨hzx, hzyβ© | |
| exact β¨hzx.symm.trans hzy, hzx.symmβ© | |
| simp only [directSum, htags] | |
| split_ifs | |
| Β· exact (matrixCoefficients_cyclic (K := K) x.2 y.2 z.2).symm | |
| Β· rfl | |
| rw [hcyc, congrFun (congrFun (congrFun heq z) x) y] | |
| apply Finset.sum_congr rfl | |
| intro i hi | |
| simp only [rankOne] | |
| ring | |
| theorem rectangular_directSum_rank_lower {K : Type*} [Field K] | |
| {a b L r : β} (ha : 0 < a) (hb : 0 < b) | |
| (h : RankAtMost (directSum (fun _ : Fin L => | |
| matrixCoefficients (K := K) (Fin a) (Fin b) (Fin a))) r) : | |
| L * a ^ 2 β€ r β§ L * (a * b) β€ r := by | |
| let : Nonempty (Fin a) := β¨β¨0, haβ©β© | |
| let : Nonempty (Fin b) := β¨β¨0, hbβ©β© | |
| constructor | |
| Β· simpa only [Fintype.card_fin, pow_two] using | |
| directSum_matrixCoefficients_rank_lower h | |
| Β· simpa only [Fintype.card_fin] using | |
| directSum_matrixCoefficients_rank_lower (rectangular_directSum_cyclic_rank h) | |
| end Tensor | |
| end MatrixMultiplication | |
| end | |
| end | |
| end MatrixAllFields | |
| namespace MatrixAllFields | |
| open scoped BigOperators Topology Polynomial | |
| section | |
| noncomputable section | |
| open scoped BigOperators | |
| namespace MatrixMultiplication.Foundation | |
| namespace Tensor | |
| section ConstantRestriction | |
| variable {F X Y Z X' Y' Z' : Type*} [CommSemiring F] | |
| variable [Fintype X] [Fintype Y] [Fintype Z] | |
| def restrictPolynomial (A : X' β X β F) (B : Y' β Y β F) | |
| (C : Z' β Z β F) (P : Tensor (Polynomial F) X Y Z) : | |
| Tensor (Polynomial F) X' Y' Z' := | |
| restrict (fun x' x => Polynomial.C (A x' x)) | |
| (fun y' y => Polynomial.C (B y' y)) | |
| (fun z' z => Polynomial.C (C z' z)) P | |
| @[simp] theorem restrictPolynomial_coeff (A : X' β X β F) (B : Y' β Y β F) | |
| (C : Z' β Z β F) (P : Tensor (Polynomial F) X Y Z) (k : β) | |
| (x' : X') (y' : Y') (z' : Z') : | |
| (restrictPolynomial A B C P x' y' z').coeff k = | |
| restrict A B C (fun x y z => (P x y z).coeff k) x' y' z' := by | |
| simp only [restrictPolynomial, restrict, Polynomial.finsetSum_coeff, | |
| mul_assoc, Polynomial.coeff_C_mul] | |
| theorem RankAtMost.restrictPolynomial {P : Tensor (Polynomial F) X Y Z} {r : β} | |
| (hP : RankAtMost P r) (A : X' β X β F) (B : Y' β Y β F) | |
| (C : Z' β Z β F) : RankAtMost (restrictPolynomial A B C P) r := | |
| hP.restrict (fun x' x => Polynomial.C (A x' x)) | |
| (fun y' y => Polynomial.C (B y' y)) | |
| (fun z' z => Polynomial.C (C z' z)) | |
| theorem restrictPolynomial_degree_le (A : X' β X β F) (B : Y' β Y β F) | |
| (C : Z' β Z β F) (P : Tensor (Polynomial F) X Y Z) (D : β) | |
| (hdegree : β x y z, (P x y z).degree β€ D) | |
| (x' : X') (y' : Y') (z' : Z') : | |
| (restrictPolynomial A B C P x' y' z').degree β€ D := by | |
| apply (Polynomial.degree_le_iff_coeff_zero _ _).2 | |
| intro k hk | |
| rw [restrictPolynomial_coeff] | |
| have hzero (x : X) (y : Y) (z : Z) : (P x y z).coeff k = 0 := | |
| (Polynomial.degree_le_iff_coeff_zero _ _).1 (hdegree x y z) k hk | |
| simp only [restrict, hzero, mul_zero, Finset.sum_const_zero] | |
| end ConstantRestriction | |
| namespace PolynomialApproximation | |
| variable {F X Y Z X' Y' Z' : Type*} [Field F] | |
| def ofRankAtMost (T : Tensor F X Y Z) (r : β) (hT : RankAtMost T r) : | |
| PolynomialApproximation T r 0 0 where | |
| polynomial := fun x y z => Polynomial.C (T x y z) | |
| rank_bound := hT.map Polynomial.C | |
| vanishes := by | |
| intro x y z k hk | |
| exact (Nat.not_lt_zero k hk).elim | |
| leading := by | |
| intro x y z | |
| exact Polynomial.coeff_C_zero | |
| degree_bound := by | |
| intro x y z | |
| simpa only [Nat.cast_zero] using (Polynomial.degree_C_le (a := T x y z)) | |
| @[simp] theorem ofRankAtMost_polynomial (T : Tensor F X Y Z) (r : β) | |
| (hT : RankAtMost T r) : | |
| (ofRankAtMost T r hT).polynomial = (fun x y z => Polynomial.C (T x y z)) := rfl | |
| variable [Fintype X] [Fintype Y] [Fintype Z] | |
| variable {T : Tensor F X Y Z} {r d D : β} | |
| def restrict (W : PolynomialApproximation T r d D) | |
| (A : X' β X β F) (B : Y' β Y β F) (C : Z' β Z β F) : | |
| PolynomialApproximation (Tensor.restrict A B C T) r d D where | |
| polynomial := restrictPolynomial A B C W.polynomial | |
| rank_bound := W.rank_bound.restrictPolynomial A B C | |
| vanishes := by | |
| intro x' y' z' k hk | |
| rw [restrictPolynomial_coeff] | |
| have hzero (x : X) (y : Y) (z : Z) : (W.polynomial x y z).coeff k = 0 := | |
| W.vanishes x y z k hk | |
| simp only [Tensor.restrict, hzero, mul_zero, Finset.sum_const_zero] | |
| leading := by | |
| intro x' y' z' | |
| rw [restrictPolynomial_coeff] | |
| simp only [W.leading] | |
| degree_bound := restrictPolynomial_degree_le A B C W.polynomial D W.degree_bound | |
| @[simp] theorem restrict_polynomial (W : PolynomialApproximation T r d D) | |
| (A : X' β X β F) (B : Y' β Y β F) (C : Z' β Z β F) : | |
| (W.restrict A B C).polynomial = restrictPolynomial A B C W.polynomial := rfl | |
| end PolynomialApproximation | |
| end Tensor | |
| end MatrixMultiplication.Foundation | |
| end | |
| end | |
| end MatrixAllFields | |
| namespace MatrixAllFields | |
| open scoped BigOperators Topology Polynomial | |
| section | |
| noncomputable section | |
| namespace MatrixMultiplication.Foundation | |
| namespace Tensor | |
| private def rectangularTagEquiv (L : β) : | |
| Fin (L ^ 3) β (Fin L Γ Fin L) Γ Fin L := | |
| Fintype.equivOfCardEq (by simp [pow_succ]) | |
| private def rectangularIndexEquiv (a b c : β) : | |
| Fin (a * b * c) β Fin a Γ Fin b Γ Fin c := | |
| Fintype.equivOfCardEq (by simp [mul_assoc]) | |
| theorem matrixMultiplication_directSum_symmetrized_rank {a b c L r : β} | |
| (h : RankAtMost (directSum (fun _ : Fin L => matrixMultiplication a b c)) r) : | |
| RankAtMost (directSum (fun _ : Fin (L ^ 3) => | |
| matrixMultiplication (a * b * c) (a * b * c) (a * b * c))) (r ^ 3) := by | |
| have hs := matrixCoefficients_directSum_symmetrized_rank h | |
| exact matrixCoefficients_directSum_rank_of_injective hs | |
| (rectangularTagEquiv L) (rectangularTagEquiv L).injective | |
| (rectangularIndexEquiv a b c) (rectangularIndexEquiv a b c).injective | |
| private def rectangularPullback | |
| {FieldType SourceX SourceY SourceZ TargetX TargetY TargetZ : Type*} [Field FieldType] | |
| {tensor : Tensor FieldType SourceX SourceY SourceZ} {rank shift degree : β} | |
| (witness : PolynomialApproximation tensor rank shift degree) | |
| (mapX : TargetX β SourceX) (mapY : TargetY β SourceY) (mapZ : TargetZ β SourceZ) : | |
| PolynomialApproximation (pullback mapX mapY mapZ tensor) rank shift degree where | |
| polynomial := pullback mapX mapY mapZ witness.polynomial | |
| rank_bound := witness.rank_bound.pullback mapX mapY mapZ | |
| vanishes := fun coordX coordY coordZ coeff bound => | |
| witness.vanishes (mapX coordX) (mapY coordY) (mapZ coordZ) coeff bound | |
| leading := fun coordX coordY coordZ => | |
| witness.leading (mapX coordX) (mapY coordY) (mapZ coordZ) | |
| degree_bound := fun coordX coordY coordZ => | |
| witness.degree_bound (mapX coordX) (mapY coordY) (mapZ coordZ) | |
| private def rectangularProduct | |
| {FieldType LeftX LeftY LeftZ RightX RightY RightZ : Type*} [Field FieldType] | |
| {leftTensor : Tensor FieldType LeftX LeftY LeftZ} | |
| {rightTensor : Tensor FieldType RightX RightY RightZ} | |
| {leftRank rightRank leftShift rightShift leftDegree rightDegree : β} | |
| (left : PolynomialApproximation leftTensor leftRank leftShift leftDegree) | |
| (right : PolynomialApproximation rightTensor rightRank rightShift rightDegree) : | |
| PolynomialApproximation (product leftTensor rightTensor) (leftRank * rightRank) | |
| (leftShift + rightShift) (leftDegree + rightDegree) := by | |
| have factorization (coordX : LeftX Γ RightX) (coordY : LeftY Γ RightY) | |
| (coordZ : LeftZ Γ RightZ) : | |
| product left.polynomial right.polynomial coordX coordY coordZ = | |
| Polynomial.X ^ (leftShift + rightShift) * | |
| product left.normalized right.normalized coordX coordY coordZ := by | |
| dsimp only [product] | |
| rw [left.polynomial_eq, right.polynomial_eq, pow_add] | |
| ring | |
| exact { | |
| polynomial := product left.polynomial right.polynomial | |
| rank_bound := left.rank_bound.product right.rank_bound | |
| vanishes := by | |
| intro coordX coordY coordZ coeff bound | |
| rw [factorization] | |
| simp only [Polynomial.coeff_X_pow_mul', Nat.not_le_of_lt bound, ite_false] | |
| leading := by | |
| intro coordX coordY coordZ | |
| rw [factorization] | |
| simp only [Polynomial.coeff_X_pow_mul', le_refl, ite_true, Nat.sub_self, | |
| product, Polynomial.mul_coeff_zero, left.normalized_constant, right.normalized_constant] | |
| degree_bound := by | |
| intro coordX coordY coordZ | |
| apply Polynomial.degree_le_of_natDegree_le | |
| exact Polynomial.natDegree_mul_le_of_le | |
| (Polynomial.natDegree_le_of_degree_le (left.degree_bound coordX.1 coordY.1 coordZ.1)) | |
| (Polynomial.natDegree_le_of_degree_le (right.degree_bound coordX.2 coordY.2 coordZ.2)) } | |
| private def rectangularCyclic | |
| {FieldType CoordX CoordY CoordZ : Type*} [Field FieldType] | |
| {tensor : Tensor FieldType CoordX CoordY CoordZ} {rank shift degree : β} | |
| (witness : PolynomialApproximation tensor rank shift degree) : | |
| PolynomialApproximation (cyclic tensor) rank shift degree where | |
| polynomial := cyclic witness.polynomial | |
| rank_bound := witness.rank_bound.cyclic | |
| vanishes := fun coordY coordZ coordX coeff bound => | |
| witness.vanishes coordX coordY coordZ coeff bound | |
| leading := fun coordY coordZ coordX => witness.leading coordX coordY coordZ | |
| degree_bound := fun coordY coordZ coordX => witness.degree_bound coordX coordY coordZ | |
| def PolynomialApproximation.matrixCoefficients_directSum_of_injective | |
| {F ΞΉ ΞΊ A B : Type*} [Field F] | |
| [DecidableEq ΞΉ] [DecidableEq ΞΊ] [DecidableEq A] [DecidableEq B] {r d D : β} | |
| (P : PolynomialApproximation | |
| (directSum (fun _ : ΞΉ => matrixCoefficients (K := F) A A A)) r d D) | |
| (f : ΞΊ β ΞΉ) (hf : Function.Injective f) (g : B β A) (hg : Function.Injective g) : | |
| PolynomialApproximation | |
| (directSum (fun _ : ΞΊ => matrixCoefficients (K := F) B B B)) r d D := by | |
| let coord : ΞΊ Γ (B Γ B) β ΞΉ Γ (A Γ A) := | |
| fun x => (f x.1, (g x.2.1, g x.2.2)) | |
| have heq : Tensor.pullback coord coord coord | |
| (directSum (fun _ : ΞΉ => matrixCoefficients (K := F) A A A)) = | |
| directSum (fun _ : ΞΊ => matrixCoefficients (K := F) B B B) := by | |
| funext x y z | |
| simp only [Tensor.pullback, coord, directSum, matrixCoefficients, hf.eq_iff, hg.eq_iff] | |
| rw [β heq] | |
| exact rectangularPullback P coord coord coord | |
| def PolynomialApproximation.matrixMultiplication_directSum_symmetrized | |
| {a b c L r d D : β} | |
| (P : PolynomialApproximation | |
| (directSum (fun _ : Fin L => matrixMultiplication a b c)) r d D) : | |
| PolynomialApproximation (directSum (fun _ : Fin (L ^ 3) => | |
| matrixMultiplication (a * b * c) (a * b * c) (a * b * c))) | |
| (r ^ 3) (3 * d) (3 * D) := by | |
| have combine {LeftTag RightTag LeftX LeftY LeftZ RightX RightY RightZ : Type} | |
| [DecidableEq LeftTag] [DecidableEq RightTag] | |
| {leftTensor : LeftTag β Tensor β LeftX LeftY LeftZ} | |
| {rightTensor : RightTag β Tensor β RightX RightY RightZ} | |
| {leftRank rightRank leftShift rightShift leftDegree rightDegree : β} | |
| (left : PolynomialApproximation (directSum leftTensor) leftRank leftShift leftDegree) | |
| (right : PolynomialApproximation (directSum rightTensor) rightRank rightShift rightDegree) : | |
| PolynomialApproximation | |
| (directSum (fun tag : LeftTag Γ RightTag => product (leftTensor tag.1) (rightTensor tag.2))) | |
| (leftRank * rightRank) (leftShift + rightShift) (leftDegree + rightDegree) := by | |
| have combined := rectangularPullback (rectangularProduct left right) | |
| (directSumProductEquiv LeftTag RightTag LeftX RightX) | |
| (directSumProductEquiv LeftTag RightTag LeftY RightY) | |
| (directSumProductEquiv LeftTag RightTag LeftZ RightZ) | |
| simpa only [directSum_product] using combined | |
| have base : PolynomialApproximation | |
| (directSum (fun _ : Fin L => matrixCoefficients (K := β) (Fin a) (Fin b) (Fin c))) | |
| r d D := P | |
| have rotated : PolynomialApproximation | |
| (directSum (fun _ : Fin L => matrixCoefficients (K := β) (Fin b) (Fin c) (Fin a))) | |
| r d D := by | |
| simpa only [cyclic_directSum, cyclic_matrixCoefficients] using rectangularCyclic base | |
| have twiceRotated : PolynomialApproximation | |
| (directSum (fun _ : Fin L => matrixCoefficients (K := β) (Fin c) (Fin a) (Fin b))) | |
| r d D := by | |
| simpa only [cyclic_directSum, cyclic_matrixCoefficients] using rectangularCyclic rotated | |
| let squareIndex := Fin a Γ Fin b Γ Fin c | |
| let tagIndex := (Fin L Γ Fin L) Γ Fin L | |
| have symmetrized := rectangularPullback (combine (combine base rotated) twiceRotated) | |
| (fun coord : tagIndex Γ (squareIndex Γ squareIndex) => | |
| (coord.1, rectangularSquareX (Fin a) (Fin b) (Fin c) coord.2)) | |
| (fun coord : tagIndex Γ (squareIndex Γ squareIndex) => | |
| (coord.1, rectangularSquareY (Fin a) (Fin b) (Fin c) coord.2)) | |
| (fun coord : tagIndex Γ (squareIndex Γ squareIndex) => | |
| (coord.1, rectangularSquareZ (Fin a) (Fin b) (Fin c) coord.2)) | |
| have shift_eq : d + d + d = 3 * d := by ring | |
| have degree_eq : D + D + D = 3 * D := by ring | |
| have squared : PolynomialApproximation | |
| (directSum (fun _ : tagIndex => matrixCoefficients (K := β) squareIndex squareIndex squareIndex)) | |
| (r ^ 3) (3 * d) (3 * D) := by | |
| simp only [directSum_pullback] at symmetrized | |
| simp_rw [matrixCoefficients_cyclic_product_square | |
| (K := β) (A := Fin a) (B := Fin b) (C := Fin c)] at symmetrized | |
| simpa only [pow_succ, pow_zero, one_mul, shift_eq, degree_eq] using symmetrized | |
| exact squared.matrixCoefficients_directSum_of_injective | |
| (rectangularTagEquiv L) (rectangularTagEquiv L).injective | |
| (rectangularIndexEquiv a b c) (rectangularIndexEquiv a b c).injective | |
| end Tensor | |
| theorem mul_rpow_third_le_of_cube {u v w r : β} (hv : 0 β€ v) (hr : 0 β€ r) | |
| (h : u ^ 3 * v ^ w β€ r ^ 3) : u * v ^ (w / 3) β€ r := by | |
| have hpow : (v ^ (w / 3)) ^ (3 : β) = v ^ w := by | |
| rw [β Real.rpow_mul_natCast hv] | |
| congr 1 | |
| norm_num | |
| apply le_of_pow_le_pow_leftβ (by decide : (3 : β) β 0) hr | |
| simpa only [mul_pow, hpow] using h | |
| namespace Arithmetic | |
| theorem equalRectangular_inequality {a b c L r : β} | |
| (ha : 1 β€ a) (hb : 1 β€ b) (hc : 1 β€ c) | |
| (h : Tensor.RankAtMost | |
| (Tensor.directSum (fun _ : Fin L => Tensor.matrixMultiplication a b c)) r) : | |
| (L : β) * ((a * b * c : β) : β) ^ (omega / 3) β€ (r : β) := by | |
| have hv : 1 β€ a * b * c := Nat.mul_pos (Nat.mul_pos ha hb) hc | |
| have hs := equalSummand_inequality hv | |
| (Tensor.matrixMultiplication_directSum_symmetrized_rank h) | |
| apply mul_rpow_third_le_of_cube (Nat.cast_nonneg (a * b * c)) (Nat.cast_nonneg r) | |
| simpa only [Nat.cast_pow] using hs | |
| theorem equalRectangular_inequality_of_polynomialApproximation | |
| {a b c L r d D : β} (ha : 1 β€ a) (hb : 1 β€ b) (hc : 1 β€ c) | |
| (P : Tensor.PolynomialApproximation | |
| (Tensor.directSum (fun _ : Fin L => Tensor.matrixMultiplication a b c)) r d D) : | |
| (L : β) * ((a * b * c : β) : β) ^ (omega / 3) β€ (r : β) := by | |
| have hv : 1 β€ a * b * c := Nat.mul_pos (Nat.mul_pos ha hb) hc | |
| have hs := equalSummand_inequality_of_polynomialApproximation hv | |
| P.matrixMultiplication_directSum_symmetrized | |
| apply mul_rpow_third_le_of_cube (Nat.cast_nonneg (a * b * c)) (Nat.cast_nonneg r) | |
| simpa only [Nat.cast_pow] using hs | |
| end Arithmetic | |
| end MatrixMultiplication.Foundation | |
| end | |
| end | |
| end MatrixAllFields | |
| end OAI | |