openAI-math-dataset / lean /OAI /LinearAlgebra /MatrixMultiplication /AuxiliarySeparation /Convolution /Basic.lean
| import OAI.LinearAlgebra.MatrixMultiplication.Tensor.ComplexDotPairing | |
| import OAI.LinearAlgebra.MatrixMultiplication.Tensor.ComplexTensorSymmetrization | |
| import Mathlib.Tactic | |
| namespace OAI | |
| /-! | |
| # The polynomial multiplication tensor | |
| The coefficient tensor `convolution a b` represents multiplication of binary forms | |
| of degrees `a - 1` and `b - 1`, or equivalently ordinary coefficient convolution. | |
| The output leg has `a + b - 1` coordinates. The definitions also make sense when | |
| an input dimension is zero, while the nonzero and full-output-support statements | |
| use the positive dimensions assumed in Section 5 of the paper. | |
| -/ | |
| open scoped BigOperators | |
| namespace MatrixMultiplication.AuxiliarySeparation | |
| open MatrixMultiplication.Foundation | |
| /-- The tensor `C(a,b)` of Section 5, in monomial coefficient coordinates. -/ | |
| def convolution (a b : ℕ) : Tensor ℂ (Fin a) (Fin b) (Fin (a + b - 1)) := | |
| fun i j k => if i.val + j.val = k.val then 1 else 0 | |
| @[simp] theorem convolution_apply (a b : ℕ) | |
| (i : Fin a) (j : Fin b) (k : Fin (a + b - 1)) : | |
| convolution a b i j k = if i.val + j.val = k.val then 1 else 0 := rfl | |
| @[simp] theorem convolution_ne_zero_iff {a b : ℕ} | |
| (i : Fin a) (j : Fin b) (k : Fin (a + b - 1)) : | |
| convolution a b i j k ≠ 0 ↔ i.val + j.val = k.val := by | |
| simp only [convolution] | |
| split_ifs <;> simp_all | |
| @[simp] theorem convolution_eq_one_iff {a b : ℕ} | |
| (i : Fin a) (j : Fin b) (k : Fin (a + b - 1)) : | |
| convolution a b i j k = 1 ↔ i.val + j.val = k.val := by | |
| simp only [convolution] | |
| split_ifs <;> simp_all | |
| @[simp] theorem convolution_eq_zero_iff {a b : ℕ} | |
| (i : Fin a) (j : Fin b) (k : Fin (a + b - 1)) : | |
| convolution a b i j k = 0 ↔ i.val + j.val ≠ k.val := by | |
| simp only [convolution] | |
| split_ifs <;> simp_all | |
| /-- Every pair of input monomials has a valid output coordinate. -/ | |
| def convolutionOutput {a b : ℕ} (i : Fin a) (j : Fin b) : Fin (a + b - 1) := | |
| ⟨i.val + j.val, by have hi := i.isLt; have hj := j.isLt; omega⟩ | |
| @[simp] theorem convolution_at_output {a b : ℕ} (i : Fin a) (j : Fin b) : | |
| convolution a b i j (convolutionOutput i j) = 1 := by | |
| simp [convolutionOutput] | |
| /-- Every output monomial of the expected degree occurs in the product. -/ | |
| theorem convolution_output_supported {a b : ℕ} (ha : 0 < a) (hb : 0 < b) | |
| (k : Fin (a + b - 1)) : | |
| ∃ (i : Fin a) (j : Fin b), convolution a b i j k = 1 := by | |
| by_cases hk : k.val < a | |
| · exact ⟨⟨k.val, hk⟩, ⟨0, hb⟩, by simp⟩ | |
| · have hk' := k.isLt | |
| refine ⟨⟨a - 1, by omega⟩, ⟨k.val - (a - 1), by omega⟩, ?_⟩ | |
| apply (convolution_eq_one_iff _ _ _).mpr | |
| dsimp | |
| omega | |
| theorem convolution_nonzero {a b : ℕ} (ha : 0 < a) (hb : 0 < b) : | |
| convolution a b ≠ 0 := by | |
| intro hz | |
| have hc := congrFun (congrFun (congrFun hz ⟨0, ha⟩) ⟨0, hb⟩) | |
| (convolutionOutput ⟨0, ha⟩ ⟨0, hb⟩) | |
| change convolution a b ⟨0, ha⟩ ⟨0, hb⟩ | |
| (convolutionOutput ⟨0, ha⟩ ⟨0, hb⟩) = 0 at hc | |
| rw [convolution_at_output] at hc | |
| exact one_ne_zero hc | |
| theorem convolution_nonzero_iff (a b : ℕ) : | |
| convolution a b ≠ 0 ↔ 0 < a ∧ 0 < b := by | |
| constructor | |
| · intro h | |
| constructor | |
| · by_contra ha | |
| have ha' : a = 0 := by omega | |
| subst a | |
| apply h | |
| funext i | |
| exact Fin.elim0 i | |
| · by_contra hb | |
| have hb' : b = 0 := by omega | |
| subst b | |
| apply h | |
| funext i j | |
| exact Fin.elim0 j | |
| · rintro ⟨ha, hb⟩ | |
| exact convolution_nonzero ha hb | |
| /-- Commuting the two inputs only casts the equal output dimensions. -/ | |
| theorem convolution_comm (a b : ℕ) (i : Fin a) (j : Fin b) | |
| (k : Fin (a + b - 1)) : | |
| convolution a b i j k = | |
| convolution b a j i (Fin.cast (by omega) k) := by | |
| simp only [convolution, Fin.val_cast, Nat.add_comm] | |
| /-- The boundary tensor `C(1,b)` has the coefficient matrix of a dot product. -/ | |
| theorem convolution_one_left (b : ℕ) (i : Fin 1) (j : Fin b) | |
| (k : Fin (1 + b - 1)) : | |
| convolution 1 b i j k = if j.val = k.val then 1 else 0 := by | |
| simp [convolution] | |
| /-- The other boundary tensor has the same coordinate identity. -/ | |
| theorem convolution_one_right (a : ℕ) (i : Fin a) (j : Fin 1) | |
| (k : Fin (a + 1 - 1)) : | |
| convolution a 1 i j k = if i.val = k.val then 1 else 0 := by | |
| simp [convolution] | |
| /-- Relabel the output of `C(1,b)` by its actual dimension `b`. -/ | |
| def convolutionOneOutputEquiv (b : ℕ) : Fin b ≃ Fin (1 + b - 1) := | |
| finCongr (by omega) | |
| /-- Relabel the single input coordinate of `C(1,b)` by `Unit`. -/ | |
| def convolutionOneInputEquiv : Unit ≃ Fin 1 where | |
| toFun _ := 0 | |
| invFun _ := () | |
| left_inv _ := rfl | |
| right_inv _i := Subsingleton.elim _ _ | |
| /-- `C(1,b)` is the dot-product tensor with the singleton on the first leg. -/ | |
| theorem convolution_one_left_dotPairing (b : ℕ) : | |
| Tensor.pullback convolutionOneInputEquiv (Equiv.refl (Fin b)) | |
| (convolutionOneOutputEquiv b) (convolution 1 b) = | |
| Tensor.cyclic (Tensor.cyclic (Tensor.dotPairing (K := ℂ) (Fin b))) := by | |
| funext i j k | |
| simp [Tensor.pullback, convolutionOneInputEquiv, convolutionOneOutputEquiv, | |
| Tensor.cyclic, Tensor.dotPairing, convolution, Fin.ext_iff] | |
| /-- Relabel the output of `C(a,1)` by its actual dimension `a`. -/ | |
| def convolutionRightOneOutputEquiv (a : ℕ) : Fin a ≃ Fin (a + 1 - 1) := | |
| finCongr (by omega) | |
| /-- `C(a,1)` is the dot-product tensor with the singleton on the second leg. -/ | |
| theorem convolution_one_right_dotPairing (a : ℕ) : | |
| Tensor.pullback (Equiv.refl (Fin a)) convolutionOneInputEquiv | |
| (convolutionRightOneOutputEquiv a) (convolution a 1) = | |
| Tensor.cyclic (Tensor.dotPairing (K := ℂ) (Fin a)) := by | |
| funext i j k | |
| simp [Tensor.pullback, convolutionOneInputEquiv, convolutionRightOneOutputEquiv, | |
| Tensor.cyclic, Tensor.dotPairing, convolution, Fin.ext_iff, eq_comm] | |
| /-- Contracting the coefficient tensor computes ordinary finite convolution. -/ | |
| theorem contract_convolution {a b : ℕ} (x : Fin a → ℂ) (y : Fin b → ℂ) | |
| (k : Fin (a + b - 1)) : | |
| Tensor.contract (convolution a b) x y k = | |
| ∑ i : Fin a, ∑ j : Fin b, | |
| if i.val + j.val = k.val then x i * y j else 0 := by | |
| simp [Tensor.contract, convolution, ite_mul] | |
| end MatrixMultiplication.AuxiliarySeparation | |
| end OAI | |