| import Mathlib |
| import OAI.RepresentationTheory.Unitary.Basic |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder |
| attribute [local instance] Classical.propDecidable |
|
|
| namespace CoordinateSweeps |
|
|
| namespace SignedTensor |
|
|
| /- p even basis symbols followed by p odd ones, exactly E⊕O in05. -/ |
| abbrev Letter (p : ℕ) := Fin (2*p) |
| abbrev Word (p l : ℕ) := Fin l → Letter p |
|
|
| def odd {p : ℕ} (a : Letter p) : Prop := p ≤ a.val |
|
|
| /- The sign from reordering the odd factors, with positions ordered as in |
| ordinary tensor words. There is no choice of orientation hidden here. -/ |
| def koszulExponent {p l : ℕ} (σ : Equiv.Perm (Fin l)) (w : Word p l) : ℕ := |
| ((Equiv.Perm.finPairsLT l).filter (fun ij => |
| odd (w ij.1) ∧ odd (w ij.2) ∧ σ ij.1 < σ ij.2)).card |
|
|
| def phase {p l : ℕ} (σ : Equiv.Perm (Fin l)) (w : Word p l) : ℂ := |
| (-1)^koszulExponent σ w |
|
|
| /- The underlying ordinary slot permutation; gh applies h first. -/ |
| def wordPerm {p l : ℕ} (σ : Equiv.Perm (Fin l)) : Equiv.Perm (Word p l) where |
| toFun w i := w (σ⁻¹ i) |
| invFun w i := w (σ i) |
| left_inv w := by funext i; simp |
| right_inv w := by funext i; simp |
|
|
| /- Matrix of the exact parity-signed action in the tensor word basis. -/ |
| def matrix {p l : ℕ} (σ : Equiv.Perm (Fin l)) : Matrix (Word p l) (Word p l) ℂ := |
| fun u w => if u=wordPerm σ w then phase σ w else 0 |
|
|
| lemma phase_star_mul {p l : ℕ} (σ : Equiv.Perm (Fin l)) (w : Word p l) : |
| star (phase σ w)*phase σ w=1 := by |
| simp only [phase,star_pow,star_neg,star_one] |
| rw [← mul_pow] |
| simp |
|
|
| lemma phase_prod {p l : ℕ} (σ : Equiv.Perm (Fin l)) (w : Word p l) : |
| phase σ w = ∏ ij ∈ Equiv.Perm.finPairsLT l, |
| (if odd (w ij.1) ∧ odd (w ij.2) ∧ σ ij.1 < σ ij.2 then (-1 : ℂ) else 1) := by |
| rw [Finset.prod_ite] |
| simp [phase,koszulExponent] |
|
|
| lemma wordPerm_mul {p l : ℕ} (σ τ : Equiv.Perm (Fin l)) : |
| wordPerm (p := p) (σ*τ) = wordPerm σ * wordPerm τ := by |
| ext w i |
| simp [wordPerm] |
|
|
| /- The exact Koszul cocycle, proved from pair inversions, not an action axiom. -/ |
| theorem phase_mul {p l : ℕ} (σ τ : Equiv.Perm (Fin l)) (w : Word p l) : |
| phase (σ*τ) w = phase σ (wordPerm τ w) * phase τ w := by |
| rw [phase_prod,phase_prod,phase_prod] |
| have hreindex : |
| (∏ ij ∈ Equiv.Perm.finPairsLT l, |
| (if odd (wordPerm τ w ij.1) ∧ odd (wordPerm τ w ij.2) ∧ σ ij.1 < σ ij.2 |
| then (-1 : ℂ) else 1)) = |
| ∏ ij ∈ Equiv.Perm.finPairsLT l, |
| (if odd (wordPerm τ w (Equiv.Perm.signBijAux τ ij).1) ∧ |
| odd (wordPerm τ w (Equiv.Perm.signBijAux τ ij).2) ∧ |
| σ (Equiv.Perm.signBijAux τ ij).1 < σ (Equiv.Perm.signBijAux τ ij).2 |
| then (-1 : ℂ) else 1) := by |
| symm |
| exact Finset.prod_nbij (Equiv.Perm.signBijAux τ) |
| Equiv.Perm.signBijAux_mem Equiv.Perm.signBijAux_injOn |
| Equiv.Perm.signBijAux_surj (fun _ _ => rfl) |
| rw [hreindex,← Finset.prod_mul_distrib] |
| apply Finset.prod_congr rfl |
| rintro ⟨i,j⟩ hij |
| have hji : j < i := Equiv.Perm.mem_finPairsLT.mp hij |
| have hne : τ j ≠ τ i := τ.injective.ne hji.ne |
| have hneσ : σ (τ j) ≠ σ (τ i) := σ.injective.ne hne |
| by_cases hi : odd (w i) |
| · by_cases hj : odd (w j) |
| · by_cases ht : τ j < τ i |
| · simp [Equiv.Perm.signBijAux,wordPerm,Equiv.Perm.mul_apply,ht,hi,hj,ht.not_gt] |
| · have ht' : τ i < τ j := lt_of_le_of_ne (le_of_not_gt ht) hne.symm |
| by_cases hs : σ (τ i) < σ (τ j) |
| · simp [Equiv.Perm.signBijAux,wordPerm,Equiv.Perm.mul_apply,ht,ht',hi,hj,hs,hs.not_gt] |
| · have hs' : σ (τ j) < σ (τ i) := lt_of_le_of_ne (le_of_not_gt hs) hneσ |
| simp [Equiv.Perm.signBijAux,wordPerm,Equiv.Perm.mul_apply,ht,ht',hi,hj,hs,hs'] |
| · by_cases ht : τ j < τ i <;> |
| simp [Equiv.Perm.signBijAux,wordPerm,Equiv.Perm.mul_apply,ht,hi,hj] |
| · by_cases ht : τ j < τ i <;> |
| simp [Equiv.Perm.signBijAux,wordPerm,Equiv.Perm.mul_apply,ht,hi] |
| |
| /- Unitarity follows directly, without assuming the Schur-Weyl |
| or Pieri decomposition. -/ |
| theorem matrix_unitary {p l : ℕ} (σ : Equiv.Perm (Fin l)) : |
| (matrix (p := p) σ).conjTranspose * matrix σ=1 := by |
| ext u w |
| simp only [Matrix.mul_apply,Matrix.conjTranspose_apply,matrix] |
| rw [Finset.sum_eq_single (wordPerm σ u)] |
| · by_cases hu : u=w |
| · subst w |
| simp only [ite_true,Matrix.one_apply_eq,phase_star_mul] |
| · have hne : wordPerm σ u ≠ wordPerm σ w := |
| fun hh => hu ((wordPerm σ).injective hh) |
| simp [hne,hu] |
| · intro v hv hne |
| simp [hne] |
| · simp |
| |
| lemma phase_one {p l : ℕ} (w : Word p l) : phase (1 : Equiv.Perm (Fin l)) w=1 := by |
| rw [phase_prod] |
| apply Finset.prod_eq_one |
| intro ij hij |
| have hji := Equiv.Perm.mem_finPairsLT.mp hij |
| simp [Equiv.Perm.one_apply,hji.not_gt] |
| |
| theorem matrix_one (p l : ℕ) : matrix (p := p) (1 : Equiv.Perm (Fin l))=1 := by |
| ext u w |
| simp [matrix,wordPerm,phase_one,Matrix.one_apply] |
| |
| theorem matrix_mul {p l : ℕ} (σ τ : Equiv.Perm (Fin l)) : |
| matrix (p := p) (σ*τ)=matrix σ * matrix τ := by |
| ext u w |
| simp only [Matrix.mul_apply,matrix] |
| rw [Finset.sum_eq_single (wordPerm τ w)] |
| · simp only [ite_true,wordPerm_mul,Equiv.Perm.mul_apply,phase_mul] |
| split_ifs <;> simp |
| · intro v hv hne |
| simp [hne] |
| · simp |
| |
| /- Exact signed tensor representation of the symmetric group. -/ |
| def action (p l : ℕ) : Equiv.Perm (Fin l) →* Matrix (Word p l) (Word p l) ℂ where |
| toFun := matrix |
| map_one' := matrix_one p l |
| map_mul' := matrix_mul |
| |
| /- Ordinary (not graded) tensor power of a one-site density, as in05. -/ |
| def densityPower {p : ℕ} (l : ℕ) (r : Matrix (Letter p) (Letter p) ℂ) : |
| Matrix (Word p l) (Word p l) ℂ := fun u w => ∏ i, r (u i) (w i) |
| |
| lemma densityPower_mul {p : ℕ} (l : ℕ) (a b : Matrix (Letter p) (Letter p) ℂ) : |
| densityPower l (a*b)=densityPower l a * densityPower l b := by |
| ext u w |
| simp only [densityPower,Matrix.mul_apply] |
| rw [Fintype.prod_sum] |
| apply Finset.sum_congr rfl |
| intro v hv |
| exact Finset.prod_mul_distrib |
| |
| lemma densityPower_star {p : ℕ} (l : ℕ) (r : Matrix (Letter p) (Letter p) ℂ) : |
| densityPower l r.conjTranspose=(densityPower l r).conjTranspose := by |
| ext u w |
| simp [densityPower,Matrix.conjTranspose_apply] |
| |
| lemma densityPower_trace {p : ℕ} (l : ℕ) (r : Matrix (Letter p) (Letter p) ℂ) : |
| Matrix.trace (densityPower l r)=(Matrix.trace r)^l := by |
| change (∑ w : Word p l, ∏ i, r (w i) (w i))=(∑ i, r i i)^l |
| exact (Fintype.sum_pow (fun i : Letter p => r i i) l).symm |
| |
| open scoped MatrixOrder in |
| lemma densityPower_posSemidef {p : ℕ} (l : ℕ) (r : Matrix (Letter p) (Letter p) ℂ) |
| (hr : r.PosSemidef) : (densityPower l r).PosSemidef := by |
| obtain ⟨b,rfl⟩ := CStarAlgebra.nonneg_iff_eq_star_mul_self.mp hr.nonneg |
| rw [densityPower_mul,Matrix.star_eq_conjTranspose,densityPower_star] |
| exact Matrix.posSemidef_conjTranspose_mul_self _ |
| |
| /- Even means positive trace-one and block diagonal for E,O, exactly as in05. -/ |
| def EvenDensity (p : ℕ) := {r : Matrix (Letter p) (Letter p) ℂ // |
| r.PosSemidef ∧ Matrix.trace r=1 ∧ |
| ∀ i j, (odd i ↔ ¬ odd j) → r i j=0} |
| |
| instance (p : ℕ) : MeasurableSpace (EvenDensity p) := |
| MeasurableSpace.comap Subtype.val (borel (Matrix (Letter p) (Letter p) ℂ)) |
| |
| lemma phase_eq_of_parity {p l : ℕ} (σ : Equiv.Perm (Fin l)) |
| (u w : Word p l) (h : ∀ i, odd (u i) ↔ odd (w i)) : phase σ u=phase σ w := by |
| simp only [phase,koszulExponent] |
| congr 2 |
| apply Finset.filter_congr |
| intro ij hij |
| rw [h ij.1,h ij.2] |
| |
| lemma densityPower_parity_of_ne_zero {p l : ℕ} (r : EvenDensity p) |
| {u w : Word p l} (h : densityPower l r.val u w ≠ 0) : |
| ∀ i, odd (u i) ↔ odd (w i) := by |
| intro i |
| have he : r.val (u i) (w i) ≠ 0 := |
| (Finset.prod_ne_zero_iff.mp h) i (Finset.mem_univ _) |
| by_contra hn |
| apply he |
| apply r.property.2.2 |
| tauto |
| |
| lemma densityPower_permute {p l : ℕ} (σ : Equiv.Perm (Fin l)) |
| (r : Matrix (Letter p) (Letter p) ℂ) (u w : Word p l) : |
| densityPower l r (wordPerm σ u) (wordPerm σ w)=densityPower l r u w := by |
| simp only [densityPower,wordPerm,Equiv.coe_fn_mk] |
| exact Equiv.prod_comp σ⁻¹ (fun i => r (u i) (w i)) |
| |
| /- Even densities commute with the signed action; omission of evenness here |
| would be false. This is also the block-reordering claim at the end of05. -/ |
| theorem densityPower_commute {p l : ℕ} (r : EvenDensity p) |
| (σ : Equiv.Perm (Fin l)) : |
| matrix σ * densityPower l r.val=densityPower l r.val * matrix σ := by |
| ext u w |
| simp only [Matrix.mul_apply,matrix] |
| rw [Finset.sum_eq_single ((wordPerm σ).symm u), |
| Finset.sum_eq_single (wordPerm σ w)] |
| · simp only [(wordPerm σ).apply_symm_apply,ite_true] |
| have hd : densityPower l r.val u (wordPerm σ w)= |
| densityPower l r.val ((wordPerm σ).symm u) w := by |
| simpa using densityPower_permute σ r.val ((wordPerm σ).symm u) w |
| rw [hd] |
| by_cases hn : densityPower l r.val ((wordPerm σ).symm u) w=0 |
| · simp [hn] |
| · rw [phase_eq_of_parity σ _ _ (densityPower_parity_of_ne_zero r hn),mul_comm] |
| · intro v hv hne |
| simp [hne] |
| · simp |
| · intro v hv hne |
| have hh : u ≠ wordPerm σ v := by |
| intro he |
| apply hne |
| exact (Equiv.eq_symm_apply _).mpr he.symm |
| simp [hh] |
| · simp |
| |
| lemma evenDensityPower_trace {p : ℕ} (l : ℕ) (r : EvenDensity p) : |
| Matrix.trace (densityPower l r.val)=1 := by |
| rw [densityPower_trace,r.property.2.1,one_pow] |
| |
| /- The standard central character formula for the isotypic projection. Its |
| projection properties require the signed action laws (not assumed here). -/ |
| def isotypic {p l : ℕ} (ρ : UnitaryIrrep (Equiv.Perm (Fin l))) : |
| Matrix (Word p l) (Word p l) ℂ := |
| ((ρ.dimension : ℂ)/(Fintype.card (Equiv.Perm (Fin l)) : ℂ)) • |
| ∑ σ, Matrix.trace (ρ.matrix σ⁻¹) • matrix σ |
| |
| /- Exact signed-density domination05 eq13, expressed for every irreducible |
| (including absent ones whose projection is zero). The mixture is a genuine |
| probability measure on the source's even density matrices, not an unproved |
| positive operator supplied as a hypothesis. -/ |
| def Domination : Prop := |
| ∃ C : ℝ, 0 < C ∧ ∀ s p : ℕ, 1 ≤ p → p ≤ s → ∀ l : ℕ, l ≤ s → |
| ∀ ρ : UnitaryIrrep (Equiv.Perm (Fin l)), |
| ∃ μ : MeasureTheory.Measure (EvenDensity p), MeasureTheory.IsProbabilityMeasure μ ∧ |
| (Complex.ofReal (Real.exp (Real.log ρ.dimension+C*p^2*Real.log (s+1))) • |
| (∫ r : EvenDensity p, densityPower l r.val ∂μ) - isotypic (p := p) ρ).PosSemidef |
|
|
| end SignedTensor |
| end CoordinateSweeps |
|
|
| /- A direct counting approach to the polynomial multiplicity bound in05, |
| without replacing Schur-Weyl or the density inequality by an axiom. |
| The signed tensor commutant is determined by pair-word histograms. -/ |
| namespace CoordinateSweeps.SignedTensor |
|
|
| lemma phase_ne_zero {p l : ℕ} (σ : Equiv.Perm (Fin l)) (w : Word p l) : phase σ w ≠ 0 := by |
| intro h |
| have hh := phase_star_mul σ w |
| simp [h] at hh |
|
|
| lemma mul_signed_entry {p l : ℕ} (A : Matrix (Word p l) (Word p l) ℂ) |
| (σ : Equiv.Perm (Fin l)) (u w : Word p l) : |
| (A*matrix (p := p) σ) u w=A u (wordPerm σ w)*phase σ w := by |
| simp only [Matrix.mul_apply,matrix] |
| rw [Finset.sum_eq_single (wordPerm σ w)] |
| · simp |
| · intro v hv hne; simp [hne] |
| · simp |
|
|
| lemma signed_mul_entry {p l : ℕ} (A : Matrix (Word p l) (Word p l) ℂ) |
| (σ : Equiv.Perm (Fin l)) (u w : Word p l) : |
| (matrix (p := p) σ*A) (wordPerm σ u) w=phase σ u*A u w := by |
| simp only [Matrix.mul_apply,matrix] |
| rw [Finset.sum_eq_single u] |
| · simp |
| · intro v hv hne |
| have hne' : wordPerm σ u ≠ wordPerm σ v := |
| fun hh => hne (((wordPerm σ).injective hh).symm) |
| simp [hne'] |
| · simp |
|
|
| /- The actual signed-action commutant as a linear subspace of matrices. -/ |
| def commutant (p l : ℕ) : Submodule ℂ (Matrix (Word p l) (Word p l) ℂ) where |
| carrier := {A | ∀ σ : Equiv.Perm (Fin l), A*matrix σ=matrix σ*A} |
| zero_mem' := by simp |
| add_mem' hA hB := by intro σ; simp only [add_mul,mul_add,hA σ,hB σ] |
| smul_mem' c A hA := by intro σ; simp only [smul_mul_assoc,mul_smul_comm,hA σ] |
|
|
| lemma commutant_zero_transport {p l : ℕ} (A : commutant p l) |
| (σ : Equiv.Perm (Fin l)) {u w : Word p l} (h : A.val u w=0) : |
| A.val (wordPerm σ u) (wordPerm σ w)=0 := by |
| have hh := congrArg (fun B : Matrix (Word p l) (Word p l) ℂ => B (wordPerm σ u) w) |
| (A.property σ) |
| rw [mul_signed_entry,signed_mul_entry,h,mul_zero] at hh |
| exact (mul_eq_zero.mp hh).resolve_right (phase_ne_zero σ w) |
|
|
| abbrev Profile (p l : ℕ) := (Letter p × Letter p) → Fin (l+1) |
|
|
| def profile {p l : ℕ} (u w : Word p l) : Profile p l := fun a => |
| ⟨(Finset.univ.filter (fun i => (u i,w i)=a)).card, |
| Nat.lt_succ_iff.mpr (by |
| simpa using Finset.card_filter_le (Finset.univ : Finset (Fin l)) |
| (fun i => (u i,w i)=a))⟩ |
|
|
| lemma profile_fiber_card {p l : ℕ} (u w : Word p l) (a : Letter p × Letter p) : |
| Fintype.card {i : Fin l // (u i,w i)=a}=(profile u w a).val := by |
| simp [profile,Fintype.card_subtype] |
|
|
| /- Two word pairs have the same histogram exactly when a position permutation |
| carries one to the other. This supplies the finite orbit-counting parameter. -/ |
| lemma profile_eq_exists_perm {p l : ℕ} {u w u' w' : Word p l} |
| (hh : profile u w=profile u' w') : |
| ∃ σ : Equiv.Perm (Fin l), wordPerm σ u=u' ∧ wordPerm σ w=w' := by |
| have hc (a : Letter p × Letter p) : Fintype.card {i : Fin l // (u i,w i)=a}= |
| Fintype.card {i : Fin l // (u' i,w' i)=a} := by |
| rw [profile_fiber_card,profile_fiber_card,hh] |
| let e (a : Letter p × Letter p) : {i : Fin l // (u i,w i)=a} ≃ |
| {i : Fin l // (u' i,w' i)=a} := Fintype.equivOfCardEq (hc a) |
| let σ : Equiv.Perm (Fin l) := Equiv.ofFiberEquiv e |
| have he (i : Fin l) : (u' (σ i),w' (σ i))=(u i,w i) := Equiv.ofFiberEquiv_map e i |
| refine ⟨σ,?_,?_⟩ |
| · funext i |
| have hi := congrArg Prod.fst (he (σ⁻¹ i)) |
| simpa [wordPerm] using hi.symm |
| · funext i |
| have hi := congrArg Prod.snd (he (σ⁻¹ i)) |
| simpa [wordPerm] using hi.symm |
|
|
| abbrev OccurringProfile (p l : ℕ) := |
| {q : Profile p l // q ∈ Set.range (fun uw : Word p l × Word p l => profile uw.1 uw.2)} |
|
|
| def profileRep {p l : ℕ} (q : OccurringProfile p l) : Word p l × Word p l := |
| Classical.choose q.property |
|
|
| lemma profileRep_spec {p l : ℕ} (q : OccurringProfile p l) : |
| profile (profileRep q).1 (profileRep q).2=q.val := Classical.choose_spec q.property |
|
|
| def commutantEval (p l : ℕ) : commutant p l →ₗ[ℂ] (OccurringProfile p l → ℂ) where |
| toFun A q := A.val (profileRep q).1 (profileRep q).2 |
| map_add' _ _ := rfl |
| map_smul' _ _ := rfl |
|
|
| lemma commutantEval_injective (p l : ℕ) : Function.Injective (commutantEval p l) := by |
| apply (LinearMap.ker_eq_bot).mp |
| apply LinearMap.ker_eq_bot'.mpr |
| intro A hA |
| apply Subtype.ext |
| ext u w |
| let q : OccurringProfile p l := ⟨profile u w,Set.mem_range_self (u,w)⟩ |
| have he : A.val (profileRep q).1 (profileRep q).2=0 := congrFun hA q |
| have hp : profile (profileRep q).1 (profileRep q).2=profile u w := profileRep_spec q |
| obtain ⟨σ,hσu,hσw⟩ := profile_eq_exists_perm hp |
| have hh := commutant_zero_transport A σ he |
| simpa [hσu,hσw] using hh |
| |
| /- Polynomial signed-commutant bound of exactly the O(p² log(s+1)) scale |
| required by the main induction. No classification of partitions is used. -/ |
| theorem commutant_finrank_le (p l : ℕ) : |
| Module.finrank ℂ (commutant p l) ≤ (l+1)^((2*p)*(2*p)) := by |
| have h := LinearMap.finrank_le_finrank_of_injective (commutantEval_injective p l) |
| have hc : Fintype.card (OccurringProfile p l) ≤ Fintype.card (Profile p l) := |
| Fintype.card_subtype_le _ |
| have he : Fintype.card (Profile p l)=(l+1)^((2*p)*(2*p)) := by |
| simp [Profile,Letter] |
| simpa [he] using h.trans (by simpa using hc) |
| |
| end CoordinateSweeps.SignedTensor |
| |
| namespace CoordinateSweeps.SignedTensor |
| |
| lemma matrix_inv {p l : ℕ} (σ : Equiv.Perm (Fin l)) : |
| matrix (p := p) σ⁻¹=(matrix (p := p) σ).conjTranspose := by |
| calc |
| matrix σ⁻¹=1*matrix (p := p) σ⁻¹ := (one_mul _).symm |
| _ = ((matrix σ).conjTranspose*matrix σ)*matrix (p := p) σ⁻¹ := by rw [matrix_unitary] |
| _ = (matrix (p := p) σ).conjTranspose := by |
| rw [mul_assoc,← matrix_mul,mul_inv_cancel,matrix_one,mul_one] |
| |
| abbrev tensorRepresentation (p l : ℕ) := UnitaryIrrep.matrixRepresentation (action p l) |
| |
| /- An actual intertwining endomorphism has its coefficient matrix in the |
| signed commutant. This is not an assumed decomposition of the tensor action. -/ |
| def endomorphismMatrix (p l : ℕ) : |
| (tensorRepresentation p l).IntertwiningMap (tensorRepresentation p l) →ₗ[ℂ] |
| commutant p l where |
| toFun F := ⟨LinearMap.toMatrixAlgEquiv' F.toLinearMap,by |
| intro σ |
| apply Matrix.toLinAlgEquiv'.injective |
| simp only [map_mul,Matrix.toLinAlgEquiv'_toMatrixAlgEquiv'] |
| exact F.isIntertwining' σ⟩ |
| map_add' F H := by |
| apply Subtype.ext |
| exact map_add LinearMap.toMatrixAlgEquiv' _ _ |
| map_smul' c F := by |
| apply Subtype.ext |
| exact map_smul LinearMap.toMatrixAlgEquiv'.toLinearMap c _ |
|
|
| lemma endomorphismMatrix_injective (p l : ℕ) : |
| Function.Injective (endomorphismMatrix p l) := by |
| intro F H hh |
| apply Representation.IntertwiningMap.ext |
| exact LinearMap.toMatrixAlgEquiv'.injective (congrArg Subtype.val hh) |
| |
| theorem tensor_endomorphisms_finrank_le (p l : ℕ) : |
| Module.finrank ℂ ((tensorRepresentation p l).IntertwiningMap (tensorRepresentation p l)) ≤ |
| (l+1)^((2*p)*(2*p)) := |
| (LinearMap.finrank_le_finrank_of_injective (endomorphismMatrix_injective p l)).trans |
| (commutant_finrank_le p l) |
| |
| /- The polynomial multiplicity clause of05 signed density lemma, proved |
| without Young diagrams. Multiplicity is the actual space of equivariant embeddings. -/ |
| theorem multiplicity_le (p l : ℕ) (ρ : UnitaryIrrep (Equiv.Perm (Fin l))) : |
| Module.finrank ℂ (ρ.asRepresentation.IntertwiningMap (tensorRepresentation p l)) ≤ |
| (l+1)^((2*p)*(2*p)) := by |
| have hh := ρ.multiplicity_sq_le_commutant (action p l) |
| (fun σ => matrix_inv σ |>.symm) |
| have hm : Module.finrank ℂ (ρ.asRepresentation.IntertwiningMap (tensorRepresentation p l)) ≤ |
| (Module.finrank ℂ (ρ.asRepresentation.IntertwiningMap (tensorRepresentation p l)))^2 := by |
| exact Nat.le_self_pow (by omega) _ |
| exact hm.trans (hh.trans (tensor_endomorphisms_finrank_le p l)) |
| |
| lemma isotypic_eq_projector {p l : ℕ} (ρ : UnitaryIrrep (Equiv.Perm (Fin l))) : |
| isotypic (p := p) ρ=ρ.projector (action p l) := by |
| simp only [isotypic,UnitaryIrrep.projector,UnitaryIrrep.coefficient,Finset.smul_sum,mul_smul] |
| rfl |
| |
| theorem isotypic_posSemidef {p l : ℕ} (ρ : UnitaryIrrep (Equiv.Perm (Fin l))) : |
| (isotypic (p := p) ρ).PosSemidef := by |
| rw [isotypic_eq_projector] |
| exact ρ.projector_posSemidef (action p l) (fun σ => (matrix_inv σ).symm) |
| |
| theorem isotypic_trace {p l : ℕ} (ρ : UnitaryIrrep (Equiv.Perm (Fin l))) : |
| Matrix.trace (isotypic (p := p) ρ)=(ρ.dimension : ℂ)* |
| Module.finrank ℂ (ρ.asRepresentation.IntertwiningMap (tensorRepresentation p l)) := by |
| rw [isotypic_eq_projector] |
| simp only [UnitaryIrrep.projector,Matrix.trace_sum,Matrix.trace_smul, |
| UnitaryIrrep.coefficient,smul_eq_mul] |
| calc |
| _ = ((ρ.dimension : ℂ)/(Fintype.card (Equiv.Perm (Fin l)) : ℂ)) * |
| ∑ σ, Matrix.trace (action p l σ)*Matrix.trace (ρ.matrix σ⁻¹) := by |
| rw [Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro σ hσ |
| ring |
| _ = _ := by |
| rw [ρ.character_sum_multiplicity (action p l)] |
| have hN : (Fintype.card (Equiv.Perm (Fin l)) : ℂ) ≠ 0 := |
| Nat.cast_ne_zero.mpr Fintype.card_ne_zero |
| field_simp |
| |
| end CoordinateSweeps.SignedTensor |
| |
| /- Mismatched symbols in a purification |
| obey a Pauli exclusion rule. This is derived from the literal Koszul action. -/ |
| namespace CoordinateSweeps.SignedTensor |
| |
| lemma swap01_inversion_iff (n : ℕ) (i j : Fin (n+2)) : |
| (j < i ∧ Equiv.swap (0 : Fin (n+2)) 1 i < Equiv.swap 0 1 j) ↔ |
| i = 1 ∧ j = 0 := by |
| simp only [Equiv.swap_apply_def] |
| split_ifs <;> simp_all |
| omega |
| |
| lemma phase_swap01 {p n : ℕ} (w : Word p (n+2)) : |
| phase (Equiv.swap (0 : Fin (n+2)) 1) w = |
| if odd (w 1) ∧ odd (w 0) then (-1 : ℂ) else 1 := by |
| have he : ((Equiv.Perm.finPairsLT (n+2)).filter (fun ij => |
| odd (w ij.1) ∧ odd (w ij.2) ∧ |
| Equiv.swap (0 : Fin (n+2)) 1 ij.1 < Equiv.swap 0 1 ij.2)) = |
| if odd (w 1) ∧ odd (w 0) then {⟨1,0⟩} else ∅ := by |
| ext ⟨i,j⟩ |
| simp only [Finset.mem_filter, Equiv.Perm.mem_finPairsLT] |
| have hi := swap01_inversion_iff n i j |
| split_ifs with hw |
| · simp only [Finset.mem_singleton, Sigma.mk.inj_iff, heq_eq_eq] |
| constructor |
| · rintro ⟨hji,hiw,hjw,hs⟩ |
| exact hi.mp ⟨hji,hs⟩ |
| · rintro ⟨rfl,rfl⟩ |
| exact ⟨by simp, hw.1, hw.2, by simp⟩ |
| · simp only [Finset.notMem_empty, iff_false] |
| rintro ⟨hji,hiw,hjw,hs⟩ |
| obtain ⟨rfl,rfl⟩ := hi.mp ⟨hji,hs⟩ |
| exact hw ⟨hiw,hjw⟩ |
| unfold phase koszulExponent |
| rw [he] |
| split_ifs <;> simp |
| |
| lemma wordPerm_swap01_of_equal {p n : ℕ} (w : Word p (n+2)) (hw : w 0 = w 1) : |
| wordPerm (Equiv.swap (0 : Fin (n+2)) 1) w = w := by |
| ext i |
| simp only [wordPerm, Equiv.coe_fn_mk, Equiv.swap_inv, Equiv.swap_apply_def] |
| split_ifs <;> simp_all |
| |
| /- Two repeated, parity-mismatched pair symbols force a zero entry in every |
| commuting matrix, hence in the canonical purification of an isotypic projector. -/ |
| theorem commutant_entry_zero_adjacent_mismatch {p n : ℕ} (A : commutant p (n+2)) |
| (u w : Word p (n+2)) (hu : u 0 = u 1) (hw : w 0 = w 1) |
| (hm : odd (u 0) ↔ ¬ odd (w 0)) : A.val u w = 0 := by |
| let σ := Equiv.swap (0 : Fin (n+2)) 1 |
| have h := congrArg (fun B : Matrix (Word p (n+2)) (Word p (n+2)) ℂ => |
| B (wordPerm σ u) w) (A.property σ) |
| rw [mul_signed_entry, signed_mul_entry, |
| wordPerm_swap01_of_equal u hu, wordPerm_swap01_of_equal w hw] at h |
| dsimp [σ] at h |
| rw [phase_swap01, phase_swap01, ← hu, ← hw] at h |
| by_cases ho : odd (u 0) |
| · have hw' : ¬ odd (w 0) := hm.mp ho |
| simp only [ho, hw', and_self, ↓reduceIte, mul_one, neg_one_mul] at h |
| linear_combination (1/2 : ℂ)*h |
| · have hw' : odd (w 0) := Classical.byContradiction (fun hh => ho (hm.mpr hh)) |
| simp only [ho, hw', and_self, ↓reduceIte, one_mul, mul_neg_one] at h |
| linear_combination (-1/2 : ℂ)*h |
| |
| /- An explicit two-point transporter, avoiding any unproved transitivity |
| principle or choice of ordering of the other positions. -/ |
| lemma exists_perm_pair {X : Type*} [DecidableEq X] (a b c d : X) |
| (hab : a ≠ b) (hcd : c ≠ d) : |
| ∃ g : Equiv.Perm X, g a = c ∧ g b = d := by |
| let s := Equiv.swap a c |
| have hs : s b ≠ c := by |
| intro h |
| have he : s a = c := by simp [s] |
| exact hab (s.injective (he.trans h.symm)) |
| refine ⟨Equiv.swap (s b) d * s, ?_, ?_⟩ |
| · simp only [Equiv.Perm.mul_apply] |
| have he : s a = c := by simp [s] |
| rw [he, Equiv.swap_apply_of_ne_of_ne hs.symm hcd] |
| · simp |
| |
| /- All repeated parity-mismatched pair symbols are impossible, at arbitrary |
| positions. Distinct mismatched symbols will therefore account for every |
| exceptional slot in the postselection argument. -/ |
| theorem commutant_entry_zero_repeated_mismatch {p l : ℕ} (A : commutant p l) |
| (u w : Word p l) (i j : Fin l) (hij : i ≠ j) (hu : u i = u j) (hw : w i = w j) |
| (hm : odd (u i) ↔ ¬ odd (w i)) : A.val u w = 0 := by |
| have hl : 2 ≤ l := by |
| have hn : i.val ≠ j.val := fun h => hij (Fin.ext h) |
| have hi := i.isLt |
| have hj := j.isLt |
| omega |
| obtain ⟨n, rfl⟩ : ∃ n, l = n+2 := ⟨l-2, by omega⟩ |
| obtain ⟨g,hi,hj⟩ := exists_perm_pair i j (0 : Fin (n+2)) 1 hij (by simp) |
| let u' := wordPerm g u |
| let w' := wordPerm g w |
| have hue (x : Fin (n+2)) : u' (g x) = u x := by simp [u',wordPerm] |
| have hwe (x : Fin (n+2)) : w' (g x) = w x := by simp [w',wordPerm] |
| have hui : u' 0 = u i := hi ▸ hue i |
| have huj : u' 1 = u j := hj ▸ hue j |
| have hwi : w' 0 = w i := hi ▸ hwe i |
| have hwj : w' 1 = w j := hj ▸ hwe j |
| have hz : A.val u' w' = 0 := by |
| apply commutant_entry_zero_adjacent_mismatch A u' w' |
| · exact hui.trans (hu.trans huj.symm) |
| · exact hwi.trans (hw.trans hwj.symm) |
| · simpa [hui,hwi] using hm |
| have hz' := commutant_zero_transport A g⁻¹ hz |
| simpa [u',w',wordPerm] using hz' |
| end CoordinateSweeps.SignedTensor |
| |
| namespace CoordinateSweeps.SignedTensor |
| /- Exceptional slots of a vectorized commuting matrix. -/ |
| def mismatchSlots {p l : ℕ} (u w : Word p l) : Finset (Fin l) := |
| Finset.univ.filter (fun i => odd (u i) ↔ ¬ odd (w i)) |
| |
| /- The exclusion bound needed for even-density postselection. The coarse |
| constant four rather than two is harmless in the source's absolute Cp² error. -/ |
| theorem mismatchSlots_card_le {p l : ℕ} (A : commutant p l) |
| (u w : Word p l) (hne : A.val u w ≠ 0) : |
| (mismatchSlots u w).card ≤ (2*p)*(2*p) := by |
| classical |
| let f : {i // i ∈ mismatchSlots u w} → Letter p × Letter p := fun i => (u i.val,w i.val) |
| have hf : Function.Injective f := by |
| intro i j he |
| apply Subtype.ext |
| by_contra hij |
| apply hne |
| exact commutant_entry_zero_repeated_mismatch A u w i.val j.val hij |
| (congrArg Prod.fst he) (congrArg Prod.snd he) (Finset.mem_filter.mp i.property).2 |
| have hc := Fintype.card_le_of_injective f hf |
| simpa only [Fintype.card_coe, Fintype.card_prod, Fintype.card_fin] using hc |
| end CoordinateSweeps.SignedTensor |
|
|
| namespace CoordinateSweeps.SignedTensor |
| /- The actual Koszul regrouping phase from (V⊗V̄)^⊗l to |
| V^⊗l⊗V̄^⊗l. It will cancel, not be dropped, under partial trace. -/ |
| def regroupPhase {p l : ℕ} (u w : Word p l) : ℂ := |
| ∏ ij ∈ Equiv.Perm.finPairsLT l, |
| if odd (u ij.1) ∧ odd (w ij.2) then (-1 : ℂ) else 1 |
|
|
| lemma phase_square {p l : ℕ} (σ : Equiv.Perm (Fin l)) (u : Word p l) : |
| phase σ u * phase σ u = 1 := by |
| simpa only [phase,star_pow,star_neg,star_one] using phase_star_mul σ u |
|
|
| lemma regroupPhase_square {p l : ℕ} (u w : Word p l) : |
| regroupPhase u w * regroupPhase u w = 1 := by |
| unfold regroupPhase |
| rw [← Finset.prod_mul_distrib] |
| apply Finset.prod_eq_one |
| intro ij _ |
| split_ifs <;> norm_num |
|
|
| lemma regroupPhase_star {p l : ℕ} (u w : Word p l) : |
| star (regroupPhase u w) = regroupPhase u w := by |
| unfold regroupPhase |
| rw [star_prod] |
| apply Finset.prod_congr rfl |
| intro ij _ |
| split_ifs <;> simp |
|
|
| /- Permutations of the matched slots have no residual super-sign after |
| literal Koszul regrouping; the positions of mismatched symbols are fixed. -/ |
| theorem regroupPhase_permute {p l : ℕ} (σ : Equiv.Perm (Fin l)) (u w : Word p l) |
| (hfix : ∀ i, (odd (u i) ↔ ¬ odd (w i)) → σ i = i) : |
| regroupPhase (wordPerm σ u) (wordPerm σ w) * phase σ u * phase σ w = |
| regroupPhase u w := by |
| unfold regroupPhase |
| rw [phase_prod,phase_prod] |
| have hreindex : |
| (∏ ij ∈ Equiv.Perm.finPairsLT l, |
| (if odd (wordPerm σ u ij.1) ∧ odd (wordPerm σ w ij.2) then (-1 : ℂ) else 1)) = |
| ∏ ij ∈ Equiv.Perm.finPairsLT l, |
| (if odd (wordPerm σ u (Equiv.Perm.signBijAux σ ij).1) ∧ |
| odd (wordPerm σ w (Equiv.Perm.signBijAux σ ij).2) then (-1 : ℂ) else 1) := by |
| symm |
| exact Finset.prod_nbij (Equiv.Perm.signBijAux σ) |
| Equiv.Perm.signBijAux_mem Equiv.Perm.signBijAux_injOn |
| Equiv.Perm.signBijAux_surj (fun _ _ => rfl) |
| rw [hreindex,← Finset.prod_mul_distrib,← Finset.prod_mul_distrib] |
| apply Finset.prod_congr rfl |
| rintro ⟨i,j⟩ hij |
| have hji : j < i := Equiv.Perm.mem_finPairsLT.mp hij |
| have hne : σ j ≠ σ i := σ.injective.ne hji.ne |
| by_cases ht : σ j < σ i |
| · simp [Equiv.Perm.signBijAux,wordPerm,ht,ht.not_gt] |
| · have ht' : σ i < σ j := lt_of_le_of_ne (le_of_not_gt ht) hne.symm |
| have hm : ¬ ((odd (u i) ↔ ¬ odd (w i)) ∧ (odd (u j) ↔ ¬ odd (w j))) := by |
| rintro ⟨hi,hj⟩ |
| have hi' := hfix i hi |
| have hj' := hfix j hj |
| rw [hi',hj'] at ht' |
| exact hji.not_gt ht' |
| by_cases hui : odd (u i) <;> by_cases huj : odd (u j) <;> |
| by_cases hwi : odd (w i) <;> by_cases hwj : odd (w j) <;> |
| simp [Equiv.Perm.signBijAux,wordPerm,ht,ht',hui,huj,hwi,hwj] at hm ⊢ |
|
|
| lemma commutant_transport {p l : ℕ} (A : commutant p l) (σ : Equiv.Perm (Fin l)) |
| (u w : Word p l) : |
| A.val (wordPerm σ u) (wordPerm σ w) = phase σ u * phase σ w * A.val u w := by |
| have hh := congrArg (fun B : Matrix (Word p l) (Word p l) ℂ => B (wordPerm σ u) w) |
| (A.property σ) |
| rw [mul_signed_entry,signed_mul_entry] at hh |
| calc |
| _ = (A.val (wordPerm σ u) (wordPerm σ w) * phase σ w) * phase σ w := by |
| rw [mul_assoc,phase_square,mul_one] |
| _ = (phase σ u * A.val u w) * phase σ w := by rw [hh] |
| _ = _ := by ring |
|
|
| /- Rephased purification components are ordinary symmetric on the free, |
| matched-pair slots, a proved conclusion from the signed commutant relation. -/ |
| theorem regrouped_commutant_invariant {p l : ℕ} (A : commutant p l) |
| (σ : Equiv.Perm (Fin l)) (u w : Word p l) |
| (hfix : ∀ i, (odd (u i) ↔ ¬ odd (w i)) → σ i = i) : |
| regroupPhase (wordPerm σ u) (wordPerm σ w) * |
| A.val (wordPerm σ u) (wordPerm σ w) = regroupPhase u w * A.val u w := by |
| rw [commutant_transport] |
| calc |
| _ = (regroupPhase (wordPerm σ u) (wordPerm σ w) * phase σ u * phase σ w) * A.val u w := by ring |
| _ = _ := by rw [regroupPhase_permute σ u w hfix] |
|
|
| /- Equal local parities in the system copies give equal regrouping signs. |
| This is what justifies cancellation under the actual auxiliary partial trace. -/ |
| lemma regroupPhase_of_same_parity {p l : ℕ} (u u' w : Word p l) |
| (h : ∀ i, odd (u i) ↔ odd (u' i)) : regroupPhase u w = regroupPhase u' w := by |
| unfold regroupPhase |
| apply Finset.prod_congr rfl |
| intro ij _ |
| rw [h ij.1] |
| end CoordinateSweeps.SignedTensor |
|
|
| end |
| open scoped Matrix.Norms.L2Operator |
|
|
| end OAI |
|
|
