openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /CoppersmithWinograd /ComplexCWBoundary.lean
| import OAI.LinearAlgebra.MatrixMultiplication.CoppersmithWinograd.ComplexCoppersmithWinograd | |
| namespace OAI | |
| /-! Coppersmith–Winograd tensors, tensor powers and local restrictions. -/ | |
| noncomputable section | |
| namespace MatrixMultiplication.Foundation | |
| namespace CWBoundary | |
| open Polynomial | |
| def deleted : Tensor ℂ (Fin 3) (Fin 3) (Fin 3) := | |
| fun x y z => if x = 1 ∧ y = 0 ∧ z = 1 then 1 else 0 | |
| def tensor : Tensor ℂ (Fin 3) (Fin 3) (Fin 3) := | |
| fun x y z => if x = 1 ∧ y = 0 ∧ z = 1 then 0 | |
| else CoppersmithWinograd.tensor x y z | |
| @[simp] theorem tensor_deleted : tensor 1 0 1 = 0 := by simp [tensor] | |
| theorem tensor_preserves (x y z : Fin 3) (h : ¬ (x = 1 ∧ y = 0 ∧ z = 1)) : | |
| tensor x y z = CoppersmithWinograd.tensor x y z := by simp [tensor, h] | |
| theorem deleted_rankAtMost : Tensor.RankAtMost deleted 1 := by | |
| have heq : deleted = Tensor.rankOne | |
| (fun x : Fin 3 => if x = 1 then (1 : ℂ) else 0) | |
| (fun y : Fin 3 => if y = 0 then (1 : ℂ) else 0) | |
| (fun z : Fin 3 => if z = 1 then (1 : ℂ) else 0) := by | |
| funext x y z | |
| by_cases hx : x = 1 <;> by_cases hy : y = 0 <;> by_cases hz : z = 1 <;> | |
| simp [deleted, Tensor.rankOne, hx, hy, hz] | |
| rw [heq] | |
| exact Tensor.rankOne_rankAtMost _ _ _ | |
| section LocalMaps | |
| variable {K : Type*} [CommSemiring K] | |
| def diagonalMap (w : Fin 3 → K) : Fin 3 → Fin 3 → K := | |
| fun output input => if input = output then w output else 0 | |
| def outerWeight (t : K) (x : Fin 3) : K := if x = 1 then t else 1 | |
| def middleWeight (t : K) (y : Fin 3) : K := if y = 1 then 1 else t | |
| def outerMap (t : K) : Fin 3 → Fin 3 → K := diagonalMap (outerWeight t) | |
| def middleMap (t : K) : Fin 3 → Fin 3 → K := diagonalMap (middleWeight t) | |
| theorem restrict_diagonal_apply (a b c : Fin 3 → K) | |
| (T : Tensor K (Fin 3) (Fin 3) (Fin 3)) (x y z : Fin 3) : | |
| Tensor.restrict (diagonalMap a) (diagonalMap b) (diagonalMap c) T x y z = | |
| a x * b y * c z * T x y z := by | |
| simp [Tensor.restrict, diagonalMap, ite_mul, mul_ite] | |
| theorem weight_on_support (t : K) (x y z : Fin 3) | |
| (hs : x.val + y.val + z.val = 2) : | |
| outerWeight t x * middleWeight t y * outerWeight t z = | |
| if x = 1 ∧ y = 0 ∧ z = 1 then t ^ 3 else t := by | |
| fin_cases x <;> fin_cases y <;> fin_cases z <;> | |
| norm_num at hs <;> norm_num [outerWeight, middleWeight] | |
| all_goals ring | |
| theorem scale_lifted_tensor (f : ℂ →+* K) (t : K) : | |
| Tensor.restrict (outerMap t) (middleMap t) (outerMap t) | |
| (fun x y z => f (CoppersmithWinograd.tensor x y z)) = | |
| fun x y z => t * f (tensor x y z) + t ^ 3 * f (deleted x y z) := by | |
| funext x y z | |
| rw [outerMap, middleMap, restrict_diagonal_apply] | |
| by_cases hs : x.val + y.val + z.val = 2 | |
| · rw [weight_on_support t x y z hs] | |
| by_cases hd : x = 1 ∧ y = 0 ∧ z = 1 <;> | |
| simp [tensor, deleted, CoppersmithWinograd.tensor, hs, hd] | |
| · by_cases hd : x = 1 ∧ y = 0 ∧ z = 1 | |
| · rcases hd with ⟨rfl, rfl, rfl⟩ | |
| norm_num at hs | |
| · simp [tensor, deleted, CoppersmithWinograd.tensor, hs, hd] | |
| end LocalMaps | |
| theorem scaling_identity (t : ℂ) : | |
| Tensor.restrict (outerMap t) (middleMap t) (outerMap t) | |
| CoppersmithWinograd.tensor = | |
| fun x y z => t * tensor x y z + t ^ 3 * deleted x y z := by | |
| simpa using scale_lifted_tensor (RingHom.id ℂ) t | |
| def scalingPolynomial : Tensor (Polynomial ℂ) (Fin 3) (Fin 3) (Fin 3) := | |
| Tensor.restrict (outerMap X) (middleMap X) (outerMap X) | |
| (fun x y z => C (CoppersmithWinograd.tensor x y z)) | |
| theorem scalingPolynomial_apply (x y z : Fin 3) : | |
| scalingPolynomial x y z = X * C (tensor x y z) + X ^ 3 * C (deleted x y z) := by | |
| exact congrFun (congrFun (congrFun (scale_lifted_tensor C X) x) y) z | |
| theorem scalingPolynomial_coeff (x y z : Fin 3) (k : ℕ) : | |
| (scalingPolynomial x y z).coeff k = | |
| (if k = 1 then tensor x y z else 0) + | |
| (if k = 3 then deleted x y z else 0) := by | |
| rw [scalingPolynomial_apply, Polynomial.coeff_add, | |
| mul_comm X (C (tensor x y z)), mul_comm (X ^ 3) (C (deleted x y z)), | |
| Polynomial.coeff_C_mul_X, Polynomial.coeff_C_mul_X_pow] | |
| theorem scalingPolynomial_leading (x y z : Fin 3) : | |
| (scalingPolynomial x y z).coeff 1 = tensor x y z := by | |
| simp [scalingPolynomial_coeff] | |
| theorem scalingPolynomial_degree (x y z : Fin 3) : | |
| (scalingPolynomial x y z).degree ≤ 3 := by | |
| rw [scalingPolynomial_apply, | |
| mul_comm X (C (tensor x y z)), mul_comm (X ^ 3) (C (deleted x y z))] | |
| apply Polynomial.degree_add_le_of_degree_le | |
| · exact (Polynomial.degree_C_mul_X_le (tensor x y z)).trans (by norm_num) | |
| · exact Polynomial.degree_C_mul_X_pow_le 3 (deleted x y z) | |
| def normalizedCurve (t : ℂ) : Tensor ℂ (Fin 3) (Fin 3) (Fin 3) := | |
| fun x y z => tensor x y z + t ^ 2 * deleted x y z | |
| theorem normalizedCurve_restriction (t : ℂ) (ht : t ≠ 0) : | |
| normalizedCurve t = Tensor.restrict | |
| (diagonalMap (fun x => t⁻¹ * outerWeight t x)) | |
| (middleMap t) (outerMap t) CoppersmithWinograd.tensor := by | |
| funext x y z | |
| rw [middleMap, outerMap, restrict_diagonal_apply] | |
| have h := congrFun (congrFun (congrFun (scaling_identity t) x) y) z | |
| rw [outerMap, middleMap, restrict_diagonal_apply] at h | |
| calc | |
| normalizedCurve t x y z = | |
| (t⁻¹ * t) * tensor x y z + (t⁻¹ * t) * t ^ 2 * deleted x y z := by | |
| simp [normalizedCurve, inv_mul_cancel₀ ht] | |
| _ = t⁻¹ * (t * tensor x y z + t ^ 3 * deleted x y z) := by ring | |
| _ = t⁻¹ * (outerWeight t x * middleWeight t y * outerWeight t z * | |
| CoppersmithWinograd.tensor x y z) := by rw [h] | |
| _ = _ := by ring | |
| theorem degeneration : Tensor.DegeneratesTo CoppersmithWinograd.tensor tensor := by | |
| have hf : Continuous normalizedCurve := by | |
| unfold normalizedCurve | |
| fun_prop | |
| have hclosed : IsClosed {t : ℂ | normalizedCurve t ∈ | |
| closure (Tensor.restrictionOrbit CoppersmithWinograd.tensor)} := | |
| isClosed_closure.preimage hf | |
| have hsubset : ({0}ᶜ : Set ℂ) ⊆ {t : ℂ | normalizedCurve t ∈ | |
| closure (Tensor.restrictionOrbit CoppersmithWinograd.tensor)} := by | |
| intro t ht | |
| apply subset_closure | |
| exact ⟨diagonalMap (fun x => t⁻¹ * outerWeight t x), middleMap t, outerMap t, | |
| normalizedCurve_restriction t (by simpa using ht)⟩ | |
| have hz := closure_minimal hsubset hclosed ((dense_compl_singleton (0 : ℂ)) 0) | |
| have heq : normalizedCurve 0 = tensor := by | |
| funext x y z | |
| simp [normalizedCurve] | |
| change normalizedCurve 0 ∈ | |
| closure (Tensor.restrictionOrbit CoppersmithWinograd.tensor) at hz | |
| rw [heq] at hz | |
| exact hz | |
| def weight (x y z : Fin 3) : ℕ := | |
| (if x = 1 then 1 else 0) + (if y = 1 then 0 else 1) + | |
| (if z = 1 then 1 else 0) | |
| def polynomial : Tensor (Polynomial ℂ) (Fin 3) (Fin 3) (Fin 3) := | |
| Tensor.restrict (outerMap X) (middleMap X) (outerMap X) | |
| CoppersmithWinograd.polynomial | |
| theorem polynomial_rankAtMost : Tensor.RankAtMost polynomial 3 := | |
| CoppersmithWinograd.rank_bound.restrict (outerMap X) (middleMap X) (outerMap X) | |
| theorem polynomial_apply (x y z : Fin 3) : | |
| polynomial x y z = | |
| if x.val + y.val + z.val = 2 ∨ x.val + y.val + z.val = 4 ∨ | |
| x.val + y.val + z.val = 6 then | |
| X ^ (x.val + y.val + z.val + weight x y z) else 0 := by | |
| unfold polynomial outerMap middleMap | |
| rw [restrict_diagonal_apply, CoppersmithWinograd.polynomial_apply] | |
| by_cases hs : x.val + y.val + z.val = 2 ∨ x.val + y.val + z.val = 4 ∨ | |
| x.val + y.val + z.val = 6 | |
| · simp only [ite_eq_left hs] | |
| by_cases hx : x = 1 <;> by_cases hy : y = 1 <;> by_cases hz : z = 1 <;> | |
| simp [outerWeight, middleWeight, weight, hx, hy, hz, pow_add] <;> ring | |
| · simp [hs] | |
| theorem weighted_degree (x y z : Fin 3) | |
| (hs : x.val + y.val + z.val = 2 ∨ x.val + y.val + z.val = 4 ∨ | |
| x.val + y.val + z.val = 6) : | |
| (x.val + y.val + z.val + weight x y z = 3 ↔ | |
| x.val + y.val + z.val = 2 ∧ ¬ (x = 1 ∧ y = 0 ∧ z = 1)) ∧ | |
| 3 ≤ x.val + y.val + z.val + weight x y z ∧ | |
| x.val + y.val + z.val + weight x y z ≤ 7 := by | |
| fin_cases x <;> fin_cases y <;> fin_cases z <;> norm_num at hs <;> norm_num [weight] | |
| theorem polynomial_leading (x y z : Fin 3) : | |
| (polynomial x y z).coeff 3 = tensor x y z := by | |
| rw [polynomial_apply] | |
| by_cases hs : x.val + y.val + z.val = 2 ∨ x.val + y.val + z.val = 4 ∨ | |
| x.val + y.val + z.val = 6 | |
| · simp only [ite_eq_left hs, Polynomial.coeff_X_pow] | |
| have hd : (3 = x.val + y.val + z.val + weight x y z) ↔ | |
| (x.val + y.val + z.val = 2 ∧ ¬ (x = 1 ∧ y = 0 ∧ z = 1)) := | |
| eq_comm.trans (weighted_degree x y z hs).1 | |
| simp only [hd] | |
| by_cases hb : x = 1 ∧ y = 0 ∧ z = 1 <;> | |
| by_cases htwo : x.val + y.val + z.val = 2 <;> | |
| simp [tensor, CoppersmithWinograd.tensor, hb, htwo] | |
| · have htwo : x.val + y.val + z.val ≠ 2 := fun h => hs (Or.inl h) | |
| rw [ite_eq_right hs] | |
| simp [tensor, CoppersmithWinograd.tensor, htwo] | |
| theorem polynomial_vanishes (x y z : Fin 3) (k : ℕ) (hk : k < 3) : | |
| (polynomial x y z).coeff k = 0 := by | |
| rw [polynomial_apply] | |
| by_cases hs : x.val + y.val + z.val = 2 ∨ x.val + y.val + z.val = 4 ∨ | |
| x.val + y.val + z.val = 6 | |
| · have hd := (weighted_degree x y z hs).2.1 | |
| have hne : k ≠ x.val + y.val + z.val + weight x y z := by omega | |
| simp [hs, Polynomial.coeff_X_pow, hne] | |
| · simp [hs] | |
| theorem polynomial_degree (x y z : Fin 3) : (polynomial x y z).degree ≤ 7 := by | |
| rw [polynomial_apply] | |
| by_cases hs : x.val + y.val + z.val = 2 ∨ x.val + y.val + z.val = 4 ∨ | |
| x.val + y.val + z.val = 6 | |
| · rw [ite_eq_left hs] | |
| apply Polynomial.degree_le_of_natDegree_le | |
| rw [Polynomial.natDegree_X_pow] | |
| exact (weighted_degree x y z hs).2.2 | |
| · simp [hs] | |
| def approximation : Tensor.PolynomialApproximation tensor 3 3 7 where | |
| polynomial := polynomial | |
| rank_bound := polynomial_rankAtMost | |
| vanishes := polynomial_vanishes | |
| leading := polynomial_leading | |
| degree_bound := polynomial_degree | |
| theorem borderRankAtMost : Tensor.BorderRankAtMost tensor 3 := | |
| approximation.borderRankAtMost | |
| theorem rank_power (n : ℕ) : | |
| Tensor.RankAtMost (Tensor.power tensor n) ((7 * n + 1) * 3 ^ n) := | |
| approximation.rank_power n | |
| end CWBoundary | |
| end MatrixMultiplication.Foundation | |
| end | |
| end OAI | |