openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /Polynomial /ComplexPolynomialDegenerationComposition.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Polynomial.ComplexPolynomialApproximation | |
| import OAI.LinearAlgebra.MatrixMultiplication.Tensor.ComplexTensorSymmetrization | |
| import Mathlib.Algebra.Polynomial.Expand | |
| import Lean.Elab.Tactic.Omega | |
| namespace OAI | |
| /-! Polynomial tensor restrictions and exact coefficient extraction. -/ | |
| noncomputable section | |
| open scoped BigOperators | |
| namespace MatrixMultiplication.Foundation | |
| namespace Tensor | |
| section ScalarRestriction | |
| variable {K X Y Z X' Y' Z' : Type*} [CommSemiring K] | |
| variable [Fintype X] [Fintype Y] [Fintype Z] | |
| theorem restrict_scalar_mul (A : X' → X → K) (B : Y' → Y → K) | |
| (C : Z' → Z → K) (P : Tensor K X Y Z) (s : K) : | |
| restrict A B C (fun x y z => s * P x y z) = | |
| fun x' y' z' => s * restrict A B C P x' y' z' := by | |
| funext x' y' z' | |
| simp only [restrict, Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro x hx | |
| apply Finset.sum_congr rfl | |
| intro y hy | |
| apply Finset.sum_congr rfl | |
| intro z hz | |
| ring | |
| theorem cyclic_restrict (A : X' → X → K) (B : Y' → Y → K) | |
| (C : Z' → Z → K) (P : Tensor K X Y Z) : | |
| cyclic (restrict A B C P) = restrict B C A (cyclic P) := by | |
| funext y' z' x' | |
| simp only [cyclic, restrict] | |
| calc | |
| (∑ x, ∑ y, ∑ z, A x' x * B y' y * C z' z * P x y z) = | |
| ∑ y, ∑ x, ∑ z, A x' x * B y' y * C z' z * P x y z := | |
| Finset.sum_comm | |
| _ = ∑ y, ∑ z, ∑ x, A x' x * B y' y * C z' z * P x y z := by | |
| apply Finset.sum_congr rfl | |
| intro y hy | |
| exact Finset.sum_comm | |
| _ = _ := by | |
| apply Finset.sum_congr rfl | |
| intro y hy | |
| apply Finset.sum_congr rfl | |
| intro z hz | |
| apply Finset.sum_congr rfl | |
| intro x hx | |
| ring | |
| end ScalarRestriction | |
| section PolynomialCoefficients | |
| variable {F : Type*} [Field F] | |
| theorem coeff_mul_expand_eq_constant (M p : Polynomial F) (a : F) | |
| (hp : p.coeff 0 = a) (k j : ℕ) (hj : j ≤ k) : | |
| (M * Polynomial.expand F (k + 1) p).coeff j = | |
| (M * Polynomial.C a).coeff j := by | |
| have hdiv : Polynomial.X ∣ p - Polynomial.C a := | |
| Polynomial.X_dvd_iff.mpr (by simp only [Polynomial.coeff_sub, | |
| Polynomial.coeff_C_zero, hp, sub_self]) | |
| rcases hdiv with ⟨q, hq⟩ | |
| have hpq : p = Polynomial.C a + Polynomial.X * q := by | |
| rw [← hq] | |
| ring | |
| have hexpand : Polynomial.expand F (k + 1) p = | |
| Polynomial.C a + Polynomial.X ^ (k + 1) * | |
| Polynomial.expand F (k + 1) q := by | |
| rw [hpq, map_add, map_mul, Polynomial.expand_C, Polynomial.expand_X] | |
| have hmul : M * Polynomial.expand F (k + 1) p = | |
| M * Polynomial.C a + Polynomial.X ^ (k + 1) * | |
| (M * Polynomial.expand F (k + 1) q) := by | |
| rw [hexpand] | |
| ring | |
| rw [hmul, Polynomial.coeff_add, Polynomial.coeff_X_pow_mul', | |
| ite_eq_right (by omega), add_zero] | |
| end PolynomialCoefficients | |
| section PolynomialLocalMaps | |
| variable {F X Y Z X' Y' Z' : Type*} [Field F] | |
| variable [Fintype X] [Fintype Y] [Fintype Z] | |
| structure PolynomialRestrictionDegeneration | |
| (T : Tensor F X Y Z) (U : Tensor F X' Y' Z') (k Lx Ly Lz : ℕ) where | |
| leftMap : X' → X → Polynomial F | |
| middleMap : Y' → Y → Polynomial F | |
| rightMap : Z' → Z → Polynomial F | |
| left_degree : ∀ x' x, (leftMap x' x).degree ≤ Lx | |
| middle_degree : ∀ y' y, (middleMap y' y).degree ≤ Ly | |
| right_degree : ∀ z' z, (rightMap z' z).degree ≤ Lz | |
| vanishes : ∀ x' y' z' j, j < k → | |
| (restrict leftMap middleMap rightMap | |
| (fun x y z => Polynomial.C (T x y z)) x' y' z').coeff j = 0 | |
| leading : ∀ x' y' z', | |
| (restrict leftMap middleMap rightMap | |
| (fun x y z => Polynomial.C (T x y z)) x' y' z').coeff k = U x' y' z' | |
| namespace PolynomialRestrictionDegeneration | |
| variable {T : Tensor F X Y Z} {U : Tensor F X' Y' Z'} | |
| variable {k Lx Ly Lz r d D : ℕ} | |
| def cyclic (L : PolynomialRestrictionDegeneration T U k Lx Ly Lz) : | |
| PolynomialRestrictionDegeneration (Tensor.cyclic T) (Tensor.cyclic U) k Ly Lz Lx where | |
| leftMap := L.middleMap | |
| middleMap := L.rightMap | |
| rightMap := L.leftMap | |
| left_degree := L.middle_degree | |
| middle_degree := L.right_degree | |
| right_degree := L.left_degree | |
| vanishes := by | |
| intro y' z' x' j hj | |
| change (restrict L.middleMap L.rightMap L.leftMap | |
| (Tensor.cyclic (fun x y z => Polynomial.C (T x y z))) y' z' x').coeff j = 0 | |
| rw [← cyclic_restrict] | |
| exact L.vanishes x' y' z' j hj | |
| leading := by | |
| intro y' z' x' | |
| change (restrict L.middleMap L.rightMap L.leftMap | |
| (Tensor.cyclic (fun x y z => Polynomial.C (T x y z))) y' z' x').coeff k = | |
| Tensor.cyclic U y' z' x' | |
| rw [← cyclic_restrict] | |
| exact L.leading x' y' z' | |
| def basePolynomial (L : PolynomialRestrictionDegeneration T U k Lx Ly Lz) : | |
| Tensor (Polynomial F) X' Y' Z' := | |
| restrict L.leftMap L.middleMap L.rightMap (fun x y z => Polynomial.C (T x y z)) | |
| def compositionPolynomial (L : PolynomialRestrictionDegeneration T U k Lx Ly Lz) | |
| (W : PolynomialApproximation T r d D) : Tensor (Polynomial F) X' Y' Z' := | |
| restrict L.leftMap L.middleMap L.rightMap | |
| (fun x y z => Polynomial.expand F (k + 1) (W.polynomial x y z)) | |
| def normalizedComposition (L : PolynomialRestrictionDegeneration T U k Lx Ly Lz) | |
| (W : PolynomialApproximation T r d D) : Tensor (Polynomial F) X' Y' Z' := | |
| restrict L.leftMap L.middleMap L.rightMap | |
| (fun x y z => Polynomial.expand F (k + 1) (W.normalized x y z)) | |
| theorem compositionPolynomial_eq | |
| (L : PolynomialRestrictionDegeneration T U k Lx Ly Lz) | |
| (W : PolynomialApproximation T r d D) (x' : X') (y' : Y') (z' : Z') : | |
| L.compositionPolynomial W x' y' z' = | |
| Polynomial.X ^ (d * (k + 1)) * L.normalizedComposition W x' y' z' := by | |
| have hpoint : (fun x y z => Polynomial.expand F (k + 1) (W.polynomial x y z)) = | |
| fun x y z => Polynomial.X ^ (d * (k + 1)) * | |
| Polynomial.expand F (k + 1) (W.normalized x y z) := by | |
| funext x y z | |
| rw [W.polynomial_eq, map_mul, map_pow, Polynomial.expand_X] | |
| simp only [← pow_mul, Nat.mul_comm] | |
| unfold compositionPolynomial normalizedComposition | |
| rw [hpoint, restrict_scalar_mul] | |
| theorem normalizedComposition_coeff | |
| (L : PolynomialRestrictionDegeneration T U k Lx Ly Lz) | |
| (W : PolynomialApproximation T r d D) (j : ℕ) (hj : j ≤ k) | |
| (x' : X') (y' : Y') (z' : Z') : | |
| (L.normalizedComposition W x' y' z').coeff j = | |
| (L.basePolynomial x' y' z').coeff j := by | |
| simp only [normalizedComposition, basePolynomial, restrict, Polynomial.finsetSum_coeff] | |
| apply Finset.sum_congr rfl | |
| intro x hx | |
| apply Finset.sum_congr rfl | |
| intro y hy | |
| apply Finset.sum_congr rfl | |
| intro z hz | |
| exact coeff_mul_expand_eq_constant | |
| (L.leftMap x' x * L.middleMap y' y * L.rightMap z' z) | |
| (W.normalized x y z) (T x y z) (W.normalized_constant x y z) k j hj | |
| theorem compositionPolynomial_rank | |
| (L : PolynomialRestrictionDegeneration T U k Lx Ly Lz) | |
| (W : PolynomialApproximation T r d D) : | |
| RankAtMost (L.compositionPolynomial W) r := | |
| (W.rank_bound.map (Polynomial.expand F (k + 1)).toRingHom).restrict | |
| L.leftMap L.middleMap L.rightMap | |
| theorem compositionPolynomial_degree | |
| (L : PolynomialRestrictionDegeneration T U k Lx Ly Lz) | |
| (W : PolynomialApproximation T r d D) (x' : X') (y' : Y') (z' : Z') : | |
| (L.compositionPolynomial W x' y' z').degree ≤ D * (k + 1) + Lx + Ly + Lz := by | |
| apply Polynomial.degree_le_of_natDegree_le | |
| unfold compositionPolynomial restrict | |
| apply Polynomial.natDegree_sum_le_of_forall_le | |
| intro x hx | |
| apply Polynomial.natDegree_sum_le_of_forall_le | |
| intro y hy | |
| apply Polynomial.natDegree_sum_le_of_forall_le | |
| intro z hz | |
| have hA := Polynomial.natDegree_le_of_degree_le (L.left_degree x' x) | |
| have hB := Polynomial.natDegree_le_of_degree_le (L.middle_degree y' y) | |
| have hC := Polynomial.natDegree_le_of_degree_le (L.right_degree z' z) | |
| have hP : (Polynomial.expand F (k + 1) (W.polynomial x y z)).natDegree ≤ | |
| D * (k + 1) := by | |
| rw [Polynomial.natDegree_expand] | |
| exact Nat.mul_le_mul_right (k + 1) | |
| (Polynomial.natDegree_le_of_degree_le (W.degree_bound x y z)) | |
| have hprod := Polynomial.natDegree_mul_le_of_le | |
| (Polynomial.natDegree_mul_le_of_le | |
| (Polynomial.natDegree_mul_le_of_le hA hB) hC) hP | |
| change (L.leftMap x' x * L.middleMap y' y * L.rightMap z' z * | |
| Polynomial.expand F (k + 1) (W.polynomial x y z)).natDegree ≤ | |
| D * (k + 1) + Lx + Ly + Lz | |
| simpa only [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm] using hprod | |
| def compose (L : PolynomialRestrictionDegeneration T U k Lx Ly Lz) | |
| (W : PolynomialApproximation T r d D) : | |
| PolynomialApproximation U r (d * (k + 1) + k) (D * (k + 1) + Lx + Ly + Lz) where | |
| polynomial := L.compositionPolynomial W | |
| rank_bound := L.compositionPolynomial_rank W | |
| vanishes := by | |
| intro x' y' z' j hj | |
| rw [L.compositionPolynomial_eq W, Polynomial.coeff_X_pow_mul'] | |
| split_ifs with hdj | |
| · have hjk : j - d * (k + 1) < k := by omega | |
| rw [L.normalizedComposition_coeff W _ (Nat.le_of_lt hjk)] | |
| exact L.vanishes x' y' z' _ hjk | |
| · rfl | |
| leading := by | |
| intro x' y' z' | |
| rw [L.compositionPolynomial_eq W, Polynomial.coeff_X_pow_mul'] | |
| simp only [Nat.le_add_right, ite_true, Nat.add_sub_cancel_left] | |
| rw [L.normalizedComposition_coeff W k le_rfl] | |
| exact L.leading x' y' z' | |
| degree_bound := L.compositionPolynomial_degree W | |
| @[simp] theorem compose_polynomial | |
| (L : PolynomialRestrictionDegeneration T U k Lx Ly Lz) | |
| (W : PolynomialApproximation T r d D) : | |
| (L.compose W).polynomial = restrict L.leftMap L.middleMap L.rightMap | |
| (fun x y z => Polynomial.expand F (k + 1) (W.polynomial x y z)) := rfl | |
| end PolynomialRestrictionDegeneration | |
| end PolynomialLocalMaps | |
| end Tensor | |
| end MatrixMultiplication.Foundation | |
| end | |
| end OAI | |