math / data /lean /OAI /RepresentationTheory /RowColumn /Multiplicity.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
12.2 kB
import OAI.RepresentationTheory.RowColumn.HookModel
namespace OAI
noncomputable section
open scoped BigOperators Classical
namespace RowColumn
section Retraction
variable {G V W : Type*} [Group G] [Fintype G]
[AddCommGroup V] [Module β„‚ V] [AddCommGroup W] [Module β„‚ W]
{ρ : Representation β„‚ G V} {Οƒ : Representation β„‚ G W}
def algebraicAverage (A : V β†’β‚—[β„‚] W) : Representation.IntertwiningMap ρ Οƒ where
toLinearMap := βˆ‘ g, (Οƒ g).comp (A.comp (ρ g⁻¹))
isIntertwining' h := by
ext v
simp only [LinearMap.comp_apply, LinearMap.sum_apply, map_sum]
apply Fintype.sum_equiv (Equiv.mulLeft h⁻¹)
intro g
simp only [Equiv.coe_mulLeft, mul_inv_rev, inv_inv, map_mul, Module.End.mul_apply]
have hh (w : W) : Οƒ h (Οƒ h⁻¹ w) = w := by
change (Οƒ h * Οƒ h⁻¹) w = w
rw [← map_mul, mul_inv_cancel, map_one]
rfl
rw [hh]
/-- Averaging an algebraic left inverse produces a genuine equivariant retraction.
Used to transfer the signed-slot commutant bound to the hook Specht module. -/
lemma intertwiner_has_retraction (L : Representation.IntertwiningMap ρ Οƒ)
(hL : Function.Injective L) :
βˆƒ R : Representation.IntertwiningMap Οƒ ρ, βˆ€ v, R (L v) = v := by
obtain ⟨A, hA⟩ := L.toLinearMap.exists_leftInverse_of_injective
(LinearMap.ker_eq_bot.mpr hL)
refine ⟨(Fintype.card G : β„‚)⁻¹ β€’ algebraicAverage A, ?_⟩
intro v
change (Fintype.card G : β„‚)⁻¹ β€’ (βˆ‘ g, (ρ g).comp (A.comp (Οƒ g⁻¹))) (L v) = v
simp only [LinearMap.sum_apply, LinearMap.comp_apply]
have ha (g : G) : ρ g (A (Οƒ g⁻¹ (L v))) = v := by
rw [← Representation.IntertwiningMap.isIntertwining ρ Οƒ L]
have he : A (L (ρ g⁻¹ v)) = ρ g⁻¹ v :=
LinearMap.congr_fun hA (ρ g⁻¹ v)
rw [he]
change (ρ g * ρ g⁻¹) v = v
rw [← map_mul, mul_inv_cancel, map_one]
rfl
simp only [ha, Finset.sum_const, Finset.card_univ]
rw [← Nat.cast_smul_eq_nsmul β„‚, smul_smul, inv_mul_cancelβ‚€, one_smul]
exact_mod_cast Fintype.card_ne_zero
def extendCommutant (L : Representation.IntertwiningMap ρ Οƒ)
(R : Representation.IntertwiningMap Οƒ ρ) :
Representation.IntertwiningMap ρ ρ β†’β‚—[β„‚] Representation.IntertwiningMap Οƒ Οƒ where
toFun A := L.comp (A.comp R)
map_add' A B := by ext v; simp
map_smul' z A := by ext v; simp
omit [Fintype G] in
lemma extendCommutant_injective (L : Representation.IntertwiningMap ρ Οƒ)
(R : Representation.IntertwiningMap Οƒ ρ) (hL : Function.Injective L)
(hR : βˆ€ v, R (L v) = v) : Function.Injective (extendCommutant L R) := by
intro A B h
apply Representation.IntertwiningMap.ext
ext v
change A v = B v
apply hL
have he := congrArg (fun T : Representation.IntertwiningMap Οƒ Οƒ => T (L v)) h
simpa only [extendCommutant, LinearMap.coe_mk, AddHom.coe_mk,
Representation.IntertwiningMap.comp_apply, hR] using he
lemma commutant_finrank_le_of_embedding [FiniteDimensional β„‚ W]
(L : Representation.IntertwiningMap ρ Οƒ) (hL : Function.Injective L) :
Module.finrank β„‚ (Representation.IntertwiningMap ρ ρ) ≀
Module.finrank β„‚ (Representation.IntertwiningMap Οƒ Οƒ) := by
obtain ⟨R, hR⟩ := intertwiner_has_retraction L hL
exact LinearMap.finrank_le_finrank_of_injective (f := extendCommutant L R)
(extendCommutant_injective L R hL hR)
end Retraction
end RowColumn
namespace RowColumn
open scoped BigOperators Classical
open CubeShuffle.UnitaryFinite
section CopyCount
variable {G V X : Type*} [Group G]
[NormedAddCommGroup V] [InnerProductSpace β„‚ V] [FiniteDimensional β„‚ V]
[NormedAddCommGroup X] [InnerProductSpace β„‚ X] [FiniteDimensional β„‚ X]
{ρ : Representation β„‚ G V} {Ο„ : Representation β„‚ G X}
{u : β„•} (I : Fin u β†’ V β†’β‚—α΅’[β„‚] X)
lemma adjoint_intertwines (A : V β†’β‚—[β„‚] X) (hA : Intertwines ρ Ο„ A)
(hρ : IsUnitary ρ) (hΟ„ : IsUnitary Ο„) :
Intertwines Ο„ ρ A.toContinuousLinearMap.adjoint.toLinearMap := by
intro g x
apply ext_inner_left β„‚
intro v
change inner β„‚ v (A.toContinuousLinearMap.adjoint (Ο„ g x)) =
inner β„‚ v (ρ g (A.toContinuousLinearMap.adjoint x))
rw [ContinuousLinearMap.adjoint_inner_right]
rw [← inv_inv g, unitary_inner_inv ρ hρ, ContinuousLinearMap.adjoint_inner_right]
change inner β„‚ (A v) (Ο„ (g⁻¹)⁻¹ x) = inner β„‚ (A (ρ g⁻¹ v)) x
rw [hA, unitary_inner_inv Ο„ hΟ„]
def copyIdempotent (hI : βˆ€ i, Intertwines ρ Ο„ (I i).toLinearMap)
(hρ : IsUnitary ρ) (hΟ„ : IsUnitary Ο„) (i : Fin u) :
Representation.IntertwiningMap Ο„ Ο„ where
toLinearMap := (I i).toLinearMap.comp (I i).toContinuousLinearMap.adjoint.toLinearMap
isIntertwining' g := by
ext x
change I i ((I i).toContinuousLinearMap.adjoint (Ο„ g x)) =
Ο„ g (I i ((I i).toContinuousLinearMap.adjoint x))
rw [show (I i).toContinuousLinearMap.adjoint (Ο„ g x) =
ρ g ((I i).toContinuousLinearMap.adjoint x) from
adjoint_intertwines (I i).toLinearMap (hI i) hρ hΟ„ g x]
exact hI i g _
lemma adjoint_copy_apply (ho : βˆ€ i j, i β‰  j β†’ βˆ€ v w, inner β„‚ (I i v) (I j w) = 0)
(i j : Fin u) (v : V) :
(I i).toContinuousLinearMap.adjoint (I j v) = if i = j then v else 0 := by
apply ext_inner_left β„‚
intro w
rw [ContinuousLinearMap.adjoint_inner_right]
by_cases he : i = j
Β· subst j
simp [LinearIsometry.inner_map_map]
Β· simp only [ite_eq_right he, inner_zero_right, LinearIsometry.coe_toContinuousLinearMap]
exact ho i j he w v
lemma copyIdempotent_apply (hI : βˆ€ i, Intertwines ρ Ο„ (I i).toLinearMap)
(hρ : IsUnitary ρ) (hΟ„ : IsUnitary Ο„)
(ho : βˆ€ i j, i β‰  j β†’ βˆ€ v w, inner β„‚ (I i v) (I j w) = 0)
(i j : Fin u) (v : V) :
copyIdempotent I hI hρ hΟ„ i (I j v) = if i = j then I j v else 0 := by
change I i ((I i).toContinuousLinearMap.adjoint (I j v)) = _
rw [adjoint_copy_apply I ho]
split_ifs with he
Β· subst j; rfl
Β· exact map_zero _
/-- Orthogonal nonzero copies supply linearly independent elements of the
commutant by their actual range projections. -/
lemma copyIdempotent_independent [Nontrivial V]
(hI : βˆ€ i, Intertwines ρ Ο„ (I i).toLinearMap)
(hρ : IsUnitary ρ) (hΟ„ : IsUnitary Ο„)
(ho : βˆ€ i j, i β‰  j β†’ βˆ€ v w, inner β„‚ (I i v) (I j w) = 0) :
LinearIndependent β„‚ (copyIdempotent I hI hρ hΟ„) := by
obtain ⟨v, hv⟩ := exists_ne (0 : V)
rw [linearIndependent_iff']
intro s z hz j hj
have he := congrArg (fun T : Representation.IntertwiningMap Ο„ Ο„ => T (I j v)) hz
simp only [Representation.IntertwiningMap.sum_apply, Representation.IntertwiningMap.smul_apply,
copyIdempotent_apply I hI hρ hΟ„ ho] at he
have he' : βˆ‘ i ∈ s, z i β€’ (if i = j then I j v else 0) = 0 := he
simp only [smul_ite, smul_zero] at he'
simp only [Finset.sum_ite_eq', ite_eq_left hj] at he'
exact (smul_eq_zero.mp he').resolve_right (fun hz => hv ((I j).injective (hz.trans (map_zero _).symm)))
lemma copy_count_le_commutant [Nontrivial V]
(hI : βˆ€ i, Intertwines ρ Ο„ (I i).toLinearMap)
(hρ : IsUnitary ρ) (hΟ„ : IsUnitary Ο„)
(ho : βˆ€ i j, i β‰  j β†’ βˆ€ v w, inner β„‚ (I i v) (I j w) = 0) :
u ≀ Module.finrank β„‚ (Representation.IntertwiningMap Ο„ Ο„) := by
simpa using (copyIdempotent_independent I hI hρ hΟ„ ho).fintype_card_le_finrank
end CopyCount
end RowColumn
namespace RowColumn
open scoped BigOperators Classical
open CubeShuffle.Specht CubeShuffle.UnitaryFinite
section Relabelling
variable {S T L : Type*}
def lineGroupCongr (e : S ≃ T) (f : S β†’ L) :
lineGroup f ≃* lineGroup (f ∘ e.symm) where
toFun g := ⟨e.permCongr g.1, by
intro x
simpa only [Function.comp_apply, Equiv.permCongr_apply, Equiv.symm_apply_apply] using g.2 (e.symm x)⟩
invFun g := ⟨e.symm.permCongr g.1, by
intro x
simpa only [Function.comp_apply, Equiv.permCongr_apply, Equiv.symm_symm,
Equiv.symm_apply_apply] using g.2 (e x)⟩
left_inv g := by apply Subtype.ext; exact e.permCongr.symm_apply_apply g.1
right_inv g := by apply Subtype.ext; exact e.permCongr.apply_symm_apply g.1
map_mul' g t := by apply Subtype.ext; exact e.permCongrHom.map_mul g.1 t.1
end Relabelling
section Transfer
variable {G H V : Type*} [Group G] [Group H] [AddCommGroup V] [Module β„‚ V]
def commutantOfComp (ρ : Representation β„‚ G V) (e : H ≃* G) :
Representation.IntertwiningMap (ρ.comp e.toMonoidHom) (ρ.comp e.toMonoidHom) β†’β‚—[β„‚]
Representation.IntertwiningMap ρ ρ where
toFun T :=
{ toLinearMap := T.toLinearMap
isIntertwining' g := by simpa using T.isIntertwining' (e.symm g) }
map_add' A B := rfl
map_smul' z A := rfl
lemma commutantOfComp_injective (ρ : Representation β„‚ G V) (e : H ≃* G) :
Function.Injective (commutantOfComp ρ e) := by
intro T U he
exact Representation.IntertwiningMap.ext
(congrArg (fun T : Representation.IntertwiningMap ρ ρ => T.toLinearMap) he)
lemma commutant_comp_finrank_le [FiniteDimensional β„‚ V]
(ρ : Representation β„‚ G V) (e : H ≃* G) :
Module.finrank β„‚ (Representation.IntertwiningMap (ρ.comp e.toMonoidHom) (ρ.comp e.toMonoidHom)) ≀
Module.finrank β„‚ (Representation.IntertwiningMap ρ ρ) :=
LinearMap.finrank_le_finrank_of_injective (commutantOfComp_injective ρ e)
end Transfer
section HookMultiplicity
variable {S L : Type*} [Fintype S] [DecidableEq S] [Fintype L] [DecidableEq L]
(f : S β†’ L) (a : YoungDiagram) (e : S ≃ Cell a) (h : β„•) (H : InHook a h)
abbrev hookLineTarget :=
(Signed.lineRepresentation (odd := HookModel.IsOdd (h := h))
(k := HookModel.oddCount a h H) (f ∘ e.symm)).comp (lineGroupCongr e f).toMonoidHom
def hookLineEmbedding : Representation.IntertwiningMap
((relabelledUnitary a e).comp (lineGroup f).subtype) (hookLineTarget f a e h H) where
toLinearMap := (HookModel.hookEmbedding a h H).toLinearMap.comp (spaceHilbertEquiv a).symm.toLinearMap
isIntertwining' g := by
apply LinearMap.ext
intro v
let T := (HookModel.hookEmbedding a h H).comp (unitaryEquiv a).symm.toIntertwiningMap
exact Representation.IntertwiningMap.isIntertwining _ _ T (e.permCongr g.1) v
omit [Fintype S] [DecidableEq S] [Fintype L] [DecidableEq L] in
lemma hookLineEmbedding_injective : Function.Injective (hookLineEmbedding f a e h H) :=
(HookModel.hookEmbedding_injective a h H).comp (spaceHilbertEquiv a).symm.injective
include H
/-- Polynomial commutant estimate for the actual hook Specht representation
restricted to arbitrary fibres. This is the required first multiplicity bound
for both row and column restrictions in the occupied theorem. -/
lemma hook_line_commutant_bound :
Module.finrank β„‚ (Representation.IntertwiningMap
((relabelledUnitary a e).comp (lineGroup f).subtype)
((relabelledUnitary a e).comp (lineGroup f).subtype)) ≀
(Fintype.card S + 1) ^ (4 * Fintype.card L * h ^ 2) := by
apply (commutant_finrank_le_of_embedding (hookLineEmbedding f a e h H)
(hookLineEmbedding_injective f a e h H)).trans
apply (commutant_comp_finrank_le _ (lineGroupCongr e f)).trans
have hc := Signed.commutant_dimension_bound (odd := HookModel.IsOdd (h := h))
(k := HookModel.oddCount a h H) (f ∘ e.symm)
have hs : Fintype.card (Cell a) = Fintype.card S := (Fintype.card_congr e).symm
simpa only [hs, HookModel.Color, Fintype.card_sum, Fintype.card_fin,
show Fintype.card L * (h + h) ^ 2 = 4 * Fintype.card L * h ^ 2 by ring] using hc
lemma hook_line_copy_count {V : Type*} [NormedAddCommGroup V] [InnerProductSpace β„‚ V]
[FiniteDimensional β„‚ V] [Nontrivial V] (ρ : Representation β„‚ (lineGroup f) V)
(hρ : IsUnitary ρ) {u : β„•} (I : Fin u β†’ V β†’β‚—α΅’[β„‚] hilbertSpace a)
(hI : CompleteCopies (V := V) (W := hilbertSpace a) ρ ((relabelledUnitary a e).comp (lineGroup f).subtype) I) :
u ≀ (Fintype.card S + 1) ^ (4 * Fintype.card L * h ^ 2) :=
(copy_count_le_commutant (V := V) (X := hilbertSpace a) I hI.1 hρ (fun g => relabelledUnitary_unitary a e g.1) hI.2.1).trans
(hook_line_commutant_bound f a e h H)
end HookMultiplicity
end RowColumn
end
end OAI