Download data/lean/OAI/RepresentationTheory/RowColumn/Multiplicity.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/RowColumn/Multiplicity.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/RepresentationTheory/RowColumn/Multiplicity.lean
-
curl -L -o Multiplicity.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/RowColumn/Multiplicity.lean
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 | |