| import Mathlib |
| import OAI.LinearAlgebra.MatrixFields.Construction.ComplexRectangularASI |
| import OAI.LinearAlgebra.MatrixFields.Construction.ExactStatisticWords |
| import OAI.LinearAlgebra.MatrixFields.Construction.JointMaskedAssignment |
|
|
| namespace OAI |
|
|
| namespace MatrixAllFields |
|
|
| open scoped BigOperators Topology Polynomial |
|
|
| section |
| noncomputable section |
|
|
| open scoped BigOperators |
| open MatrixMultiplication.Foundation |
|
|
| namespace MatrixMultiplication.FieldCoefficientExtraction |
|
|
| variable {F X Y Z : Type*} |
|
|
| theorem coeff_triple [CommSemiring F] (a b c : Polynomial F) (d : ℕ) : |
| (a * b * c).coeff d = |
| ∑ i : Fin (d + 1), ∑ j : Fin (d + 1), |
| (if j.val ≤ d - i.val then a.coeff (d - i.val - j.val) else 0) * |
| b.coeff j.val * c.coeff i.val := by |
| classical |
| rw [show a * b * c = c * (b * a) by ring] |
| rw [Polynomial.coeff_mul, Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk] |
| rw [← Fin.sum_univ_eq_sum_range] |
| apply Finset.sum_congr rfl |
| intro i hi |
| rw [Polynomial.coeff_mul, Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk] |
| rw [Finset.mul_sum] |
| rw [Fin.sum_univ_eq_sum_range (fun j : ℕ => |
| (if j ≤ d - i.val then a.coeff (d - i.val - j) else 0) * |
| b.coeff j * c.coeff i.val) (d + 1)] |
| symm |
| calc |
| (∑ j ∈ Finset.range (d + 1), |
| (if j ≤ d - i.val then a.coeff (d - i.val - j) else 0) * |
| b.coeff j * c.coeff i.val) = |
| ∑ j ∈ Finset.range (d - i.val + 1), |
| (if j ≤ d - i.val then a.coeff (d - i.val - j) else 0) * |
| b.coeff j * c.coeff i.val := by |
| symm |
| apply Finset.sum_subset (Finset.range_mono (by omega)) |
| intro j hj hjnot |
| have h : ¬ j ≤ d - i.val := by |
| simpa only [Finset.mem_range, Nat.lt_succ_iff] using hjnot |
| simp [h] |
| _ = ∑ j ∈ Finset.range (d - i.val + 1), |
| c.coeff i.val * (b.coeff j * a.coeff (d - i.val - j)) := by |
| apply Finset.sum_congr rfl |
| intro j hj |
| rw [ite_eq_left (Nat.le_of_lt_succ (Finset.mem_range.mp hj))] |
| ring |
|
|
| theorem rankAtMost_coeff [CommSemiring F] |
| {P : Tensor (Polynomial F) X Y Z} {r : ℕ} |
| (hP : Tensor.RankAtMost P r) (d : ℕ) : |
| Tensor.RankAtMost (fun x y z => (P x y z).coeff d) ((d + 1) ^ 2 * r) := by |
| classical |
| rcases hP with ⟨a, b, c, rfl⟩ |
| let aa : (Fin r × Fin (d + 1) × Fin (d + 1)) → X → F := |
| fun v x => if v.2.2.val ≤ d - v.2.1.val then |
| (a v.1 x).coeff (d - v.2.1.val - v.2.2.val) else 0 |
| let bb : (Fin r × Fin (d + 1) × Fin (d + 1)) → Y → F := |
| fun v y => (b v.1 y).coeff v.2.2.val |
| let cc : (Fin r × Fin (d + 1) × Fin (d + 1)) → Z → F := |
| fun v z => (c v.1 z).coeff v.2.1.val |
| have heq : (fun x y z => (∑ j, Tensor.rankOne (a j) (b j) (c j) x y z).coeff d) = |
| fun x y z => ∑ v, Tensor.rankOne (aa v) (bb v) (cc v) x y z := by |
| funext x y z |
| simp only [Polynomial.finsetSum_coeff, Tensor.rankOne, Fintype.sum_prod_type, |
| coeff_triple, aa, bb, cc] |
| rw [heq] |
| simpa only [Fintype.card_prod, Fintype.card_fin, pow_two, Nat.mul_comm, |
| Nat.mul_left_comm, Nat.mul_assoc] using Tensor.rankAtMost_sum_rankOne aa bb cc |
|
|
| theorem rank_power [Field F] {T : Tensor F X Y Z} {r d D : ℕ} |
| (A : Tensor.PolynomialApproximation T r d D) (n : ℕ) : |
| Tensor.RankAtMost (Tensor.power T n) ((d * n + 1) ^ 2 * r ^ n) := by |
| have h := rankAtMost_coeff (A.power n).rank_bound (d * n) |
| 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] at h |
| exact h |
|
|
| end MatrixMultiplication.FieldCoefficientExtraction |
|
|
| end |
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open scoped BigOperators |
| open MatrixMultiplication.Foundation Polynomial |
|
|
| namespace MatrixMultiplication.FieldCW |
|
|
| section Integral |
|
|
| variable (F : Type*) [CommRing F] (q : ℕ) |
|
|
| def zeroForm (x : Fin (q + 2)) : F := if x.val = 0 then 1 else 0 |
|
|
| def interiorForm (i : Fin q) (x : Fin (q + 2)) : F := |
| if x.val = i.val + 1 then 1 else 0 |
|
|
| def lastForm (x : Fin (q + 2)) : F := if x.val = q + 1 then 1 else 0 |
|
|
| def interiorSum (x : Fin (q + 2)) : F := ∑ i, interiorForm F q i x |
|
|
| def tensor : Tensor F (Fin (q + 2)) (Fin (q + 2)) (Fin (q + 2)) := |
| fun x y z => |
| (∑ i : Fin q, |
| (zeroForm F q x * interiorForm F q i y * interiorForm F q i z + |
| interiorForm F q i x * zeroForm F q y * interiorForm F q i z + |
| interiorForm F q i x * interiorForm F q i y * zeroForm F q z)) + |
| lastForm F q x * zeroForm F q y * zeroForm F q z + |
| zeroForm F q x * lastForm F q y * zeroForm F q z + |
| zeroForm F q x * zeroForm F q y * lastForm F q z |
|
|
| theorem interior_pair_sum (x y : Fin (q + 2)) : |
| (∑ i : Fin q, interiorForm F q i x * interiorForm F q i y) = |
| if x = y ∧ 1 ≤ x.val ∧ x.val ≤ q then 1 else 0 := by |
| classical |
| by_cases hx : 1 ≤ x.val ∧ x.val ≤ q |
| · let i : Fin q := ⟨x.val - 1, by omega⟩ |
| rw [Finset.sum_eq_single i] |
| · simp [interiorForm, i, Nat.sub_add_cancel hx.1, hx.1, hx.2, |
| Fin.ext_iff, eq_comm] |
| · intro j hj hji |
| have hne : x.val ≠ j.val + 1 := by |
| intro h |
| apply hji |
| apply Fin.ext |
| dsimp [i] |
| omega |
| simp [interiorForm, hne] |
| · simp |
| · have hsum : (∑ i : Fin q, interiorForm F q i x * interiorForm F q i y) = 0 := by |
| apply Finset.sum_eq_zero |
| intro i hi |
| have hne : x.val ≠ i.val + 1 := by |
| intro h |
| apply hx |
| have := i.isLt |
| omega |
| simp [interiorForm, hne] |
| rw [hsum, ite_eq_right] |
| intro h |
| exact hx ⟨h.2.1, h.2.2⟩ |
|
|
| theorem tensor_zero_side (x y z : Fin (q + 2)) (hx : x.val = 0) : |
| tensor F q x y z = |
| if (y.val = 0 ∧ z.val = q + 1) ∨ |
| (y.val = q + 1 ∧ z.val = 0) ∨ |
| (1 ≤ y.val ∧ y.val ≤ q ∧ y = z) then 1 else 0 := by |
| have hx0 : zeroForm F q x = 1 := by simp [zeroForm, hx] |
| have hxlast : lastForm F q x = 0 := by simp [lastForm, hx] |
| have hxmid (i : Fin q) : interiorForm F q i x = 0 := by |
| simp [interiorForm, hx] |
| simp only [tensor, hx0, hxlast, hxmid, one_mul, zero_mul, add_zero] |
| rw [interior_pair_sum] |
| by_cases hy0 : y.val = 0 |
| · simp [zeroForm, lastForm, hy0] |
| · by_cases hylast : y.val = q + 1 |
| · have hyinter : ¬ y.val ≤ q := by omega |
| simp [zeroForm, lastForm, hylast] |
| · have hylo : 1 ≤ y.val := by omega |
| have hyhi : y.val ≤ q := by have := y.isLt; omega |
| simp [zeroForm, lastForm, hy0, hylast, hylo, hyhi] |
| |
| theorem tensor_cyclic (x y z : Fin (q + 2)) : |
| tensor F q x y z = tensor F q y z x := by |
| unfold tensor |
| have hsum : |
| (∑ i : Fin q, |
| (zeroForm F q x * interiorForm F q i y * interiorForm F q i z + |
| interiorForm F q i x * zeroForm F q y * interiorForm F q i z + |
| interiorForm F q i x * interiorForm F q i y * zeroForm F q z)) = |
| ∑ i : Fin q, |
| (zeroForm F q y * interiorForm F q i z * interiorForm F q i x + |
| interiorForm F q i y * zeroForm F q z * interiorForm F q i x + |
| interiorForm F q i y * interiorForm F q i z * zeroForm F q x) := by |
| apply Finset.sum_congr rfl |
| intro i hi |
| ring |
| rw [hsum] |
| ring |
|
|
| def form (e : ℕ) (u v : F) : Polynomial F := C u + X ^ e * C v |
|
|
| def left : Option (Option (Fin q)) → Fin (q + 2) → Polynomial F |
| | some (some i), x => X * form F 1 (zeroForm F q x) (interiorForm F q i x) |
| | some none, x => -form F 2 (zeroForm F q x) (interiorSum F q x) |
| | none, x => (1 - C (q : F) * X) * form F 3 (zeroForm F q x) (lastForm F q x) |
|
|
| def other : Option (Option (Fin q)) → Fin (q + 2) → Polynomial F |
| | some (some i), x => form F 1 (zeroForm F q x) (interiorForm F q i x) |
| | some none, x => form F 2 (zeroForm F q x) (interiorSum F q x) |
| | none, x => form F 3 (zeroForm F q x) (lastForm F q x) |
|
|
| def polynomial : Tensor (Polynomial F) (Fin (q + 2)) (Fin (q + 2)) (Fin (q + 2)) := |
| fun x y z => ∑ i, Tensor.rankOne (left F q i) (other F q i) (other F q i) x y z |
|
|
| theorem rank_bound : Tensor.RankAtMost (polynomial F q) (q + 2) := by |
| unfold polynomial |
| simpa only [Fintype.card_option, Fintype.card_fin, Nat.add_assoc, |
| Nat.reduceAdd] using |
| Tensor.rankAtMost_sum_rankOne (left F q) (other F q) (other F q) |
|
|
| theorem polynomial_apply (x y z : Fin (q + 2)) : |
| polynomial F q x y z = |
| (∑ i : Fin q, X * form F 1 (zeroForm F q x) (interiorForm F q i x) * |
| form F 1 (zeroForm F q y) (interiorForm F q i y) * |
| form F 1 (zeroForm F q z) (interiorForm F q i z)) - |
| form F 2 (zeroForm F q x) (interiorSum F q x) * |
| form F 2 (zeroForm F q y) (interiorSum F q y) * |
| form F 2 (zeroForm F q z) (interiorSum F q z) + |
| (1 - C (q : F) * X) * form F 3 (zeroForm F q x) (lastForm F q x) * |
| form F 3 (zeroForm F q y) (lastForm F q y) * |
| form F 3 (zeroForm F q z) (lastForm F q z) := by |
| simp only [polynomial, Fintype.sum_option, Tensor.rankOne, left, other] |
| ring |
|
|
| private theorem coeff_mul_two (a b : Polynomial F) : |
| (a * b).coeff 2 = a.coeff 0 * b.coeff 2 + a.coeff 1 * b.coeff 1 + |
| a.coeff 2 * b.coeff 0 := by |
| rw [Polynomial.coeff_mul, Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk] |
| simp [Finset.sum_range_succ, add_assoc] |
|
|
| private theorem coeff_mul_three (a b : Polynomial F) : |
| (a * b).coeff 3 = a.coeff 0 * b.coeff 3 + a.coeff 1 * b.coeff 2 + |
| a.coeff 2 * b.coeff 1 + a.coeff 3 * b.coeff 0 := by |
| rw [Polynomial.coeff_mul, Finset.Nat.sum_antidiagonal_eq_sum_range_succ_mk] |
| simp [Finset.sum_range_succ, add_assoc] |
|
|
| theorem vanishes (x y z : Fin (q + 2)) (k : ℕ) (hk : k < 3) : |
| (polynomial F q x y z).coeff k = 0 := by |
| interval_cases k <;> |
| simp [polynomial_apply, Polynomial.mul_coeff_zero, |
| Polynomial.mul_coeff_one, coeff_mul_two, form, Polynomial.coeff_add, |
| Polynomial.coeff_sub, interiorSum, |
| Polynomial.coeff_one, Polynomial.coeff_X, |
| Finset.sum_add_distrib, Finset.sum_mul, Finset.mul_sum] <;> |
| simp only [mul_assoc, mul_comm] <;> ring_nf |
| simp only [Finset.sum_add_distrib, Finset.mul_sum, mul_assoc, mul_comm] |
| ring |
| |
| theorem leading (x y z : Fin (q + 2)) : |
| (polynomial F q x y z).coeff 3 = tensor F q x y z := by |
| simp [polynomial_apply, Polynomial.mul_coeff_zero, |
| Polynomial.mul_coeff_one, coeff_mul_two, coeff_mul_three, form, |
| Polynomial.coeff_add, Polynomial.coeff_sub, |
| tensor, Polynomial.coeff_one, Polynomial.coeff_X, |
| Finset.sum_add_distrib] |
| simp only [mul_assoc, mul_comm, mul_left_comm] |
| ring_nf |
| simp only [Finset.sum_add_distrib, mul_assoc, mul_comm, mul_left_comm] |
| ring |
|
|
| def degreeBound : ℕ := Finset.univ.sup fun xyz : |
| Fin (q + 2) × Fin (q + 2) × Fin (q + 2) => |
| (polynomial F q xyz.1 xyz.2.1 xyz.2.2).natDegree |
|
|
| theorem degree_bound (x y z : Fin (q + 2)) : |
| (polynomial F q x y z).degree ≤ degreeBound F q := by |
| let f : (Fin (q + 2) × Fin (q + 2) × Fin (q + 2)) → ℕ := |
| fun xyz => (polynomial F q xyz.1 xyz.2.1 xyz.2.2).natDegree |
| have h := Finset.le_sup (s := Finset.univ) (f := f) (b := (x, y, z)) |
| (Finset.mem_univ (x, y, z)) |
| exact Polynomial.degree_le_of_natDegree_le h |
|
|
| end Integral |
|
|
| variable (F : Type*) [Field F] (q : ℕ) |
|
|
| def approximation : Tensor.PolynomialApproximation (tensor F q) (q + 2) 3 |
| (degreeBound F q) where |
| polynomial := polynomial F q |
| rank_bound := rank_bound F q |
| vanishes := vanishes F q |
| leading := leading F q |
| degree_bound := degree_bound F q |
|
|
| theorem rank_power (n : ℕ) : |
| Tensor.RankAtMost (Tensor.power (tensor F q) n) ((3 * n + 1) ^ 2 * (q + 2) ^ n) := |
| FieldCoefficientExtraction.rank_power (approximation F q) n |
|
|
| end MatrixMultiplication.FieldCW |
|
|
| end |
|
|
|
|
|
|
|
|
| namespace MatrixMultiplication.CWLeafRestrictions |
|
|
| open MatrixMultiplication.Foundation |
|
|
| def lastLabel (q : ℕ) : Fin (q + 2) := ⟨q + 1, by omega⟩ |
|
|
| def complement (q : ℕ) : Fin (q + 2) ≃ Fin (q + 2) := |
| Equiv.swap 0 (lastLabel q) |
|
|
| @[simp] theorem complement_zero (q : ℕ) : complement q 0 = lastLabel q := by |
| simp [complement] |
|
|
| @[simp] theorem complement_last (q : ℕ) : complement q (lastLabel q) = 0 := by |
| simp [complement] |
|
|
| @[simp] theorem complement_involution (q : ℕ) (x : Fin (q + 2)) : |
| complement q (complement q x) = x := by |
| simp [complement] |
|
|
| theorem complement_interior (q : ℕ) (x : Fin (q + 2)) |
| (hx0 : x.val ≠ 0) (hxlast : x.val ≠ q + 1) : complement q x = x := by |
| apply Equiv.swap_apply_of_ne_of_ne |
| · intro h |
| exact hx0 (congrArg Fin.val h) |
| · intro h |
| exact hxlast (congrArg Fin.val h) |
|
|
| theorem zero_support_iff (q : ℕ) (y z : Fin (q + 2)) : |
| ((y.val = 0 ∧ z.val = q + 1) ∨ |
| (y.val = q + 1 ∧ z.val = 0) ∨ |
| (1 ≤ y.val ∧ y.val ≤ q ∧ y = z)) ↔ complement q y = z := by |
| by_cases hy0 : y.val = 0 |
| · have hy : y = 0 := Fin.ext hy0 |
| subst y |
| rw [complement_zero] |
| constructor |
| · rintro (⟨_, hz⟩ | ⟨hy, _⟩ | ⟨hy, _⟩) |
| · exact Fin.ext hz.symm |
| · have : (0 : ℕ) = q + 1 := hy |
| omega |
| · have : 1 ≤ (0 : ℕ) := hy |
| omega |
| · intro h |
| exact Or.inl ⟨rfl, (congrArg Fin.val h).symm⟩ |
| · by_cases hylast : y.val = q + 1 |
| · have hy : y = lastLabel q := Fin.ext hylast |
| subst y |
| rw [complement_last] |
| constructor |
| · rintro (⟨hy, _⟩ | ⟨_, hz⟩ | ⟨_, hy, _⟩) |
| · have : q + 1 = 0 := hy |
| omega |
| · exact Fin.ext hz.symm |
| · have : q + 1 ≤ q := hy |
| omega |
| · intro h |
| exact Or.inr (Or.inl ⟨rfl, (congrArg Fin.val h).symm⟩) |
| · have hlo : 1 ≤ y.val := by omega |
| have hhi : y.val ≤ q := by have := y.isLt; omega |
| rw [complement_interior q y hy0 hylast] |
| simp [hy0, hylast, hlo, hhi] |
| |
| theorem tensor_zero_matching (F : Type*) [CommRing F] (q : ℕ) |
| (y z : Fin (q + 2)) : |
| FieldCW.tensor F q 0 y (complement q z) = if y = z then 1 else 0 := by |
| rw [FieldCW.tensor_zero_side F q 0 y (complement q z) rfl] |
| simp only [zero_support_iff, Equiv.apply_eq_iff_eq] |
|
|
| theorem tensor_middle_zero_matching (F : Type*) [CommRing F] (q : ℕ) |
| (x z : Fin (q + 2)) : |
| FieldCW.tensor F q x 0 (complement q z) = if x = z then 1 else 0 := by |
| rw [FieldCW.tensor_cyclic F q x 0 (complement q z)] |
| have h := tensor_zero_matching F q (complement q z) (complement q x) |
| simpa only [complement_involution, Equiv.apply_eq_iff_eq, eq_comm] using h |
|
|
| theorem tensor_last_zero_matching (F : Type*) [CommRing F] (q : ℕ) |
| (x y : Fin (q + 2)) : |
| FieldCW.tensor F q x (complement q y) 0 = if x = y then 1 else 0 := by |
| rw [FieldCW.tensor_cyclic F q x (complement q y) 0, |
| FieldCW.tensor_cyclic F q (complement q y) 0 x] |
| exact tensor_zero_matching F q x y |
|
|
| theorem zeroX_leaf (F : Type*) [CommRing F] (q n : ℕ) |
| (p : (Fin n → Fin (q + 2)) → Prop) [DecidablePred p] : |
| Tensor.pullback (fun _ : Unit × Unit => fun _ : Fin n => (0 : Fin (q + 2))) |
| (fun y : Unit × {w // p w} => y.2.val) |
| (fun z : {w // p w} × Unit => fun i => complement q (z.1.val i)) |
| (Tensor.power (FieldCW.tensor F q) n) = |
| Tensor.matrixCoefficients Unit Unit {w // p w} := |
| LeafVolumes.matchingPower_matrixCoefficients (FieldCW.tensor F q) 0 |
| (complement q) (tensor_zero_matching F q) n p |
|
|
| theorem zeroY_leaf (F : Type*) [CommRing F] (q n : ℕ) |
| (p : (Fin n → Fin (q + 2)) → Prop) [DecidablePred p] : |
| Tensor.pullback (fun x : {w // p w} × Unit => x.1.val) |
| (fun _ : Unit × Unit => fun _ : Fin n => (0 : Fin (q + 2))) |
| (fun z : Unit × {w // p w} => fun i => complement q (z.2.val i)) |
| (Tensor.power (FieldCW.tensor F q) n) = |
| Tensor.matrixCoefficients {w // p w} Unit Unit := by |
| funext x y z |
| simp only [Tensor.pullback, Tensor.power, tensor_middle_zero_matching, |
| Fintype.prod_boole, ← funext_iff, Tensor.matrixCoefficients] |
| simp [Subtype.ext_iff, eq_comm] |
|
|
| theorem zeroZ_leaf (F : Type*) [CommRing F] (q n : ℕ) |
| (p : (Fin n → Fin (q + 2)) → Prop) [DecidablePred p] : |
| Tensor.pullback (fun x : Unit × {w // p w} => x.2.val) |
| (fun y : {w // p w} × Unit => fun i => complement q (y.1.val i)) |
| (fun _ : Unit × Unit => fun _ : Fin n => (0 : Fin (q + 2))) |
| (Tensor.power (FieldCW.tensor F q) n) = |
| Tensor.matrixCoefficients Unit {w // p w} Unit := by |
| funext x y z |
| simp only [Tensor.pullback, Tensor.power, tensor_last_zero_matching, |
| Fintype.prod_boole, ← funext_iff, Tensor.matrixCoefficients] |
| simp [Subtype.ext_iff] |
|
|
| end MatrixMultiplication.CWLeafRestrictions |
|
|
|
|
|
|
|
|
|
|
| namespace MatrixMultiplication.CWLeafStatistics |
|
|
| open MatrixMultiplication.Foundation |
|
|
| def weight (x : Fin 7) : ℕ := if x.val = 0 then 0 else if x.val = 6 then 2 else 1 |
|
|
| def pairStatistic (x : Fin 7 × Fin 7) : Fin 6 := |
| if weight x.1 + weight x.2 = 0 then 0 |
| else if weight x.1 + weight x.2 = 1 then 1 |
| else if weight x.1 + weight x.2 = 2 then |
| if weight x.1 = 1 ∧ weight x.2 = 1 then 2 else 3 |
| else if weight x.1 + weight x.2 = 3 then 4 else 5 |
|
|
| theorem statistic_weight : ∀ x : Fin 7 × Fin 7, |
| AllFieldParameters.statisticWeight (pairStatistic x) = weight x.1 + weight x.2 := by |
| decide +kernel |
|
|
| theorem pair_multiplicity : ∀ i : Fin 6, |
| Fintype.card {x : Fin 7 × Fin 7 // pairStatistic x = i} = |
| AllFieldParameters.multiplicity i := by |
| decide +kernel |
|
|
| theorem complement_weight : ∀ x : Fin 7, |
| weight (CWLeafRestrictions.complement 5 x) + weight x = 2 := by |
| decide +kernel |
|
|
| theorem complement_statistic : ∀ x : Fin 7 × Fin 7, |
| pairStatistic (CWLeafRestrictions.complement 5 x.1, |
| CWLeafRestrictions.complement 5 x.2) = |
| AllFieldParameters.kappa (pairStatistic x) := by |
| decide +kernel |
|
|
| theorem ordered_pair_multiplicity (i j : Fin 6) : |
| Fintype.card {x : (Fin 7 × Fin 7) × (Fin 7 × Fin 7) // |
| pairStatistic x.1 = i ∧ pairStatistic x.2 = j} = |
| AllFieldParameters.multiplicity i * AllFieldParameters.multiplicity j := by |
| let e : {x : (Fin 7 × Fin 7) × (Fin 7 × Fin 7) // |
| pairStatistic x.1 = i ∧ pairStatistic x.2 = j} ≃ |
| {x : Fin 7 × Fin 7 // pairStatistic x = i} × |
| {x : Fin 7 × Fin 7 // pairStatistic x = j} := |
| { toFun := fun x => (⟨x.val.1, x.property.1⟩, ⟨x.val.2, x.property.2⟩) |
| invFun := fun x => ⟨(x.1.val, x.2.val), x.1.property, x.2.property⟩ |
| left_inv := by intro x; rfl |
| right_inv := by intro x; rfl } |
| rw [Fintype.card_congr e, Fintype.card_prod, pair_multiplicity, pair_multiplicity] |
| |
| end MatrixMultiplication.CWLeafStatistics |
| |
| |
| |
| |
| |
| noncomputable section |
| |
| namespace MatrixMultiplication.CWCompatibilityTransfer |
| |
| open MatrixMultiplication.Foundation CWLeafRestrictions InheritedMasks |
| open scoped BigOperators |
| |
| def wordWeight {n : ℕ} (w : Fin n → Fin 7) : ℕ := ∑ i, CWLeafStatistics.weight (w i) |
|
|
| def wordComplement {n : ℕ} (w : Fin n → Fin 7) : Fin n → Fin 7 := |
| fun i => complement 5 (w i) |
|
|
| @[simp] theorem wordComplement_involution {n : ℕ} (w : Fin n → Fin 7) : |
| wordComplement (wordComplement w) = w := by |
| funext i |
| exact complement_involution 5 (w i) |
|
|
| theorem weight_eq_zero_iff : ∀ x : Fin 7, CWLeafStatistics.weight x = 0 ↔ x = 0 := by |
| decide +kernel |
|
|
| theorem wordWeight_zero {n : ℕ} (w : Fin n → Fin 7) (h : wordWeight w = 0) : |
| ∀ i, w i = 0 := by |
| intro i |
| have hle : CWLeafStatistics.weight (w i) ≤ wordWeight w := by |
| unfold wordWeight |
| exact Finset.single_le_sum (fun j _ => Nat.zero_le (CWLeafStatistics.weight (w j))) |
| (Finset.mem_univ i) |
| apply (weight_eq_zero_iff (w i)).mp |
| omega |
|
|
| theorem site_nonzero {F : Type*} [CommRing F] {n : ℕ} |
| (x y z : Fin n → Fin 7) |
| (h : Tensor.power (FieldCW.tensor F 5) n x y z ≠ 0) (i : Fin n) : |
| FieldCW.tensor F 5 (x i) (y i) (z i) ≠ 0 := by |
| intro hi |
| apply h |
| exact Finset.prod_eq_zero (Finset.mem_univ i) hi |
|
|
| theorem zeroX_word_match {F : Type*} [CommRing F] {n : ℕ} |
| (x y z : Fin n → Fin 7) |
| (h : Tensor.power (FieldCW.tensor F 5) n x y z ≠ 0) |
| (hx : wordWeight x = 0) : z = wordComplement y := by |
| funext i |
| have hi := site_nonzero x y z h i |
| rw [wordWeight_zero x hx i] at hi |
| have heq : FieldCW.tensor F 5 0 (y i) (z i) = |
| if y i = complement 5 (z i) then 1 else 0 := by |
| simpa only [complement_involution] using |
| tensor_zero_matching F 5 (y i) (complement 5 (z i)) |
| have hyz : y i = complement 5 (z i) := by |
| by_contra hn |
| rw [heq, ite_eq_right hn] at hi |
| exact hi rfl |
| have hh := congrArg (complement 5) hyz |
| simpa only [wordComplement, complement_involution] using hh.symm |
|
|
| theorem zeroY_word_match {F : Type*} [CommRing F] {n : ℕ} |
| (x y z : Fin n → Fin 7) |
| (h : Tensor.power (FieldCW.tensor F 5) n x y z ≠ 0) |
| (hy : wordWeight y = 0) : z = wordComplement x := by |
| funext i |
| have hi := site_nonzero x y z h i |
| rw [wordWeight_zero y hy i] at hi |
| have heq : FieldCW.tensor F 5 (x i) 0 (z i) = |
| if x i = complement 5 (z i) then 1 else 0 := by |
| simpa only [complement_involution] using |
| tensor_middle_zero_matching F 5 (x i) (complement 5 (z i)) |
| have hxz : x i = complement 5 (z i) := by |
| by_contra hn |
| rw [heq, ite_eq_right hn] at hi |
| exact hi rfl |
| have hh := congrArg (complement 5) hxz |
| simpa only [wordComplement, complement_involution] using hh.symm |
|
|
| theorem zeroZ_word_match {F : Type*} [CommRing F] {n : ℕ} |
| (x y z : Fin n → Fin 7) |
| (h : Tensor.power (FieldCW.tensor F 5) n x y z ≠ 0) |
| (hz : wordWeight z = 0) : y = wordComplement x := by |
| funext i |
| have hi := site_nonzero x y z h i |
| rw [wordWeight_zero z hz i] at hi |
| have heq : FieldCW.tensor F 5 (x i) (y i) 0 = |
| if x i = complement 5 (y i) then 1 else 0 := by |
| simpa only [complement_involution] using |
| tensor_last_zero_matching F 5 (x i) (complement 5 (y i)) |
| have hxy : x i = complement 5 (y i) := by |
| by_contra hn |
| rw [heq, ite_eq_right hn] at hi |
| exact hi rfl |
| have hh := congrArg (complement 5) hxy |
| simpa only [wordComplement, complement_involution] using hh.symm |
|
|
| theorem transfer_window {P A : Type*} [Fintype P] [DecidableEq P] |
| [Fintype A] [DecidableEq A] {n : ℕ} |
| (statistic : (Fin n → Fin 7) → A) (κ : A ≃ A) |
| (hstatistic : ∀ w, statistic (wordComplement w) = κ (statistic w)) |
| (x y : P → (Fin n → Fin 7)) (hmatch : ∀ i, y i = wordComplement (x i)) |
| (ν : A → ℝ) (η : ℝ) |
| (hx : typeWindow ν η (fun i => statistic (x i))) : |
| typeWindow (ν ∘ κ.symm) η (fun i => statistic (y i)) := by |
| have heq : (fun i => statistic (y i)) = κ ∘ (fun i => statistic (x i)) := by |
| funext i |
| rw [hmatch i, hstatistic] |
| rfl |
| rw [heq] |
| exact (typeWindow_equiv ν η (fun i => statistic (x i)) κ).mpr hx |
|
|
| end MatrixMultiplication.CWCompatibilityTransfer |
|
|
|
|
|
|
|
|
|
|
|
|
| namespace MatrixMultiplication.CWStrands |
|
|
| open MatrixMultiplication.Foundation |
| open scoped BigOperators |
|
|
| variable {F : Type*} [CommRing F] |
|
|
| theorem site_weight_support (x y z : Fin 7) |
| (h : FieldCW.tensor F 5 x y z ≠ 0) : |
| CWLeafStatistics.weight x + CWLeafStatistics.weight y + CWLeafStatistics.weight z = 2 := by |
| have hzero (a b : Fin 7) (hh : FieldCW.tensor F 5 0 a b ≠ 0) : |
| CWLeafStatistics.weight a + CWLeafStatistics.weight b = 2 := by |
| have he := CWLeafRestrictions.tensor_zero_matching F 5 a |
| (CWLeafRestrictions.complement 5 b) |
| simp only [CWLeafRestrictions.complement_involution] at he |
| by_cases hm : a = CWLeafRestrictions.complement 5 b |
| · subst a |
| exact CWLeafStatistics.complement_weight b |
| · rw [ite_eq_right hm] at he |
| exact False.elim (hh he) |
| by_cases hx : x = 0 |
| · subst x |
| simpa [CWLeafStatistics.weight] using hzero y z h |
| by_cases hy : y = 0 |
| · subst y |
| have hh : FieldCW.tensor F 5 0 z x ≠ 0 := by |
| rwa [← FieldCW.tensor_cyclic] |
| have hw := hzero z x hh |
| simp only [CWLeafStatistics.weight, Fin.val_zero, ite_eq_left, add_zero] at * |
| omega |
| by_cases hz : z = 0 |
| · subst z |
| have hh : FieldCW.tensor F 5 0 x y ≠ 0 := by |
| rwa [FieldCW.tensor_cyclic] |
| have hw := hzero x y hh |
| simpa [CWLeafStatistics.weight] using hw |
| have hx0 : x.val ≠ 0 := by simpa only [Fin.ext_iff, Fin.val_zero] using hx |
| have hy0 : y.val ≠ 0 := by simpa only [Fin.ext_iff, Fin.val_zero] using hy |
| have hz0 : z.val ≠ 0 := by simpa only [Fin.ext_iff, Fin.val_zero] using hz |
| apply False.elim (h _) |
| simp only [FieldCW.tensor, FieldCW.zeroForm, hx0, hy0, hz0, ite_false, |
| zero_mul, mul_zero, add_zero, Finset.sum_const_zero] |
|
|
| def weight {P : Type*} [Fintype P] (w : P → Fin 7) : ℕ := |
| ∑ i, CWLeafStatistics.weight (w i) |
|
|
| def strand (P : Type*) [Fintype P] : Tensor F (P → Fin 7) (P → Fin 7) (P → Fin 7) := |
| fun x y z => ∏ i, FieldCW.tensor F 5 (x i) (y i) (z i) |
|
|
| theorem strand_support {P : Type*} [Fintype P] |
| (x y z : P → Fin 7) (h : strand (F := F) P x y z ≠ 0) : |
| weight x + weight y + weight z = 2 * Fintype.card P := by |
| have hi (i : P) : FieldCW.tensor F 5 (x i) (y i) (z i) ≠ 0 := by |
| intro he |
| exact h (Finset.prod_eq_zero (Finset.mem_univ i) he) |
| calc |
| weight x + weight y + weight z = |
| ∑ i, (CWLeafStatistics.weight (x i) + CWLeafStatistics.weight (y i) + |
| CWLeafStatistics.weight (z i)) := by simp [weight, Finset.sum_add_distrib] |
| _ = ∑ _i : P, 2 := Finset.sum_congr rfl (fun i _ => site_weight_support _ _ _ (hi i)) |
| _ = 2 * Fintype.card P := by simp [Nat.mul_comm] |
|
|
| def shapeTensor (P : Type*) [Fintype P] (g : Fin 3 → ℕ) : |
| Tensor F (P → Fin 7) (P → Fin 7) (P → Fin 7) := |
| fun x y z => if weight x = g 0 ∧ weight y = g 1 ∧ weight z = g 2 |
| then strand P x y z else 0 |
|
|
| theorem shapeTensor_support {P : Type*} [Fintype P] |
| (g : Fin 3 → ℕ) (x y z : P → Fin 7) |
| (h : shapeTensor (F := F) P g x y z ≠ 0) : |
| weight x = g 0 ∧ weight y = g 1 ∧ weight z = g 2 := by |
| classical |
| by_contra hn |
| exact h (ite_eq_right hn) |
|
|
| theorem weight_sum_elim {P Q : Type*} [Fintype P] [Fintype Q] |
| (x : P → Fin 7) (y : Q → Fin 7) : |
| weight (Sum.elim x y) = weight x + weight y := by |
| simp [weight, Fintype.sum_sum_type] |
|
|
| theorem strand_sum_elim {P Q : Type*} [Fintype P] [Fintype Q] |
| (x : (P → Fin 7) × (Q → Fin 7)) |
| (y : (P → Fin 7) × (Q → Fin 7)) |
| (z : (P → Fin 7) × (Q → Fin 7)) : |
| strand (F := F) (P ⊕ Q) (Sum.elim x.1 x.2) (Sum.elim y.1 y.2) (Sum.elim z.1 z.2) = |
| Tensor.product (strand P) (strand Q) x y z := by |
| simp [strand, Tensor.product, Fintype.prod_sum_type] |
|
|
| theorem shape_split {P Q : Type*} [Fintype P] [Fintype Q] |
| (u v : Fin 3 → ℕ) |
| (x : (P → Fin 7) × (Q → Fin 7)) |
| (y : (P → Fin 7) × (Q → Fin 7)) |
| (z : (P → Fin 7) × (Q → Fin 7)) : |
| (if weight x.1 = u 0 ∧ weight y.1 = u 1 ∧ weight z.1 = u 2 then |
| shapeTensor (F := F) (P ⊕ Q) (u + v) (Sum.elim x.1 x.2) (Sum.elim y.1 y.2) |
| (Sum.elim z.1 z.2) else 0) = |
| Tensor.product (shapeTensor P u) (shapeTensor Q v) x y z := by |
| classical |
| simp only [shapeTensor, weight_sum_elim, Pi.add_apply, strand_sum_elim, |
| Tensor.product] |
| by_cases hx : weight x.1 = u 0 |
| · by_cases hy : weight y.1 = u 1 |
| · by_cases hz : weight z.1 = u 2 |
| · simp [hx, hy, hz, mul_ite] |
| · simp [hz] |
| · simp [hy] |
| · simp [hx] |
|
|
| theorem shape_split_sub {P Q : Type*} [Fintype P] [Fintype Q] |
| (g u : Fin 3 → ℕ) (hu : ∀ s, u s ≤ g s) |
| (x : (P → Fin 7) × (Q → Fin 7)) |
| (y : (P → Fin 7) × (Q → Fin 7)) |
| (z : (P → Fin 7) × (Q → Fin 7)) : |
| (if weight x.1 = u 0 ∧ weight y.1 = u 1 ∧ weight z.1 = u 2 then |
| shapeTensor (F := F) (P ⊕ Q) g (Sum.elim x.1 x.2) (Sum.elim y.1 y.2) |
| (Sum.elim z.1 z.2) else 0) = |
| Tensor.product (shapeTensor P u) (shapeTensor Q (g - u)) x y z := by |
| have hg : u + (g - u) = g := by |
| funext s |
| exact Nat.add_sub_of_le (hu s) |
| simpa only [hg] using shape_split u (g - u) x y z |
|
|
| def splitMatrix {P Q : Type*} [Fintype P] (u : ℕ) : |
| ((P → Fin 7) × (Q → Fin 7)) → ((P ⊕ Q) → Fin 7) → F := by |
| classical |
| exact fun x w => if w = Sum.elim x.1 x.2 ∧ weight x.1 = u then 1 else 0 |
|
|
| theorem shape_split_restrict {P Q : Type*} [Fintype P] [Fintype Q] |
| [DecidableEq P] [DecidableEq Q] (u v : Fin 3 → ℕ) : |
| Tensor.restrict (splitMatrix (F := F) (u 0)) (splitMatrix (u 1)) (splitMatrix (u 2)) |
| (shapeTensor (P ⊕ Q) (u + v)) = |
| Tensor.product (shapeTensor P u) (shapeTensor Q v) := by |
| classical |
| funext x y z |
| have hcollapse : Tensor.restrict (splitMatrix (F := F) (u 0)) |
| (splitMatrix (u 1)) (splitMatrix (u 2)) (shapeTensor (P ⊕ Q) (u + v)) x y z = |
| if weight x.1 = u 0 ∧ weight y.1 = u 1 ∧ weight z.1 = u 2 then |
| shapeTensor (P ⊕ Q) (u + v) (Sum.elim x.1 x.2) (Sum.elim y.1 y.2) |
| (Sum.elim z.1 z.2) else 0 := by |
| simp [Tensor.restrict, splitMatrix, ite_and, ite_mul, mul_ite] |
| split_ifs <;> simp_all |
| rw [hcollapse] |
| exact shape_split u v x y z |
| |
| end MatrixMultiplication.CWStrands |
| |
| |
| |
| |
| |
| |
| namespace MatrixMultiplication.CWCoarseIndices |
| |
| open MatrixMultiplication.Foundation CWStrands |
| open scoped BigOperators |
| |
| theorem label_weight_le_two : ∀ x : Fin 7, CWLeafStatistics.weight x ≤ 2 := by |
| decide +kernel |
|
|
| theorem weight_le {P : Type*} [Fintype P] (w : P → Fin 7) : |
| weight w ≤ 2 * Fintype.card P := by |
| calc |
| weight w ≤ ∑ _i : P, 2 := Finset.sum_le_sum fun i _ => label_weight_le_two (w i) |
| _ = _ := by simp [Nat.mul_comm] |
|
|
| def coarseIndex {P : Type*} [Fintype P] (hP : Fintype.card P ≤ 8) |
| (w : P → Fin 7) : Fin 17 := ⟨weight w, by have := weight_le w; omega⟩ |
| |
| theorem strand_coarse_support {F P : Type*} [CommRing F] [Fintype P] |
| (hP : Fintype.card P ≤ 8) (x y z : P → Fin 7) |
| (h : strand (F := F) P x y z ≠ 0) : |
| (coarseIndex hP x).val + (coarseIndex hP y).val + (coarseIndex hP z).val = |
| 2 * Fintype.card P := strand_support x y z h |
|
|
| theorem split_coarse_support {F P Q : Type*} [CommRing F] [Fintype P] [Fintype Q] |
| (hP : Fintype.card P ≤ 8) (g : Fin 3 → ℕ) |
| (x : (P → Fin 7) × (Q → Fin 7)) |
| (y : (P → Fin 7) × (Q → Fin 7)) |
| (z : (P → Fin 7) × (Q → Fin 7)) |
| (h : shapeTensor (F := F) (P ⊕ Q) g (Sum.elim x.1 x.2) |
| (Sum.elim y.1 y.2) (Sum.elim z.1 z.2) ≠ 0) : |
| ((coarseIndex hP x.1).val + (coarseIndex hP y.1).val + |
| (coarseIndex hP z.1).val = 2 * Fintype.card P) ∧ |
| (coarseIndex hP x.1).val ≤ g 0 ∧ (coarseIndex hP y.1).val ≤ g 1 ∧ |
| (coarseIndex hP z.1).val ≤ g 2 := by |
| have hshape := shapeTensor_support g _ _ _ h |
| have ht : strand (F := F) (P ⊕ Q) (Sum.elim x.1 x.2) |
| (Sum.elim y.1 y.2) (Sum.elim z.1 z.2) ≠ 0 := by |
| simpa only [shapeTensor, ite_eq_left hshape] using h |
| rw [strand_sum_elim, Tensor.product] at ht |
| have hl : strand (F := F) P x.1 y.1 z.1 ≠ 0 := by |
| intro he |
| exact ht (by rw [he, zero_mul]) |
| refine ⟨strand_coarse_support hP x.1 y.1 z.1 hl, ?_, ?_, ?_⟩ |
| · have hs := hshape.1 |
| rw [weight_sum_elim] at hs |
| exact hs ▸ Nat.le_add_right (weight x.1) (weight x.2) |
| · have hs := hshape.2.1 |
| rw [weight_sum_elim] at hs |
| exact hs ▸ Nat.le_add_right (weight y.1) (weight y.2) |
| · have hs := hshape.2.2 |
| rw [weight_sum_elim] at hs |
| exact hs ▸ Nat.le_add_right (weight z.1) (weight z.2) |
|
|
| end MatrixMultiplication.CWCoarseIndices |
|
|
|
|
|
|
|
|
|
|
|
|
| namespace MatrixMultiplication.JointCanonicalCW |
|
|
| open MatrixMultiplication.Foundation JointPopulation JointCanonicalization |
| open CWStrands HistorySymmetry InheritedMasks |
| open scoped BigOperators |
|
|
| attribute [local instance] Classical.propDecidable |
|
|
| variable {H F : Type*} [Fintype H] [DecidableEq H] [CommRing F] |
| (counts : H → Shape → ℕ) (leftLength rightLength : H → ℕ) |
| (parentShape : H → Fin 3 → ℕ) |
| (hleft : ∀ h, leftLength h ≤ 8) |
|
|
| abbrev Left (h : H) := Fin (leftLength h) → Fin 7 |
| abbrev Right (h : H) := Fin (rightLength h) → Fin 7 |
|
|
| def shapeNat (u : Shape) : Fin 3 → ℕ := fun s => (shapeSide s u).val |
|
|
| def parentTensor (h : H) : Tensor F |
| (Left leftLength h × Right rightLength h) |
| (Left leftLength h × Right rightLength h) |
| (Left leftLength h × Right rightLength h) := |
| fun x y z => shapeTensor (Fin (leftLength h) ⊕ Fin (rightLength h)) (parentShape h) |
| (Sum.elim x.1 x.2) (Sum.elim y.1 y.2) (Sum.elim z.1 z.2) |
|
|
| def coarse (_s : Fin 3) (h : H) (w : Left leftLength h × Right rightLength h) : Fin 17 := |
| CWCoarseIndices.coarseIndex (by simpa using hleft h) w.1 |
|
|
| def leftTensor (c : ClassKey (H := H)) : |
| Tensor F (Left leftLength c.1) (Left leftLength c.1) (Left leftLength c.1) := |
| shapeTensor (Fin (leftLength c.1)) (shapeNat c.2) |
|
|
| def rightTensor (c : ClassKey (H := H)) : |
| Tensor F (Right rightLength c.1) (Right rightLength c.1) (Right rightLength c.1) := |
| shapeTensor (Fin (rightLength c.1)) (parentShape c.1 - shapeNat c.2) |
|
|
| omit [Fintype H] [DecidableEq H] in |
| theorem block_eq_product (h : H) (u : Shape) |
| (hu : ∀ s, shapeNat u s ≤ parentShape h s) : |
| block (Left leftLength) (Right rightLength) |
| (parentTensor leftLength rightLength parentShape) |
| (coarse leftLength rightLength hleft) (h, u) = |
| Tensor.product (leftTensor (F := F) leftLength (h, u)) |
| (rightTensor rightLength parentShape (h, u)) := by |
| have hadd : shapeNat u + (parentShape h - shapeNat u) = parentShape h := by |
| funext s |
| exact Nat.add_sub_of_le (hu s) |
| funext x y z |
| have hs := shape_split (F := F) (P := Fin (leftLength h)) |
| (Q := Fin (rightLength h)) (shapeNat u) (parentShape h - shapeNat u) x y z |
| rw [hadd] at hs |
| simpa [block, parentTensor, coarse, CWCoarseIndices.coarseIndex, |
| Fin.ext_iff, leftTensor, rightTensor, shapeNat, shapeSide, |
| Fin.isValue, ↓reduceIte] using hs |
|
|
| omit [DecidableEq H] in |
| theorem canonicalBase_eq_children |
| (hsupport : ∀ h u, 0 < counts h u → ∀ s, shapeNat u s ≤ parentShape h s) : |
| canonicalBase counts (Left leftLength) (Right rightLength) |
| (parentTensor leftLength rightLength parentShape) |
| (coarse leftLength rightLength hleft) = |
| pairClassProduct (leftTensor (F := F) leftLength) |
| (rightTensor rightLength parentShape) := by |
| funext x y z |
| unfold canonicalBase |
| have hf : (∏ c : ClassKey (H := H), ∏ j : ClassPositions counts c, |
| block (Left leftLength) (Right rightLength) |
| (parentTensor leftLength rightLength parentShape) |
| (coarse leftLength rightLength hleft) c |
| (x.left c j, x.right c j) (y.left c j, y.right c j) (z.left c j, z.right c j)) = |
| ∏ c : ClassKey (H := H), ∏ j : ClassPositions counts c, |
| (leftTensor (F := F) leftLength c (x.left c j) (y.left c j) (z.left c j) * |
| rightTensor rightLength parentShape c (x.right c j) (y.right c j) (z.right c j)) := by |
| apply Finset.prod_congr rfl |
| intro c _ |
| apply Finset.prod_congr rfl |
| intro j _ |
| have hc : 0 < counts c.1 c.2 := lt_of_le_of_lt (Nat.zero_le j.val) j.isLt |
| rw [block_eq_product leftLength rightLength parentShape hleft c.1 c.2 |
| (hsupport c.1 c.2 hc)] |
| rfl |
| rw [hf] |
| simp only [pairClassProduct, classProduct, Finset.prod_mul_distrib] |
|
|
| abbrev RawStrands := ∀ h, Positions counts h → |
| ((Fin (leftLength h) ⊕ Fin (rightLength h)) → Fin 7) |
|
|
| def rawParentSource : Tensor F (RawStrands counts leftLength rightLength) |
| (RawStrands counts leftLength rightLength) (RawStrands counts leftLength rightLength) := |
| classProduct (fun h => shapeTensor (Fin (leftLength h) ⊕ Fin (rightLength h)) (parentShape h)) |
|
|
| def joinWords (w : RawPairs counts (Left leftLength) (Right rightLength)) : |
| RawStrands counts leftLength rightLength := |
| fun h i => Sum.elim (w h i).1 (w h i).2 |
|
|
| def joinMatrix : RawPairs counts (Left leftLength) (Right rightLength) → |
| RawStrands counts leftLength rightLength → F := |
| fun w v => if v = joinWords counts leftLength rightLength w then 1 else 0 |
|
|
| theorem parentTensor_restrict : |
| Tensor.restrict (joinMatrix (F := F) counts leftLength rightLength) |
| (joinMatrix counts leftLength rightLength) (joinMatrix counts leftLength rightLength) |
| (rawParentSource counts leftLength rightLength parentShape) = |
| sourceTensor counts (Left leftLength) (Right rightLength) |
| (parentTensor leftLength rightLength parentShape) := by |
| classical |
| funext x y z |
| simp [Tensor.restrict, joinMatrix, rawParentSource, sourceTensor, |
| classProduct, joinWords, parentTensor, ite_mul, mul_ite] |
|
|
| end MatrixMultiplication.JointCanonicalCW |
|
|
|
|
|
|
|
|
|
|
|
|
| namespace MatrixMultiplication.CWShapeLeaves |
|
|
| open MatrixMultiplication.Foundation CWStrands CWLeafRestrictions |
| open scoped BigOperators |
|
|
| theorem complement_word_weight {P : Type*} [Fintype P] (w : P → Fin 7) : |
| weight (fun i => complement 5 (w i)) + weight w = 2 * Fintype.card P := by |
| calc |
| weight (fun i => complement 5 (w i)) + weight w = |
| ∑ i, (CWLeafStatistics.weight (complement 5 (w i)) + CWLeafStatistics.weight (w i)) := by |
| simp [weight, Finset.sum_add_distrib] |
| _ = ∑ _i : P, 2 := Finset.sum_congr rfl (fun i _ => CWLeafStatistics.complement_weight (w i)) |
| _ = 2 * Fintype.card P := by simp [Nat.mul_comm] |
|
|
| theorem zeroX_shape_leaf (F : Type*) [CommRing F] (n a b : ℕ) |
| (hab : a + b = 2 * n) |
| (p : (Fin n → Fin 7) → Prop) [DecidablePred p] |
| (hp : ∀ w, p w → weight w = a) : |
| Tensor.pullback (fun _ : Unit × Unit => fun _ : Fin n => (0 : Fin 7)) |
| (fun y : Unit × {w // p w} => y.2.val) |
| (fun z : {w // p w} × Unit => fun i => complement 5 (z.1.val i)) |
| (shapeTensor (F := F) (Fin n) (Matrix.vecCons (0) (Matrix.vecCons (a) (Matrix.vecCons (b) Matrix.vecEmpty)))) = |
| Tensor.matrixCoefficients Unit Unit {w // p w} := by |
| funext x y z |
| have hy : weight y.2.val = a := hp _ y.2.property |
| have hz : weight (fun i => complement 5 (z.1.val i)) = b := by |
| have hw := complement_word_weight z.1.val |
| have hzw : weight z.1.val = a := hp _ z.1.property |
| simp only [Fintype.card_fin] at hw |
| omega |
| have hzero : weight (fun _ : Fin n => (0 : Fin 7)) = 0 := by |
| simp [weight, CWLeafStatistics.weight] |
| have hleaf := congrFun (congrFun (congrFun (zeroX_leaf F 5 n p) x) y) z |
| simpa [Tensor.pullback, shapeTensor, hzero, hy, hz, strand, Tensor.power] using hleaf |
|
|
| theorem zeroY_shape_leaf (F : Type*) [CommRing F] (n a b : ℕ) |
| (hab : a + b = 2 * n) |
| (p : (Fin n → Fin 7) → Prop) [DecidablePred p] |
| (hp : ∀ w, p w → weight w = a) : |
| Tensor.pullback (fun x : {w // p w} × Unit => x.1.val) |
| (fun _ : Unit × Unit => fun _ : Fin n => (0 : Fin 7)) |
| (fun z : Unit × {w // p w} => fun i => complement 5 (z.2.val i)) |
| (shapeTensor (F := F) (Fin n) (Matrix.vecCons (a) (Matrix.vecCons (0) (Matrix.vecCons (b) Matrix.vecEmpty)))) = |
| Tensor.matrixCoefficients {w // p w} Unit Unit := by |
| funext x y z |
| have hx : weight x.1.val = a := hp _ x.1.property |
| have hz : weight (fun i => complement 5 (z.2.val i)) = b := by |
| have hw := complement_word_weight z.2.val |
| have hzw : weight z.2.val = a := hp _ z.2.property |
| simp only [Fintype.card_fin] at hw |
| omega |
| have hzero : weight (fun _ : Fin n => (0 : Fin 7)) = 0 := by |
| simp [weight, CWLeafStatistics.weight] |
| have hleaf := congrFun (congrFun (congrFun (zeroY_leaf F 5 n p) x) y) z |
| simpa [Tensor.pullback, shapeTensor, hzero, hx, hz, strand, Tensor.power] using hleaf |
|
|
| theorem zeroZ_shape_leaf (F : Type*) [CommRing F] (n a b : ℕ) |
| (hab : a + b = 2 * n) |
| (p : (Fin n → Fin 7) → Prop) [DecidablePred p] |
| (hp : ∀ w, p w → weight w = a) : |
| Tensor.pullback (fun x : Unit × {w // p w} => x.2.val) |
| (fun y : {w // p w} × Unit => fun i => complement 5 (y.1.val i)) |
| (fun _ : Unit × Unit => fun _ : Fin n => (0 : Fin 7)) |
| (shapeTensor (F := F) (Fin n) (Matrix.vecCons (a) (Matrix.vecCons (b) (Matrix.vecCons (0) Matrix.vecEmpty)))) = |
| Tensor.matrixCoefficients Unit {w // p w} Unit := by |
| funext x y z |
| have hx : weight x.2.val = a := hp _ x.2.property |
| have hy : weight (fun i => complement 5 (y.1.val i)) = b := by |
| have hw := complement_word_weight y.1.val |
| have hyw : weight y.1.val = a := hp _ y.1.property |
| simp only [Fintype.card_fin] at hw |
| omega |
| have hzero : weight (fun _ : Fin n => (0 : Fin 7)) = 0 := by |
| simp [weight, CWLeafStatistics.weight] |
| have hleaf := congrFun (congrFun (congrFun (zeroZ_leaf F 5 n p) x) y) z |
| simpa [Tensor.pullback, shapeTensor, hzero, hx, hy, strand, Tensor.power] using hleaf |
|
|
| end MatrixMultiplication.CWShapeLeaves |
|
|
|
|
|
|
|
|
|
|
|
|
| namespace MatrixMultiplication.CWWindowedLeaves |
|
|
| open MatrixMultiplication.Foundation CWStrands CWShapeLeaves CWLeafRestrictions InheritedMasks |
| open scoped BigOperators |
|
|
| attribute [local instance] Classical.propDecidable |
|
|
| abbrev Raw (n : ℕ) := Fin n → Fin 7 |
| abbrev Alphabet (n a : ℕ) := {w : Raw n // weight w = a} |
|
|
| def complementWord {n : ℕ} (w : Raw n) : Raw n := fun i => complement 5 (w i) |
| def zeroWord (n : ℕ) : Raw n := fun _ => 0 |
|
|
| variable (F : Type*) [CommRing F] |
|
|
| theorem zeroX_local (n a b : ℕ) (hab : a + b = 2 * n) |
| (u v : Alphabet n a) : |
| shapeTensor (F := F) (Fin n) (Matrix.vecCons (0) (Matrix.vecCons (a) (Matrix.vecCons (b) Matrix.vecEmpty))) (zeroWord n) u.val (complementWord v.val) = |
| if u = v then 1 else 0 := by |
| unfold zeroWord complementWord |
| have h := zeroX_shape_leaf F n a b hab (fun w => weight w = a) (fun _ h => h) |
| have hh := congrFun (congrFun (congrFun h ((), ())) ((), u)) (v, ()) |
| simpa only [Tensor.pullback, Tensor.matrixCoefficients, |
| true_and, and_true] using hh |
|
|
| theorem zeroY_local (n a b : ℕ) (hab : a + b = 2 * n) |
| (u v : Alphabet n a) : |
| shapeTensor (F := F) (Fin n) (Matrix.vecCons (a) (Matrix.vecCons (0) (Matrix.vecCons (b) Matrix.vecEmpty))) u.val (zeroWord n) (complementWord v.val) = |
| if u = v then 1 else 0 := by |
| unfold zeroWord complementWord |
| have h := zeroY_shape_leaf F n a b hab (fun w => weight w = a) (fun _ h => h) |
| have hh := congrFun (congrFun (congrFun h (u, ())) ((), ())) ((), v) |
| have huv : (v = u) ↔ (u = v) := eq_comm |
| simpa only [Tensor.pullback, Tensor.matrixCoefficients, |
| true_and, and_true, huv] using hh |
|
|
| theorem zeroZ_local (n a b : ℕ) (hab : a + b = 2 * n) |
| (u v : Alphabet n a) : |
| shapeTensor (F := F) (Fin n) (Matrix.vecCons (a) (Matrix.vecCons (b) (Matrix.vecCons (0) Matrix.vecEmpty))) u.val (complementWord v.val) (zeroWord n) = |
| if u = v then 1 else 0 := by |
| unfold zeroWord complementWord |
| have h := zeroZ_shape_leaf F n a b hab (fun w => weight w = a) (fun _ h => h) |
| have hh := congrFun (congrFun (congrFun h ((), u)) (v, ())) ((), ()) |
| simpa only [Tensor.pullback, Tensor.matrixCoefficients, |
| true_and, and_true] using hh |
|
|
| section Classes |
|
|
| variable (n a b m : ℕ) (hab : a + b = 2 * n) |
| (p : (Fin m → Alphabet n a) → Prop) [DecidablePred p] |
|
|
| def rawSelected (w : {w : Fin m → Alphabet n a // p w}) : Fin m → Raw n := |
| fun i => (w.val i).val |
|
|
| def complementarySelected (w : {w : Fin m → Alphabet n a // p w}) : Fin m → Raw n := |
| fun i => complementWord (w.val i).val |
|
|
| include hab |
|
|
| omit [DecidablePred p] in |
| theorem zeroX_class : |
| Tensor.pullback (fun _ : Unit × Unit => fun _ : Fin m => zeroWord n) |
| (fun y : Unit × {w // p w} => rawSelected n a m p y.2) |
| (fun z : {w // p w} × Unit => complementarySelected n a m p z.1) |
| (Tensor.power (shapeTensor (F := F) (Fin n) (Matrix.vecCons (0) (Matrix.vecCons (a) (Matrix.vecCons (b) Matrix.vecEmpty)))) m) = |
| Tensor.matrixCoefficients Unit Unit {w // p w} := by |
| funext x y z |
| simp only [Tensor.pullback, Tensor.power, rawSelected, complementarySelected, |
| zeroX_local F n a b hab, Fintype.prod_boole, ← funext_iff, Tensor.matrixCoefficients] |
| simp [Subtype.ext_iff] |
|
|
| omit [DecidablePred p] in |
| theorem zeroY_class : |
| Tensor.pullback (fun x : {w // p w} × Unit => rawSelected n a m p x.1) |
| (fun _ : Unit × Unit => fun _ : Fin m => zeroWord n) |
| (fun z : Unit × {w // p w} => complementarySelected n a m p z.2) |
| (Tensor.power (shapeTensor (F := F) (Fin n) (Matrix.vecCons (a) (Matrix.vecCons (0) (Matrix.vecCons (b) Matrix.vecEmpty)))) m) = |
| Tensor.matrixCoefficients {w // p w} Unit Unit := by |
| funext x y z |
| simp only [Tensor.pullback, Tensor.power, rawSelected, complementarySelected, |
| zeroY_local F n a b hab, Fintype.prod_boole, ← funext_iff, Tensor.matrixCoefficients] |
| simp [Subtype.ext_iff, eq_comm] |
|
|
| omit [DecidablePred p] in |
| theorem zeroZ_class : |
| Tensor.pullback (fun x : Unit × {w // p w} => rawSelected n a m p x.2) |
| (fun y : {w // p w} × Unit => complementarySelected n a m p y.1) |
| (fun _ : Unit × Unit => fun _ : Fin m => zeroWord n) |
| (Tensor.power (shapeTensor (F := F) (Fin n) (Matrix.vecCons (a) (Matrix.vecCons (b) (Matrix.vecCons (0) Matrix.vecEmpty)))) m) = |
| Tensor.matrixCoefficients Unit {w // p w} Unit := by |
| funext x y z |
| simp only [Tensor.pullback, Tensor.power, rawSelected, complementarySelected, |
| zeroZ_local F n a b hab, Fintype.prod_boole, ← funext_iff, Tensor.matrixCoefficients] |
| simp [Subtype.ext_iff] |
|
|
| omit [DecidablePred p] in |
| theorem zeroX_masked |
| (keepX keepY keepZ : (Fin m → Raw n) → Prop) |
| (hx : keepX (fun _ => zeroWord n)) |
| (hy : ∀ w, keepY (rawSelected n a m p w)) |
| (hz : ∀ w, keepZ (complementarySelected n a m p w)) : |
| Tensor.pullback (fun _ : Unit × Unit => fun _ : Fin m => zeroWord n) |
| (fun y : Unit × {w // p w} => rawSelected n a m p y.2) |
| (fun z : {w // p w} × Unit => complementarySelected n a m p z.1) |
| (ExactRecovery.delete (Tensor.power (shapeTensor (F := F) (Fin n) (Matrix.vecCons (0) (Matrix.vecCons (a) (Matrix.vecCons (b) Matrix.vecEmpty)))) m) |
| keepX keepY keepZ) = Tensor.matrixCoefficients Unit Unit {w // p w} := by |
| have h := zeroX_class F n a b m hab p |
| funext x y z |
| simpa only [Tensor.pullback, ExactRecovery.delete, hx, hy, hz, and_self, ite_true] using |
| congrFun (congrFun (congrFun h x) y) z |
|
|
| omit [DecidablePred p] in |
| theorem zeroY_masked |
| (keepX keepY keepZ : (Fin m → Raw n) → Prop) |
| (hx : ∀ w, keepX (rawSelected n a m p w)) |
| (hy : keepY (fun _ => zeroWord n)) |
| (hz : ∀ w, keepZ (complementarySelected n a m p w)) : |
| Tensor.pullback (fun x : {w // p w} × Unit => rawSelected n a m p x.1) |
| (fun _ : Unit × Unit => fun _ : Fin m => zeroWord n) |
| (fun z : Unit × {w // p w} => complementarySelected n a m p z.2) |
| (ExactRecovery.delete (Tensor.power (shapeTensor (F := F) (Fin n) (Matrix.vecCons (a) (Matrix.vecCons (0) (Matrix.vecCons (b) Matrix.vecEmpty)))) m) |
| keepX keepY keepZ) = Tensor.matrixCoefficients {w // p w} Unit Unit := by |
| have h := zeroY_class F n a b m hab p |
| funext x y z |
| simpa only [Tensor.pullback, ExactRecovery.delete, hx, hy, hz, and_self, ite_true] using |
| congrFun (congrFun (congrFun h x) y) z |
|
|
| omit [DecidablePred p] in |
| theorem zeroZ_masked |
| (keepX keepY keepZ : (Fin m → Raw n) → Prop) |
| (hx : ∀ w, keepX (rawSelected n a m p w)) |
| (hy : ∀ w, keepY (complementarySelected n a m p w)) |
| (hz : keepZ (fun _ => zeroWord n)) : |
| Tensor.pullback (fun x : Unit × {w // p w} => rawSelected n a m p x.2) |
| (fun y : {w // p w} × Unit => complementarySelected n a m p y.1) |
| (fun _ : Unit × Unit => fun _ : Fin m => zeroWord n) |
| (ExactRecovery.delete (Tensor.power (shapeTensor (F := F) (Fin n) (Matrix.vecCons (a) (Matrix.vecCons (b) (Matrix.vecCons (0) Matrix.vecEmpty)))) m) |
| keepX keepY keepZ) = Tensor.matrixCoefficients Unit {w // p w} Unit := by |
| have h := zeroZ_class F n a b m hab p |
| funext x y z |
| simpa only [Tensor.pullback, ExactRecovery.delete, hx, hy, hz, and_self, ite_true] using |
| congrFun (congrFun (congrFun h x) y) z |
|
|
| omit [DecidablePred p] in |
| theorem zeroX_restriction |
| (keepX keepY keepZ : (Fin m → Raw n) → Prop) |
| (hx : keepX (fun _ => zeroWord n)) |
| (hy : ∀ w, keepY (rawSelected n a m p w)) |
| (hz : ∀ w, keepZ (complementarySelected n a m p w)) : |
| ∃ (A : (Unit × Unit) → (Fin m → Raw n) → F) |
| (B : (Unit × {w // p w}) → (Fin m → Raw n) → F) |
| (C : ({w // p w} × Unit) → (Fin m → Raw n) → F), |
| Tensor.restrict A B C |
| (ExactRecovery.delete (Tensor.power (shapeTensor (F := F) (Fin n) (Matrix.vecCons (0) (Matrix.vecCons (a) (Matrix.vecCons (b) Matrix.vecEmpty)))) m) |
| keepX keepY keepZ) = Tensor.matrixCoefficients Unit Unit {w // p w} := by |
| refine ⟨(fun _ v => if v = (fun _ => zeroWord n) then 1 else 0), |
| (fun y v => if v = rawSelected n a m p y.2 then 1 else 0), |
| (fun z v => if v = complementarySelected n a m p z.1 then 1 else 0), ?_⟩ |
| rw [← Tensor.pullback_eq_restrict] |
| exact zeroX_masked F n a b m hab p keepX keepY keepZ hx hy hz |
|
|
| omit [DecidablePred p] in |
| theorem zeroY_restriction |
| (keepX keepY keepZ : (Fin m → Raw n) → Prop) |
| (hx : ∀ w, keepX (rawSelected n a m p w)) |
| (hy : keepY (fun _ => zeroWord n)) |
| (hz : ∀ w, keepZ (complementarySelected n a m p w)) : |
| ∃ (A : ({w // p w} × Unit) → (Fin m → Raw n) → F) |
| (B : (Unit × Unit) → (Fin m → Raw n) → F) |
| (C : (Unit × {w // p w}) → (Fin m → Raw n) → F), |
| Tensor.restrict A B C |
| (ExactRecovery.delete (Tensor.power (shapeTensor (F := F) (Fin n) (Matrix.vecCons (a) (Matrix.vecCons (0) (Matrix.vecCons (b) Matrix.vecEmpty)))) m) |
| keepX keepY keepZ) = Tensor.matrixCoefficients {w // p w} Unit Unit := by |
| refine ⟨(fun x v => if v = rawSelected n a m p x.1 then 1 else 0), |
| (fun _ v => if v = (fun _ => zeroWord n) then 1 else 0), |
| (fun z v => if v = complementarySelected n a m p z.2 then 1 else 0), ?_⟩ |
| rw [← Tensor.pullback_eq_restrict] |
| exact zeroY_masked F n a b m hab p keepX keepY keepZ hx hy hz |
|
|
| omit [DecidablePred p] in |
| theorem zeroZ_restriction |
| (keepX keepY keepZ : (Fin m → Raw n) → Prop) |
| (hx : ∀ w, keepX (rawSelected n a m p w)) |
| (hy : ∀ w, keepY (complementarySelected n a m p w)) |
| (hz : keepZ (fun _ => zeroWord n)) : |
| ∃ (A : (Unit × {w // p w}) → (Fin m → Raw n) → F) |
| (B : ({w // p w} × Unit) → (Fin m → Raw n) → F) |
| (C : (Unit × Unit) → (Fin m → Raw n) → F), |
| Tensor.restrict A B C |
| (ExactRecovery.delete (Tensor.power (shapeTensor (F := F) (Fin n) (Matrix.vecCons (a) (Matrix.vecCons (b) (Matrix.vecCons (0) Matrix.vecEmpty)))) m) |
| keepX keepY keepZ) = Tensor.matrixCoefficients Unit {w // p w} Unit := by |
| refine ⟨(fun x v => if v = rawSelected n a m p x.2 then 1 else 0), |
| (fun y v => if v = complementarySelected n a m p y.1 then 1 else 0), |
| (fun _ v => if v = (fun _ => zeroWord n) then 1 else 0), ?_⟩ |
| rw [← Tensor.pullback_eq_restrict] |
| exact zeroZ_masked F n a b m hab p keepX keepY keepZ hx hy hz |
|
|
| end Classes |
|
|
| section ExactWindows |
|
|
| variable {A : Type*} [Fintype A] [DecidableEq A] |
|
|
| theorem exact_selected_window (n a : ℕ) (statistic : Raw n → A) |
| (counts : A → ℕ) (ν : A → ℝ) (η : ℝ) |
| (happrox : ∀ s, |(counts s : ℝ) / (∑ s, counts s : ℕ) - ν s| ≤ η) |
| (w : ExactStatisticWords.Words (fun u : Alphabet n a => statistic u.val) counts) : |
| typeWindow ν η (fun i => statistic (w.val i).val) := |
| ExactStatisticWords.typeWindow_of_counts _ counts w ν η happrox |
|
|
| theorem exact_complementary_window (n a : ℕ) (statistic : Raw n → A) |
| (κ : A ≃ A) |
| (hstatistic : ∀ u : Alphabet n a, statistic (complementWord u.val) = κ (statistic u.val)) |
| (counts : A → ℕ) (ν : A → ℝ) (η : ℝ) |
| (happrox : ∀ s, |(counts s : ℝ) / (∑ s, counts s : ℕ) - ν s| ≤ η) |
| (w : ExactStatisticWords.Words (fun u : Alphabet n a => statistic u.val) counts) : |
| typeWindow (ν ∘ κ.symm) η (fun i => statistic (complementWord (w.val i).val)) := by |
| have heq : (fun i => statistic (complementWord (w.val i).val)) = |
| κ ∘ (fun i => statistic (w.val i).val) := by |
| funext i |
| exact hstatistic (w.val i) |
| rw [heq] |
| exact (typeWindow_equiv ν η _ κ).mpr |
| (exact_selected_window n a statistic counts ν η happrox w) |
|
|
| omit [Fintype A] in |
| theorem zero_window (n m : ℕ) (hm : 0 < m) (statistic : Raw n → A) |
| (ν : A → ℝ) (η : ℝ) (hη : 0 ≤ η) |
| (hν : ∀ s, ν s = if statistic (zeroWord n) = s then 1 else 0) : |
| typeWindow ν η (fun _ : Fin m => statistic (zeroWord n)) := by |
| intro s |
| have hm' : (m : ℝ) ≠ 0 := by exact_mod_cast (Nat.ne_of_gt hm) |
| by_cases hs : statistic (zeroWord n) = s <;> |
| simpa [empiricalLaw, wordPopulation, hν s, hs, hm'] using hη |
| |
| end ExactWindows |
| |
| end MatrixMultiplication.CWWindowedLeaves |
| |
| |
| |
| |
| |
| |
| namespace MatrixMultiplication.CWCompleteStatistics |
| |
| open CWWindowedLeaves CWLeafStatistics CWStrands AllFieldParameters |
| open scoped BigOperators |
| |
| attribute [local instance] Classical.propDecidable |
| |
| def pairEquiv : Raw 2 ≃ (Fin 7 × Fin 7) where |
| toFun w := (w 0, w 1) |
| invFun u := (Matrix.vecCons (u.1) (Matrix.vecCons (u.2) Matrix.vecEmpty)) |
| left_inv w := by funext i; fin_cases i <;> rfl |
| right_inv u := by cases u; rfl |
| |
| def orderedEquiv : Raw 4 ≃ ((Fin 7 × Fin 7) × (Fin 7 × Fin 7)) where |
| toFun w := ((w 0, w 1), (w 2, w 3)) |
| invFun u := (Matrix.vecCons (u.1.1) (Matrix.vecCons (u.1.2) (Matrix.vecCons (u.2.1) (Matrix.vecCons (u.2.2) Matrix.vecEmpty)))) |
| left_inv w := by funext i; fin_cases i <;> rfl |
| right_inv u := by cases u with | mk u v => cases u; cases v; rfl |
| |
| def twoStatistic (w : Raw 2) : Fin 6 := pairStatistic (pairEquiv w) |
| def fourStatistic (w : Raw 4) : Fin 6 × Fin 6 := |
| (pairStatistic (orderedEquiv w).1, pairStatistic (orderedEquiv w).2) |
|
|
| def complementStatistic : Fin 6 ≃ Fin 6 := |
| { toFun := kappa |
| invFun := kappa |
| left_inv := kappa_involution |
| right_inv := kappa_involution } |
|
|
| def orderedComplementStatistic : (Fin 6 × Fin 6) ≃ (Fin 6 × Fin 6) := |
| Equiv.prodCongr complementStatistic complementStatistic |
|
|
| theorem two_weight (w : Raw 2) : |
| CWStrands.weight w = statisticWeight (twoStatistic w) := by |
| rw [twoStatistic, statistic_weight] |
| simp [CWStrands.weight, pairEquiv, Fin.sum_univ_succ] |
|
|
| theorem four_weight (w : Raw 4) : |
| CWStrands.weight w = statisticWeight (fourStatistic w).1 + |
| statisticWeight (fourStatistic w).2 := by |
| simp only [fourStatistic, statistic_weight] |
| simp [CWStrands.weight, orderedEquiv, Fin.sum_univ_succ, Nat.add_assoc] |
|
|
| theorem two_multiplicity (s : Fin 6) : |
| Fintype.card {w : Raw 2 // twoStatistic w = s} = AllFieldParameters.multiplicity s := by |
| let e : {w : Raw 2 // twoStatistic w = s} ≃ |
| {u : Fin 7 × Fin 7 // pairStatistic u = s} := |
| { toFun := fun w => ⟨pairEquiv w.val, w.property⟩ |
| invFun := fun u => ⟨pairEquiv.symm u.val, by simpa [twoStatistic] using u.property⟩ |
| left_inv := by intro w; apply Subtype.ext; simp |
| right_inv := by intro u; apply Subtype.ext; simp } |
| rw [Fintype.card_congr e, pair_multiplicity] |
| |
| theorem four_multiplicity (s : Fin 6 × Fin 6) : |
| Fintype.card {w : Raw 4 // fourStatistic w = s} = |
| AllFieldParameters.multiplicity s.1 * AllFieldParameters.multiplicity s.2 := by |
| let e : {w : Raw 4 // fourStatistic w = s} ≃ |
| {u : (Fin 7 × Fin 7) × (Fin 7 × Fin 7) // |
| pairStatistic u.1 = s.1 ∧ pairStatistic u.2 = s.2} := |
| { toFun := fun w => ⟨orderedEquiv w.val, |
| congrArg Prod.fst w.property, congrArg Prod.snd w.property⟩ |
| invFun := fun u => ⟨orderedEquiv.symm u.val, by |
| apply Prod.ext |
| · simpa [fourStatistic] using u.property.1 |
| · simpa [fourStatistic] using u.property.2⟩ |
| left_inv := by intro w; apply Subtype.ext; simp |
| right_inv := by intro u; apply Subtype.ext; simp } |
| rw [Fintype.card_congr e, ordered_pair_multiplicity] |
| |
| theorem two_complement (w : Raw 2) : |
| twoStatistic (complementWord w) = complementStatistic (twoStatistic w) := by |
| exact complement_statistic (pairEquiv w) |
|
|
| theorem four_complement (w : Raw 4) : |
| fourStatistic (complementWord w) = orderedComplementStatistic (fourStatistic w) := by |
| apply Prod.ext |
| · exact complement_statistic (orderedEquiv w).1 |
| · exact complement_statistic (orderedEquiv w).2 |
|
|
| theorem two_fixedWeight_multiplicity (a : ℕ) (s : Fin 6) (hs : statisticWeight s = a) : |
| Fintype.card {w : Alphabet 2 a // twoStatistic w.val = s} = |
| AllFieldParameters.multiplicity s := by |
| rw [ExactStatisticWords.card_fixedWeight_fiber twoStatistic CWStrands.weight |
| statisticWeight two_weight a s hs, two_multiplicity] |
|
|
| theorem four_fixedWeight_multiplicity (a : ℕ) (s : Fin 6 × Fin 6) |
| (hs : statisticWeight s.1 + statisticWeight s.2 = a) : |
| Fintype.card {w : Alphabet 4 a // fourStatistic w.val = s} = |
| AllFieldParameters.multiplicity s.1 * AllFieldParameters.multiplicity s.2 := by |
| rw [ExactStatisticWords.card_fixedWeight_fiber fourStatistic CWStrands.weight |
| (fun s => statisticWeight s.1 + statisticWeight s.2) four_weight a s hs, |
| four_multiplicity] |
|
|
| end MatrixMultiplication.CWCompleteStatistics |
|
|
| end |
| end |
|
|
| end MatrixAllFields |
|
|
| end OAI |
|
|
