introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
26.8 kB
import Mathlib
import OAI.RepresentationTheory.SignedTensor.Overlap
import OAI.Analysis.Matrix.Holder
import OAI.RepresentationTheory.Young.Classification
namespace OAI
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ComplexConjugate Matrix.Norms.L2Operator
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ComplexOrder MatrixOrder
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators ENNReal
open MeasureTheory
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
noncomputable section
open scoped BigOperators
attribute [local instance] Classical.propDecidable
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
attribute [local instance] Classical.propDecidable
noncomputable section
attribute [local instance] Classical.propDecidable
noncomputable section
open Set Complex
open scoped BigOperators Topology
open scoped Matrix.Norms.L2Operator
noncomputable section
open scoped BigOperators Matrix.Norms.L2Operator ComplexOrder
namespace CoordinateSweeps.SignedTensor
def ActiveType (p l : ℕ) :=
{ a : Nat.Partition (Fintype.card (Fin l)) // (YoungCorner.partitionUnitary (Fin l) a).projector (action p l) ≠ 0 }
instance (p l : ℕ) : Fintype (ActiveType p l) := by
unfold ActiveType
infer_instance
instance (p l : ℕ) : DecidableEq (ActiveType p l) := Classical.decEq _
def activeIrrep {p l : ℕ} (a : ActiveType p l) : UnitaryIrrep (Equiv.Perm (Fin l)) :=
YoungCorner.partitionUnitary (Fin l) a.val
def activeProjector {p l : ℕ} (a : ActiveType p l) : commutant p l :=
⟨(activeIrrep a).projector (action p l),fun σ =>
((activeIrrep a).projector_commute (action p l) σ).symm⟩
lemma activeProjector_nonzero {p l : ℕ} (a : ActiveType p l) :
(activeProjector a).val ≠ 0 := a.property
lemma active_inequivalent {p l : ℕ} (a b : ActiveType p l) (hab : a ≠ b) :
¬Nonempty (Representation.Equiv (activeIrrep a).asRepresentation (activeIrrep b).asRepresentation) := by
apply YoungCorner.partitionUnitary_inequivalent
intro h
apply hab
apply Subtype.ext
simpa using h
lemma activeProjector_mul {p l : ℕ} (a b : ActiveType p l) :
(activeProjector a).val*(activeProjector b).val=
if a=b then (activeProjector a).val else 0 := by
split_ifs with h
· subst b; exact (activeIrrep a).projector_idempotent _
· exact (activeIrrep a).projector_orthogonal (activeIrrep b)
(active_inequivalent b a (Ne.symm h)) _
lemma activeProjector_independent (p l : ℕ) :
LinearIndependent ℂ (activeProjector (p := p) (l := l)) := by
apply linearIndependent_iff'.mpr
intro t c hc a ha
have hh := congrArg (fun A : commutant p l => (activeProjector a).val*A.val) hc
have hv : ∑ b ∈ t, c b • ((activeProjector a).val*(activeProjector b).val)=0 := by
simpa only [Submodule.coe_sum,Submodule.coe_smul,ZeroMemClass.coe_zero,
Matrix.mul_sum,Matrix.mul_smul,mul_zero] using hh
simp only [activeProjector_mul,smul_ite,smul_zero] at hv
have he : c a • (activeProjector a).val=0 := by simpa [ha] using hv
exact (smul_eq_zero.mp he).resolve_right (activeProjector_nonzero a)
/- Number of actually occurring local types is polynomial even without a
hook-support classification; this is exactly the term-count scale in06:eq20. -/
theorem active_card_le (p l : ℕ) :
Fintype.card (ActiveType p l) ≤ (l+1)^((2*p)*(2*p)) :=
(activeProjector_independent p l).fintype_card_le_finrank.trans (commutant_finrank_le p l)
/- Omitting zero type projections preserves the actual identity resolution. -/
theorem active_resolution (p l : ℕ) :
∑ a : ActiveType p l, (activeProjector a).val=1 := by
let f (a : Nat.Partition (Fintype.card (Fin l))) :=
(YoungCorner.partitionUnitary (Fin l) a).projector (action p l)
have he : ∑ a : ActiveType p l, (activeProjector a).val=∑ a : Nat.Partition (Fintype.card (Fin l)), f a := by
change (∑ a : {a : Nat.Partition (Fintype.card (Fin l)) // f a ≠ 0}, f a.val)=∑ a, f a
rw [← Finset.sum_subtype (Finset.univ.filter (fun a => f a ≠ 0)) (by simp),Finset.sum_filter]
apply Finset.sum_congr rfl
intro a ha
split_ifs with h
· rfl
· exact (not_ne_iff.mp h).symm
rw [he]
have hh := YoungCorner.partition_matrix_resolution (Fin l) (action p l)
simpa [f] using hh
end CoordinateSweeps.SignedTensor
namespace CoordinateSweeps.SignedTensor
variable {p r : ℕ} (n : Fin r → ℕ)
abbrev BlockType (p : ℕ) := ∀ i, ActiveType p (n i)
abbrev blockProjector (α : BlockType n p) := groupedProjector (p := p) n (fun i => activeIrrep (α i))
/- Actual polynomial-size identity resolution of each product subgroup. -/
lemma block_resolution : ∑ α : BlockType n p, blockProjector n α=1 := by
simp only [blockProjector,groupedProjector_factor]
change (∑ α : BlockType n p, Matrix.reindexAlgEquiv ℂ ℂ (groupWord n p).symm
(DependentTensor.tensor (fun i => (activeIrrep (α i)).projector (action p (n i)))))=1
rw [← map_sum]
rw [← DependentTensor.tensor_sum (fun i (a : ActiveType p (n i)) => (activeIrrep a).projector (action p (n i)))]
have hh (i : Fin r) : ∑ a : ActiveType p (n i), (activeIrrep a).projector (action p (n i))=1 :=
active_resolution p (n i)
simp only [hh,DependentTensor.tensor_one,map_one]
lemma block_card_le (s : ℕ) (hn : ∀ i, n i ≤ s) :
Fintype.card (BlockType n p) ≤ (s+1)^(r*((2*p)*(2*p))) := by
rw [Fintype.card_pi]
calc
_ ≤ ∏ i : Fin r, (s+1)^((2*p)*(2*p)) := Finset.prod_le_prod (fun i hi =>
(active_card_le p (n i)).trans (Nat.pow_le_pow_left (Nat.succ_le_succ (hn i)) _))
_ = _ := by rw [Finset.prod_const,Finset.card_univ,Fintype.card_fin,← pow_mul,Nat.mul_comm]
end CoordinateSweeps.SignedTensor
namespace CoordinateSweeps.SignedTensor
open UnitaryIrrep FiberBlocks
variable {p r l : ℕ} (n : Fin r → ℕ)
lemma ambient_block_resolution (h : (∑ i, n i)=l) (σ : Equiv.Perm (Fin l)) :
(∑ α : BlockType n p, ambientProjector (p := p) n h σ (fun i => activeIrrep (α i)))=1 := by
subst l
unfold ambientProjector lengthMatrix
rw [← Matrix.sum_mul,← Matrix.mul_sum,block_resolution,mul_one,matrix_unitary_reverse]
variable {L : Type*} [Fintype L]
lemma fiber_block_resolution (f : L → Fin r) (e : Fin (Fintype.card L) ≃ L) :
(∑ α : BlockType (size f) p, fiberProjector (p := p) f e (fun i => activeIrrep (α i)))=1 :=
ambient_block_resolution _ _ _
def blockEntropy {n : Fin r → ℕ} (α : BlockType n p) : ℝ :=
∑ i, Real.log (activeIrrep (α i)).dimension
lemma exp_blockEntropy {n : Fin r → ℕ} (α : BlockType n p) :
Real.exp (blockEntropy α)=∏ i, ((activeIrrep (α i)).dimension : ℝ) := by
rw [blockEntropy,Real.exp_sum]
apply Finset.prod_congr rfl
intro i _
exact Real.exp_log (Nat.cast_pos.mpr (activeIrrep (α i)).positive)
lemma nat_pow_eq_exp (s t : ℕ) : ((s+1 : ℕ) : ℝ)^t=Real.exp ((t : ℝ)*Real.log (s+1 : ℕ)) := by
rw [mul_comm,Real.exp_mul,Real.exp_log (by positivity),Real.rpow_natCast]
lemma block_card_real_le (f : L → Fin r) (s : ℕ) (hn : ∀ i, size f i ≤ s) :
(Fintype.card (BlockType (size f) p) : ℝ) ≤
Real.exp ((r*((2*p)*(2*p)) : ℕ)*Real.log (s+1 : ℕ)) := by
rw [← nat_pow_eq_exp]
exact_mod_cast block_card_le (size f) s hn
lemma actual_label_overlap_exp {c : ℕ} [NeZero r]
(f : L → Fin r) (g : L → Fin c) (hinj : Function.Injective (fun x => (f x,g x)))
(e : Fin (Fintype.card L) ≃ L) (s : ℕ) (hp : 0 < p) (hps : p ≤ s)
(hnR : ∀ i, size f i ≤ s) (hnC : ∀ j, size g j ≤ s)
(α : BlockType (size f) p) (β : BlockType (size g) p)
(ρ : UnitaryIrrep (Equiv.Perm (Fin (Fintype.card L)))) :
‖fiberProjector g e (fun j => activeIrrep (β j))*ρ.projector (action p (Fintype.card L))*
fiberProjector f e (fun i => activeIrrep (α i))‖^2 ≤
Real.exp (blockEntropy α+blockEntropy β-Real.log ρ.dimension+
((r : ℝ)*c-Fintype.card L)+((r+c)*(41*p^2) : ℕ)*Real.log (s+1 : ℕ)) := by
have hh := actual_label_overlap f g hinj e s hp hps hnR hnC
(fun i => activeIrrep (α i)) (fun j => activeIrrep (β j)) ρ
have hD : 0 < (ρ.dimension : ℝ) := Nat.cast_pos.mpr ρ.positive
apply (mul_le_mul_iff_right₀ hD).mp
apply hh.trans_eq
rw [← exp_blockEntropy α,← exp_blockEntropy β,nat_pow_eq_exp,nat_pow_eq_exp]
nth_rw 1 [← Real.exp_log hD]
simp only [← Real.exp_add]
congr 1
push_cast
ring
lemma actual_label_overlap_contract {c : ℕ} (f : L → Fin r) (g : L → Fin c)
(e : Fin (Fintype.card L) ≃ L) (hp : 0 < p)
(α : BlockType (size f) p) (β : BlockType (size g) p)
(ρ : UnitaryIrrep (Equiv.Perm (Fin (Fintype.card L)))) :
‖fiberProjector g e (fun j => activeIrrep (β j))*ρ.projector (action p (Fintype.card L))*
fiberProjector f e (fun i => activeIrrep (α i))‖ ≤ 1 := by
let : NeZero (2*p) := ⟨by omega⟩
have hR := TraceHolder.projector_norm_le _ (fiberProjector_posSemidef f e _).isHermitian
(fiberProjector_idempotent (p := p) f e (fun i => activeIrrep (α i)))
have hC := TraceHolder.projector_norm_le _ (fiberProjector_posSemidef g e _).isHermitian
(fiberProjector_idempotent (p := p) g e (fun i => activeIrrep (β i)))
have hP := TraceHolder.projector_norm_le _ (ρ.projector_posSemidef _ (fun σ => (matrix_inv σ).symm)).isHermitian
(ρ.projector_idempotent (action p (Fintype.card L)))
calc
_ ≤ (‖fiberProjector g e (fun j => activeIrrep (β j))‖*‖ρ.projector (action p (Fintype.card L))‖)*
‖fiberProjector f e (fun i => activeIrrep (α i))‖ := by
exact (Matrix.l2_opNorm_mul _ _).trans
(mul_le_mul_of_nonneg_right (Matrix.l2_opNorm_mul _ _) (norm_nonneg _))
_ ≤ (1*1)*1 := mul_le_mul (mul_le_mul hC hP (norm_nonneg _) (by positivity)) hR
(norm_nonneg _) (by positivity)
_ = 1 := by norm_num
/- The actual two-product-subgroup inequality. Its only analytic inputs are
child moments; the resolution, polynomial number of types and board overlap
are all constructed above. This is the row/column step of the main induction. -/
theorem labeled_projected_moment_bound {c : ℕ} [NeZero r]
(f : L → Fin r) (g : L → Fin c) (hinj : Function.Injective (fun x => (f x,g x)))
(e : Fin (Fintype.card L) ≃ L) (s : ℕ) (hp : 0 < p) (hps : p ≤ s)
(hnR : ∀ i, size f i ≤ s) (hnC : ∀ j, size g j ≤ s)
(ρ : UnitaryIrrep (Equiv.Perm (Fin (Fintype.card L)))) (q : ℕ) (hq : 0 < q)
(c₀ ER EC : ℝ) (hc : 0 ≤ c₀) (hcq : c₀ ≤ q)
(X Y : Matrix (Word p (Fintype.card L)) (Word p (Fintype.card L)) ℂ)
(hR : ∀ α : BlockType (size f) p,
(Matrix.trace (((fiberProjector f e (fun i => activeIrrep (α i))*X).conjTranspose*
(fiberProjector f e (fun i => activeIrrep (α i))*X))^q)).re ≤ Real.exp (-c₀*blockEntropy α+ER))
(hC : ∀ β : BlockType (size g) p,
(Matrix.trace (((Y*fiberProjector g e (fun j => activeIrrep (β j))).conjTranspose*
(Y*fiberProjector g e (fun j => activeIrrep (β j))))^q)).re ≤ Real.exp (-c₀*blockEntropy β+EC)) :
(Matrix.trace (((Y*ρ.projector (action p (Fintype.card L))*X).conjTranspose*
(Y*ρ.projector (action p (Fintype.card L))*X))^q)).re ≤
Real.exp (-c₀*Real.log ρ.dimension+ER+EC+c₀*((r : ℝ)*c-Fintype.card L)+
((2*q : ℕ)*((r+c)*((2*p)*(2*p)) : ℕ)+c₀*((r+c)*(41*p^2) : ℕ))*Real.log (s+1 : ℕ)) := by
let : NeZero (2*p) := ⟨by omega⟩
have hh := TraceHolder.row_column_moment q hq
(fun α : BlockType (size f) p => fiberProjector f e (fun i => activeIrrep (α i)))
(fun β : BlockType (size g) p => fiberProjector g e (fun j => activeIrrep (β j)))
(fiber_block_resolution f e) (fiber_block_resolution g e)
(fun α => fiberProjector_idempotent f e _) (fun β => fiberProjector_idempotent g e _)
(ρ.projector (action p (Fintype.card L))) X Y blockEntropy blockEntropy (Real.log ρ.dimension)
(ER+EC) (((r : ℝ)*c-Fintype.card L)+((r+c)*(41*p^2) : ℕ)*Real.log (s+1 : ℕ)) c₀ hc hcq
(fun α β => (mul_le_mul (hR α) (hC β)
(by exact (Complex.nonneg_iff.mp (Matrix.posSemidef_conjTranspose_mul_self _ |>.pow q |>.trace_nonneg)).1)
(Real.exp_pos _).le).trans_eq (by rw [← Real.exp_add]; congr 1; ring))
(fun α β => by simpa only [add_assoc] using actual_label_overlap_exp f g hinj e s hp hps hnR hnC α β ρ)
(fun α β => actual_label_overlap_contract f g e hp α β ρ)
apply hh.trans
have hcard := mul_le_mul (block_card_real_le (p := p) f s hnR) (block_card_real_le (p := p) g s hnC)
(Nat.cast_nonneg _) (Real.exp_pos _).le
rw [← Real.exp_add] at hcard
have hpow := pow_le_pow_left₀ (by positivity : 0 ≤
(Fintype.card (BlockType (size f) p) : ℝ)*(Fintype.card (BlockType (size g) p) : ℝ)) hcard (2*q)
rw [← Real.exp_nat_mul] at hpow
rw [Nat.cast_mul]
apply (mul_le_mul_of_nonneg_right hpow (Real.exp_pos _).le).trans_eq
rw [← Real.exp_add]
congr 1
push_cast
ring
end CoordinateSweeps.SignedTensor
namespace CoordinateSweeps.SignedTensor
lemma phase_eq_of_same_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
rw [phase_prod,phase_prod]
apply Finset.prod_congr rfl
intro ij hij
simp only [h]
lemma wordPerm_same_parity {p l : ℕ} (σ : Equiv.Perm (Fin l)) (w : Word p l)
(h : ∀ i, odd (w (σ i)) ↔ odd (w i)) :
∀ i, odd (wordPerm σ w i) ↔ odd (w i) := by
intro i
simpa [wordPerm] using (h (σ⁻¹ i)).symm
lemma phase_conj_of_parity_stable {p l : ℕ} (σ g : Equiv.Perm (Fin l)) (w : Word p l)
(h : ∀ i, odd (w (σ i)) ↔ odd (w i)) :
phase (g*σ*g⁻¹) (wordPerm g w)=phase σ w := by
have he : (g*σ*g⁻¹)*g=g*σ := by simp [mul_assoc]
have hh := phase_mul (g*σ*g⁻¹) g w
rw [he,phase_mul,phase_eq_of_same_parity g _ w (wordPerm_same_parity σ w h)] at hh
apply mul_right_cancel₀ (phase_ne_zero g w)
rw [← hh,mul_comm]
lemma phase_of_fix_odd {p l : ℕ} (σ : Equiv.Perm (Fin l)) (w : Word p l)
(h : ∀ i, odd (w i) → σ i=i) : phase σ w=1 := by
rw [phase_prod]
apply Finset.prod_eq_one
intro ij hij
have hj := Equiv.Perm.mem_finPairsLT.mp hij
split_ifs with hh
· rw [h _ hh.1,h _ hh.2.1] at hh
exact False.elim (hj.not_gt hh.2.2)
· rfl
lemma phase_swap_odd {p l : ℕ} (w : Word p l) (i j : Fin l) (hij : i ≠ j)
(hi : odd (w i)) (hj : odd (w j)) : phase (Equiv.swap i j) w = -1 := 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,hgi,hgj⟩ := exists_perm_pair i j (0 : Fin (n+2)) 1 hij (by simp)
have hp : ∀ x, odd (w (Equiv.swap i j x)) ↔ odd (w x) := by
intro x
simp only [Equiv.swap_apply_def]
split_ifs <;> simp_all
have he : g*Equiv.swap i j*g⁻¹=Equiv.swap (0 : Fin (n+2)) 1 := by
rw [Equiv.mul_swap_eq_swap_mul,mul_assoc,mul_inv_cancel,mul_one,hgi,hgj]
have hh:=phase_conj_of_parity_stable (Equiv.swap i j) g w hp
rw [he,phase_swap01] at hh
have h0 : wordPerm g w 0=w i := by rw [← hgi]; simp [wordPerm]
have h1 : wordPerm g w 1=w j := by rw [← hgj]; simp [wordPerm]
simpa [h0,h1,hi,hj] using hh.symm
lemma phase_ofSubtype {p l : ℕ} (w : Word p l)
(σ : Equiv.Perm {i : Fin l // odd (w i)}) :
phase (Equiv.Perm.ofSubtype σ) w = YoungCorner.signScalar σ := by
induction σ using Equiv.Perm.swap_induction_on with
| one => simp [phase_one]
| swap_mul σ i j hij ih =>
rw [map_mul,phase_mul,Equiv.Perm.ofSubtype_swap_eq]
have hp := wordPerm_same_parity (Equiv.Perm.ofSubtype σ) w
(Equiv.Perm.ofSubtype_apply_mem_iff_mem σ)
rw [phase_eq_of_same_parity _ _ w hp,
phase_swap_odd w i j (fun he => hij (Subtype.ext he)) i.property j.property,
ih,map_mul,YoungCorner.signScalar_swap i j hij]
lemma phase_of_fix_even {p l : ℕ} (σ : Equiv.Perm (Fin l)) (w : Word p l)
(h : ∀ i, ¬ odd (w i) → σ i=i) : phase σ w=YoungCorner.signScalar σ := by
have hp : ∀ i, odd (w (σ i)) ↔ odd (w i) := by
intro i
by_cases hi : odd (w i)
· have hs : odd (w (σ i)) := by
by_contra hn
have hh := h (σ i) hn
have he := σ.injective hh
rw [he] at hn
exact hn hi
simp [hi,hs]
· rw [h i hi]
let υ := Equiv.Perm.subtypePerm (p := fun i => odd (w i)) σ hp
have he : Equiv.Perm.ofSubtype υ=σ := Equiv.Perm.ofSubtype_subtypePerm (p := fun i => odd (w i)) hp (by
intro i hi
exact Classical.byContradiction (fun hn => hi (h i hn)))
rw [← he,phase_ofSubtype]
simp [YoungCorner.signScalar,Equiv.Perm.sign_ofSubtype]
end CoordinateSweeps.SignedTensor
namespace CoordinateSweeps.YoungCorner
variable {μ : YoungDiagram} {p : ℕ}
def Hook (μ : YoungDiagram) (p : ℕ) : Prop := ∀ x : Boxes μ, x.val.1<p ∨ x.val.2<p
def hookLetter (h : Hook μ p) (x : Boxes μ) : SignedTensor.Letter p :=
if hx : x.val.1<p then ⟨x.val.1,by omega⟩ else ⟨p+x.val.2,by have hh:=(h x).resolve_left hx; omega⟩
lemma hookLetter_odd (h : Hook μ p) (x : Boxes μ) :
SignedTensor.odd (hookLetter h x) ↔ p≤x.val.1 := by
simp only [hookLetter,SignedTensor.odd]
split_ifs <;> simp_all
omega
lemma hookLetter_row_eq (h : Hook μ p) (x y : Boxes μ)
(hx : x.val.1<p) (he : hookLetter h x=hookLetter h y) : x.val.1=y.val.1 := by
have he' := congrArg Fin.val he
simp only [hookLetter] at he'
split_ifs at he' <;> simp_all
omega
lemma hookLetter_col_eq (h : Hook μ p) (x y : Boxes μ)
(hx : p≤x.val.1) (he : hookLetter h x=hookLetter h y) : x.val.2=y.val.2 := by
have he' := congrArg Fin.val he
simp only [hookLetter] at he'
split_ifs at he' <;> simp_all <;> omega
/- The geometric reason all diagonal Young-corner coefficients have positive
sign on the actual even-row/odd-column hook word. -/
lemma hook_corner_fixed {X : Type*} (t : X ≃ Boxes μ) (h : Hook μ p)
(r : colorStabilizer (rowColor t)) (c : colorStabilizer (colColor t))
(hw : ∀ x, hookLetter h (t ((r : Equiv.Perm X) (c.val x)))=hookLetter h (t x)) :
(∀ x, (t x).val.1<p → c.val x=x) ∧ (∀ x, p≤(t x).val.1 → r.val x=x) := by
have hc : ∀ x, (t x).val.1<p → c.val x=x := by
intro x hx
apply t.injective
apply Subtype.ext
apply Prod.ext
· have hr:=r.property (c.val x)
have hh:=hookLetter_row_eq h (t x) (t (r.val (c.val x))) hx (hw x).symm
exact hr.symm.trans hh.symm
· exact c.property x
refine ⟨hc,?_⟩
intro y hy
let x := (c : Equiv.Perm X)⁻¹ y
have hxy : c.val x=y := by simp [x]
have hx : p≤(t x).val.1 := by
by_contra hn
have he := hc x (by omega)
rw [hxy] at he
rw [← he] at hn
omega
apply t.injective
apply Subtype.ext
apply Prod.ext
· exact r.property y
· have hh:=hookLetter_col_eq h (t x) (t (r.val (c.val x))) hx (hw x).symm
have hh' :=c.property x
change (t (c.val x)).val.2=(t x).val.2 at hh'
rw [hxy] at hh hh'
exact hh.symm.trans hh'.symm
lemma hook_corner_phase {l : ℕ} (t : Fin l ≃ Boxes μ) (h : Hook μ p)
(r : colorStabilizer (rowColor t)) (c : colorStabilizer (colColor t))
(hw : ∀ x, hookLetter h (t ((r : Equiv.Perm (Fin l)) (c.val x)))=hookLetter h (t x)) :
SignedTensor.phase ((r : Equiv.Perm (Fin l))*c.val) (fun x => hookLetter h (t x))=
signScalar (c : Equiv.Perm (Fin l)) := by
obtain ⟨hc,hr⟩ := hook_corner_fixed t h r c hw
let w : SignedTensor.Word p l := fun x => hookLetter h (t x)
have hce : ∀ i, ¬ SignedTensor.odd (w i) → (c : Equiv.Perm (Fin l)) i=i := by
intro i hi
exact hc i (by simpa only [w,hookLetter_odd,not_le] using hi)
have hcp : ∀ i, SignedTensor.odd (w (c.val i)) ↔ SignedTensor.odd (w i) := by
intro i
by_cases hi : SignedTensor.odd (w i)
· have hh : SignedTensor.odd (w (c.val i)) := by
by_contra hn
have he := c.val.injective (hce (c.val i) hn)
rw [he] at hn
exact hn hi
simp [hi,hh]
· rw [hce i hi]
rw [SignedTensor.phase_mul,SignedTensor.phase_eq_of_same_parity _ _ w
(SignedTensor.wordPerm_same_parity c.val w hcp),SignedTensor.phase_of_fix_odd _ w]
· rw [one_mul,SignedTensor.phase_of_fix_even c.val w hce]
· intro i hi
exact hr i ((hookLetter_odd h (t i)).mp hi)
end CoordinateSweeps.YoungCorner
namespace CoordinateSweeps.YoungCorner
variable {μ : YoungDiagram} {p l : ℕ}
lemma signScalar_square {X : Type*} [Fintype X] [DecidableEq X] (c : Equiv.Perm X) :
signScalar c * signScalar c=1 := by
rcases Int.units_eq_one_or (Equiv.Perm.sign c) with h|h <;> simp [signScalar,h]
lemma hook_contribution (t : Fin l ≃ Boxes μ) (h : Hook μ p)
(r : colorStabilizer (rowColor t)) (c : colorStabilizer (colColor t)) :
let w : SignedTensor.Word p l := fun x => hookLetter h (t x)
signScalar c.val * SignedTensor.matrix (r.val*c.val) w w =
if w=SignedTensor.wordPerm (r.val*c.val) w then 1 else 0 := by
dsimp only
rw [SignedTensor.matrix]
split_ifs with he
· have hw : ∀ x, hookLetter h (t (r.val (c.val x)))=hookLetter h (t x) := by
intro x
have hh := congrFun he ((r.val*c.val) x)
simpa [SignedTensor.wordPerm,Equiv.Perm.mul_apply] using hh
rw [hook_corner_phase t h r c hw,signScalar_square]
· simp
lemma hook_corner_matrix_ne (t : Fin l ≃ Boxes μ) (h : Hook μ p) :
fixedSum (rowColor t) (SignedTensor.action p l) *
alternatingSum (colColor t) (SignedTensor.action p l) ≠ 0 := by
let w : SignedTensor.Word p l := fun x => hookLetter h (t x)
have he : (fixedSum (rowColor t) (SignedTensor.action p l) *
alternatingSum (colColor t) (SignedTensor.action p l)) w w =
∑ r : colorStabilizer (rowColor t), ∑ c : colorStabilizer (colColor t),
if w=SignedTensor.wordPerm (r.val*c.val) w then (1 : ℂ) else 0 := by
rw [fixedSum,alternatingSum,Finset.sum_mul]
simp only [Finset.mul_sum,mul_smul_comm,← map_mul,Matrix.sum_apply,Matrix.smul_apply,smul_eq_mul]
apply Finset.sum_congr rfl
intro r hr
apply Finset.sum_congr rfl
intro c hc
exact hook_contribution t h r c
have hpos : 0 < ((fixedSum (rowColor t) (SignedTensor.action p l) *
alternatingSum (colColor t) (SignedTensor.action p l)) w w).re := by
rw [he]
simp only [Complex.re_sum,apply_ite,Complex.one_re,Complex.zero_re]
apply Finset.sum_pos'
· intro r hr
apply Finset.sum_nonneg
intro c hc
split_ifs <;> norm_num
· refine ⟨1,Finset.mem_univ _,?_⟩
apply Finset.sum_pos'
· intro c hc
split_ifs <;> norm_num
· refine ⟨1,Finset.mem_univ _,?_⟩
simp [SignedTensor.wordPerm]
intro hz
rw [hz] at hpos
simp at hpos
/- The literal signed action, as a linear representation. -/
def signedRep (p l : ℕ) : Representation ℂ (Equiv.Perm (Fin l)) (SignedTensor.Word p l → ℂ) :=
Matrix.toLinAlgEquiv'.toMonoidHom.comp (SignedTensor.action p l)
lemma signedRep_hasShape (t : Fin l ≃ Boxes μ) (h : Hook μ p) :
hasShape μ t (signedRep p l) := by
have he : fixedSum (rowColor t) (signedRep p l) * alternatingSum (colColor t) (signedRep p l) =
Matrix.toLinAlgEquiv' (fixedSum (rowColor t) (SignedTensor.action p l) *
alternatingSum (colColor t) (SignedTensor.action p l)) := by
simp [fixedSum,alternatingSum,signedRep,map_sum,map_mul]
intro hz
rw [he] at hz
exact hook_corner_matrix_ne t h (Matrix.toLinAlgEquiv'.injective (hz.trans (map_zero _).symm))
lemma detecting_shape_constituent {X V : Type*} [Fintype X] [DecidableEq X]
[AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V]
(τ : Representation ℂ (Equiv.Perm X) V) (t : X ≃ Boxes μ) (h : hasShape μ t τ) :
∃ S : Subrepresentation τ, S.toRepresentation.IsIrreducible ∧ hasShape μ t S.toRepresentation := by
obtain ⟨S,hS,v,hv⟩ := RepDetection.exists_irreducible_detecting τ
(fixedSum (rowColor t) τ*alternatingSum (colColor t) τ) h
refine ⟨S,hS,?_⟩
intro hh
apply hv
have hz := congrArg (fun A : Module.End ℂ S.toSubmodule => (A v : V)) hh
simp only [Module.End.mul_apply,fixedSum_subrepresentation,alternatingSum_subrepresentation] at hz
exact hz
/- Source05 hook occurrence, derived for actual irreps in the exact Koszul
representation. No Pieri/Schur--Weyl or hook classification is assumed. -/
theorem hook_occurs {V : Type} [AddCommGroup V] [Module ℂ V] [FiniteDimensional ℂ V]
(ρ : Representation ℂ (Equiv.Perm (Fin l)) V) [ρ.IsIrreducible]
(t : Fin l ≃ Boxes μ) (hρ : hasShape μ t ρ) (h : Hook μ p) :
∃ S : Subrepresentation (signedRep p l),
Nonempty (Representation.Equiv ρ S.toRepresentation) := by
obtain ⟨S,hS,hSh⟩ := detecting_shape_constituent (signedRep p l) t (signedRep_hasShape t h)
let := hS
exact ⟨S,equiv_of_same_shape ρ S.toRepresentation μ t t hρ hSh⟩
end CoordinateSweeps.YoungCorner
namespace CoordinateSweeps.YoungCorner
open UnitaryIrrep SignedTensor
lemma hook_multiplicity_pos {p l : ℕ} {μ : YoungDiagram}
(ρ : UnitaryIrrep (Equiv.Perm (Fin l))) (t : Fin l ≃ Boxes μ)
(hρ : hasShape μ t ρ.asRepresentation) (hhook : Hook μ p) :
0 < Module.finrank ℂ (ρ.asRepresentation.IntertwiningMap (matrixRepresentation (action p l))) := by
obtain ⟨S,⟨e⟩⟩ := hook_occurs ρ.asRepresentation t hρ hhook
let inc : S.toRepresentation.IntertwiningMap (signedRep p l) :=
⟨S.toSubmodule.subtype,fun _ => rfl⟩
let f := inc.comp e.toIntertwiningMap
have hf : f ≠ 0 := by
intro hz
have hzero : ∀ v : Fin ρ.dimension → ℂ, v=0 := by
intro v
apply e.toLinearEquiv.injective
apply Subtype.val_injective
have hh := congrArg (fun g : ρ.asRepresentation.IntertwiningMap (signedRep p l) => g v) hz
change ((e.toLinearEquiv v : S.toSubmodule) : SignedTensor.Word p l → ℂ)=0 at hh
rw [map_zero]
exact hh
have : Nonempty (Fin ρ.dimension) := Fin.pos_iff_nonempty.mp ρ.positive
exact one_ne_zero (congrFun (hzero (fun _ => 1)) (Classical.arbitrary (Fin ρ.dimension)))
let : Nontrivial (ρ.asRepresentation.IntertwiningMap (signedRep p l)) := nontrivial_of_ne f 0 hf
change 0 < Module.finrank ℂ (ρ.asRepresentation.IntertwiningMap (signedRep p l))
exact Module.finrank_pos
end CoordinateSweeps.YoungCorner
end
end
end
end
end
end
end
end
end
end
open scoped Matrix.Norms.L2Operator
end OAI