openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /AuxiliarySeparation /Character /FiniteSeparation.lean
| import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Separation.Basic | |
| import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Character.Degeneration | |
| import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Character.Dot | |
| import OAI.LinearAlgebra.MatrixMultiplication.AuxiliarySeparation.Tensor.CharacterBounds | |
| namespace OAI | |
| /-! | |
| # The character bound from finite separation | |
| The explicit Fourier and square-weight construction gives a polynomial tensor | |
| whose nonzero evaluations restrict from exactly `5M` complete source copies. | |
| Character monotonicity follows by interpolation and tensor powering; it does | |
| not require continuity of the character. | |
| -/ | |
| noncomputable section | |
| open MatrixMultiplication.Foundation | |
| open scoped BigOperators | |
| namespace MatrixMultiplication.AuxiliarySeparation | |
| variable {M : ℕ} {X Y Z : Type} | |
| variable [Fintype X] [Fintype Y] [Fintype Z] | |
| omit [Fintype Z] in | |
| private theorem polynomial_rank_bound | |
| (P : Tensor (Polynomial ℂ) X Y Z) : | |
| Tensor.RankAtMost P (Fintype.card (X × Y)) := by | |
| classical | |
| let a : X × Y → X → Polynomial ℂ := fun i x => if i.1 = x then 1 else 0 | |
| let b : X × Y → Y → Polynomial ℂ := fun i y => if i.2 = y then 1 else 0 | |
| let c : X × Y → Z → Polynomial ℂ := fun i z => P i.1 i.2 z | |
| have heq : P = fun x y z => ∑ i, Tensor.rankOne (a i) (b i) (c i) x y z := by | |
| funext x y z | |
| simp [Tensor.rankOne, a, b, c, Fintype.sum_prod_type, ite_mul, mul_ite] | |
| rw [heq] | |
| exact Tensor.rankAtMost_sum_rankOne a b c | |
| /-- The explicit separation polynomial, viewed as a polynomial approximation | |
| to its constant tensor. Its rank bound is supplied by a coordinate expansion. -/ | |
| def separationPolynomialApproximation {ζ : ℂ} (hM : 0 < M) | |
| (hζ : IsPrimitiveRoot ζ (5 * M)) (B : Fin M → Tensor ℂ X Y Z) : | |
| Tensor.PolynomialApproximation (separationTarget B) | |
| (Fintype.card ((X × Fin M) × ((Fin M × Y) × Fin M))) 0 ((M - 1) ^ 2) where | |
| polynomial := separationPolynomial ζ B | |
| rank_bound := polynomial_rank_bound _ | |
| vanishes := by | |
| intro _ _ _ k hk | |
| exact (Nat.not_lt_zero k hk).elim | |
| leading := by | |
| intro x y z | |
| exact congrFun (congrFun (congrFun (separationPolynomial_coeff_zero hM hζ B) x) y) z | |
| degree_bound := separationPolynomial_degree hM hζ B | |
| namespace Character | |
| variable (χ : Character) | |
| /-- The separated constant tensor costs at most the character of the `5M` | |
| source copies. This uses the explicit polynomial, not topological continuity. -/ | |
| theorem value_separationTarget_le (hM : 0 < M) (B : Fin M → Tensor ℂ X Y Z) : | |
| χ.value (separationTarget B) ≤ | |
| 5 * (M : ℝ) * χ.value (sharedFirstTensor B) := by | |
| classical | |
| let ζ : ℂ := Complex.exp (2 * Real.pi * Complex.I / (5 * M : ℕ)) | |
| have hζ : IsPrimitiveRoot ζ (5 * M) := | |
| Complex.isPrimitiveRoot_exp _ (by omega) | |
| have hbound : χ.value (separationTarget B) ≤ | |
| χ.value (Tensor.directSum (fun _ : Fin (5 * M) => sharedFirstTensor B)) := by | |
| apply χ.value_le_of_polynomialApproximation | |
| (separationPolynomialApproximation hM hζ B) (χ.nonneg _) | |
| intro t ht | |
| change χ.value (fun x y z => (separationPolynomial ζ B x y z).eval t) ≤ _ | |
| rw [separationPolynomial_eval hM hζ B t ht] | |
| exact χ.monotone _ _ _ _ | |
| simpa only [χ.value_copies, Nat.cast_mul, Nat.cast_ofNat] using hbound | |
| /-- Character accounting for the genuine direct sum in the separated tensor. -/ | |
| theorem value_separationTarget (hM : 0 < M) (B : Fin M → Tensor ℂ X Y Z) : | |
| χ.value (separationTarget B) = | |
| (∑ h, χ.value (B h)) * (M : ℝ) ^ χ.pX := by | |
| classical | |
| rw [separationTarget_eq_directSum, χ.value_reindex, χ.map_directSum] | |
| simp only [χ.map_product, χ.value_cyclic_cyclic_dotPairing hM, Finset.sum_mul] | |
| /-- Exact finite character separation: the common first coordinate can be | |
| separated at a cost of `5M`, retaining an `M`-dimensional first-leg dot factor. -/ | |
| theorem finiteSeparation_bound (hM : 0 < M) (B : Fin M → Tensor ℂ X Y Z) : | |
| (∑ h, χ.value (B h)) * (M : ℝ) ^ χ.pX ≤ | |
| 5 * (M : ℝ) * χ.value (sharedFirstTensor B) := by | |
| rw [← χ.value_separationTarget hM B] | |
| exact χ.value_separationTarget_le hM B | |
| end Character | |
| end MatrixMultiplication.AuxiliarySeparation | |
| end | |
| end OAI | |