| import OAI.LinearAlgebra.Hadamard.CubeFibers |
|
|
| namespace OAI |
|
|
| /-! The dichotomy implied by the two Fourier product identities. -/ |
|
|
| open scoped BigOperators Matrix |
|
|
| namespace HadamardSix |
|
|
| def crossCharge : Charge := differenceCharge 2 0 3 |
|
|
| def sameCharge : Charge := differenceCharge 2 0 1 |
|
|
| lemma crossCharge_eq : crossCharge = ![2, 0, 0, -2, 0, 0] := by decide |
| lemma sameCharge_eq : sameCharge = ![2, -2, 0, 0, 0, 0] := by decide |
|
|
| private def pairOrdering : Index → Index → Index → Index := |
| ![ ![![0, 1, 2, 3, 4, 5], |
| ![0, 1, 2, 3, 4, 5], |
| ![0, 2, 1, 3, 4, 5], |
| ![0, 1, 2, 3, 4, 5], |
| ![0, 1, 2, 4, 3, 5], |
| ![0, 1, 2, 4, 5, 3]], |
| ![![1, 0, 2, 3, 4, 5], |
| ![0, 1, 2, 3, 4, 5], |
| ![2, 0, 1, 3, 4, 5], |
| ![1, 0, 2, 3, 4, 5], |
| ![1, 0, 2, 4, 3, 5], |
| ![1, 0, 2, 4, 5, 3]], |
| ![![1, 2, 0, 3, 4, 5], |
| ![2, 1, 0, 3, 4, 5], |
| ![0, 1, 2, 3, 4, 5], |
| ![1, 2, 0, 3, 4, 5], |
| ![1, 2, 0, 4, 3, 5], |
| ![1, 2, 0, 4, 5, 3]], |
| ![![3, 4, 5, 0, 1, 2], |
| ![4, 3, 5, 0, 1, 2], |
| ![4, 5, 3, 0, 1, 2], |
| ![0, 1, 2, 3, 4, 5], |
| ![3, 4, 5, 0, 1, 2], |
| ![3, 4, 5, 0, 2, 1]], |
| ![![3, 4, 5, 1, 0, 2], |
| ![4, 3, 5, 1, 0, 2], |
| ![4, 5, 3, 1, 0, 2], |
| ![3, 4, 5, 1, 0, 2], |
| ![0, 1, 2, 3, 4, 5], |
| ![3, 4, 5, 2, 0, 1]], |
| ![![3, 4, 5, 1, 2, 0], |
| ![4, 3, 5, 1, 2, 0], |
| ![4, 5, 3, 1, 2, 0], |
| ![3, 4, 5, 1, 2, 0], |
| ![3, 4, 5, 2, 1, 0], |
| ![0, 1, 2, 3, 4, 5]]] |
|
|
| private lemma pairOrdering_bijective (i j : Index) : |
| Function.Bijective (pairOrdering i j) := by |
| fin_cases i <;> fin_cases j <;> decide |
|
|
| lemma double_difference_transport (i j : Index) (hij : i ≠ j) : |
| ∃ (p : Equiv.Perm Index) (q : Charge), |
| (q = crossCharge ∨ q = sameCharge) ∧ |
| (permuteCharge p alpha = alpha ∨ permuteCharge p alpha = -alpha) ∧ |
| permuteCharge p q = differenceCharge 2 i j := by |
| let p := Equiv.ofBijective (pairOrdering i j) (pairOrdering_bijective i j) |
| refine ⟨p, if i.val / 3 = j.val / 3 then sameCharge else crossCharge, ?_, ?_, ?_⟩ |
| · split_ifs <;> simp |
| · fin_cases i <;> fin_cases j <;> decide |
| · fin_cases i <;> fin_cases j <;> first | exact (hij rfl).elim | decide |
|
|
| lemma dichotomy_of_product_identities {H : Matrix6} (hH : IsComplexHadamard H) |
| (hcross : ∀ p : Equiv.Perm Index, |
| g H (permuteCharge p alpha) * g H (permuteCharge p crossCharge) = 0) |
| (hsame : ∀ p : Equiv.Perm Index, |
| g H (permuteCharge p alpha) * g H (permuteCharge p sameCharge) = 0) : |
| (∀ p : Equiv.Perm Index, g H (permuteCharge p alpha) = 0) ∨ |
| IsComplexHadamard (entrywiseSquare H) := by |
| classical |
| by_cases hvanish : ∀ p : Equiv.Perm Index, g H (permuteCharge p alpha) = 0 |
| · exact Or.inl hvanish |
| right |
| push Not at hvanish |
| obtain ⟨p, hp⟩ := hvanish |
| let K : Matrix6 := fun i k => H (p.symm i) k |
| have hK : IsComplexHadamard K := hH.permute_rows p.symm |
| have hnonzero : g K alpha ≠ 0 := by |
| simpa [K, ← g_permuteCharge] using hp |
| have hnegative : g K (-alpha) ≠ 0 := by |
| rw [g_neg hK.1] |
| exact star_ne_zero.mpr hnonzero |
| have hc (q : Equiv.Perm Index) : |
| g K (permuteCharge q alpha) * g K (permuteCharge q crossCharge) = 0 := by |
| simpa only [K, ← g_permuteCharge, permuteCharge_trans] using hcross (p.trans q) |
| have hs (q : Equiv.Perm Index) : |
| g K (permuteCharge q alpha) * g K (permuteCharge q sameCharge) = 0 := by |
| simpa only [K, ← g_permuteCharge, permuteCharge_trans] using hsame (p.trans q) |
| have hKs : IsComplexHadamard (entrywiseSquare K) := by |
| apply (square_hadamard_iff hK.1).mpr |
| intro i j hij |
| obtain ⟨q, a, ha, hqa, hqx⟩ := double_difference_transport i j hij |
| have hprod : g K (permuteCharge q alpha) * g K (permuteCharge q a) = 0 := by |
| rcases ha with rfl | rfl |
| · exact hc q |
| · exact hs q |
| rw [hqx] at hprod |
| have hfirst : g K (permuteCharge q alpha) ≠ 0 := by |
| rcases hqa with hqa | hqa |
| · simpa only [hqa] using hnonzero |
| · simpa only [hqa] using hnegative |
| exact (mul_eq_zero.mp hprod).resolve_left hfirst |
| have hback := hKs.permute_rows p |
| change IsComplexHadamard (fun i k => H i k ^ 2) |
| simpa only [K, entrywiseSquare, Equiv.symm_apply_apply] using hback |
|
|
| end HadamardSix |
|
|
| end OAI |
|
|
