Download data/lean/OAI/RepresentationTheory/PartialPermutation/Restriction.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 5.97 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/PartialPermutation/Restriction.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/RepresentationTheory/PartialPermutation/Restriction.lean
-
curl -L -o Restriction.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/RepresentationTheory/PartialPermutation/Restriction.lean
5.97 kB
| import Mathlib | |
| namespace OAI | |
| section | |
| open scoped Classical | |
| open scoped BigOperators ComplexConjugate MonoidAlgebra | |
| open scoped BigOperators ComplexConjugate | |
| open scoped MonoidAlgebra BigOperators | |
| open scoped BigOperators MonoidAlgebra Classical | |
| attribute [local instance] Classical.propDecidable | |
| open scoped BigOperators | |
| open scoped MonoidAlgebra BigOperators | |
| namespace PartialPermutation | |
| lemma isotypic_restrict_of_fullyInvariant {R S M : Type*} | |
| [Ring R] [Ring S] [AddCommGroup M] [Module R M] [Module S M] | |
| [IsSemisimpleModule R M] [IsSemisimpleModule S M] | |
| (Ο : S β+* R) (hsmul : β s : S, β x : M, Ο s β’ x = s β’ x) | |
| (h : IsIsotypic R M) | |
| (hinv : β N : Submodule S M, N.IsFullyInvariant β | |
| β r : R, β x β N, r β’ x β N) : IsIsotypic S M := by | |
| apply isIsotypic_iff_isFullyInvariant_imp_bot_or_top.mpr | |
| intro N hN | |
| let NR : Submodule R M := { N with smul_mem' := hinv N hN } | |
| have hNR : NR.IsFullyInvariant := by | |
| intro f x hx | |
| let fS : Module.End S M := | |
| { f.toAddMonoidHom with | |
| map_smul' := fun s x => by | |
| change f (s β’ x) = s β’ f x | |
| rw [β hsmul, f.map_smul, hsmul] } | |
| exact hN fS hx | |
| rcases (isIsotypic_iff_isFullyInvariant_imp_bot_or_top.mp h) NR hNR with h0 | h1 | |
| Β· left | |
| ext x | |
| change x β NR β x = 0 | |
| rw [h0, Submodule.mem_bot] | |
| Β· right | |
| ext x | |
| change x β NR β x β (β€ : Submodule S M) | |
| simp [h1] | |
| section GroupRestriction | |
| variable {G M : Type*} [Group G] [AddCommGroup M] [Module β[G] M] | |
| @[instance_reducible] noncomputable def restrictGroupModule (H : Subgroup G) : Module β[H] M := | |
| Module.compHom M (MonoidAlgebra.mapDomainAlgHom β β H.subtype).toRingHom | |
| lemma restrictGroupModule_smul (H : Subgroup G) (s : β[H]) (x : M) : | |
| letI := restrictGroupModule (M := M) H | |
| s β’ x = (MonoidAlgebra.mapDomainAlgHom β β H.subtype s) β’ x := rfl | |
| lemma group_isotypic_restrict [Finite G] {ΞΉ : Type*} (H : ΞΉ β Subgroup G) | |
| (hgen : β¨ i, H i = β€) | |
| (hcomm : β i j, i β j β β g β H i, β k β H j, Commute g k) | |
| (h : IsIsotypic β[G] M) (i : ΞΉ) : | |
| letI := restrictGroupModule (M := M) (H i) | |
| IsIsotypic β[H i] M := by | |
| let := restrictGroupModule (M := M) (H i) | |
| let Ο : β[H i] β+* β[G] := | |
| (MonoidAlgebra.mapDomainAlgHom β β (H i).subtype).toRingHom | |
| apply isotypic_restrict_of_fullyInvariant Ο (fun s x => rfl) h | |
| intro N hN | |
| have hsingle (g : G) : β x β N, (MonoidAlgebra.single g (1 : β)) β’ x β N := by | |
| have hg : g β β¨ j, H j := by rw [hgen]; exact Subgroup.mem_top g | |
| refine Subgroup.iSup_induction H | |
| (C := fun g => β x β N, (MonoidAlgebra.single g (1 : β)) β’ x β N) hg ?_ ?_ ?_ | |
| Β· intro j g hg | |
| by_cases hji : j = i | |
| Β· subst j | |
| intro x hx | |
| have hs := N.smul_mem (MonoidAlgebra.single (β¨g, hgβ© : H i) (1 : β)) hx | |
| change Ο (MonoidAlgebra.single (β¨g, hgβ© : H i) (1 : β)) β’ x β N at hs | |
| simpa [Ο, MonoidAlgebra.mapDomainAlgHom] using hs | |
| Β· have hΟ (a : β[H i]) : Commute (MonoidAlgebra.single g (1 : β)) (Ο a) := by | |
| induction a using MonoidAlgebra.induction_linear with | |
| | zero => simp | |
| | add a b ha hb => simpa using ha.add_right hb | |
| | single k a => | |
| simpa [Ο, MonoidAlgebra.mapDomainAlgHom] using | |
| (MonoidAlgebra.single_commute_single (hcomm j i hji g hg k k.property) | |
| (Commute.all (1 : β) a)) | |
| let T : Module.End β[H i] M := | |
| { toFun := fun x => (MonoidAlgebra.single g (1 : β)) β’ x | |
| map_add' := smul_add _ | |
| map_smul' := fun a x => by | |
| change (MonoidAlgebra.single g (1 : β)) β’ (Ο a β’ x) = | |
| Ο a β’ ((MonoidAlgebra.single g (1 : β)) β’ x) | |
| simp only [smul_smul, (hΟ a).eq] } | |
| exact fun x hx => hN T hx | |
| Β· intro x hx | |
| simpa [β MonoidAlgebra.one_def] using hx | |
| Β· intro g k hg hk x hx | |
| have he : (MonoidAlgebra.single (g * k) (1 : β) : β[G]) = | |
| MonoidAlgebra.single g 1 * MonoidAlgebra.single k 1 := by | |
| simp [MonoidAlgebra.single_mul_single] | |
| rw [he, mul_smul] | |
| exact hg _ (hk _ hx) | |
| intro r x hx | |
| induction r using MonoidAlgebra.induction_linear with | |
| | zero => simp | |
| | add a b ha hb => simpa [add_smul] using N.add_mem ha hb | |
| | single g a => | |
| have hg := hsingle g x hx | |
| have hs := N.smul_mem (MonoidAlgebra.single (1 : H i) a) hg | |
| change Ο (MonoidAlgebra.single (1 : H i) a) β’ | |
| ((MonoidAlgebra.single g (1 : β)) β’ x) β N at hs | |
| simpa [Ο, MonoidAlgebra.mapDomainAlgHom, smul_smul, | |
| MonoidAlgebra.single_mul_single] using hs | |
| lemma restrictGroupModule_tower [Module β M] [IsScalarTower β β[G] M] | |
| (H : Subgroup G) : | |
| letI := restrictGroupModule (M := M) H | |
| IsScalarTower β β[H] M := by | |
| let := restrictGroupModule (M := M) H | |
| apply IsScalarTower.of_algebraMap_smul | |
| intro c x | |
| change (MonoidAlgebra.mapDomainAlgHom β β H.subtype (algebraMap β β[H] c)) β’ x = c β’ x | |
| rw [AlgHom.commutes, algebraMap_smul] | |
| lemma subgroup_algebra_commute (H K : Subgroup G) | |
| (h : β g β H, β k β K, Commute g k) (a : β[H]) (b : β[K]) : | |
| Commute (MonoidAlgebra.mapDomainAlgHom β β H.subtype a) | |
| (MonoidAlgebra.mapDomainAlgHom β β K.subtype b) := by | |
| induction a using MonoidAlgebra.induction_linear with | |
| | zero => simp | |
| | add aβ aβ haβ haβ => | |
| simp only [map_add] | |
| exact haβ.add_left haβ | |
| | single g c => | |
| induction b using MonoidAlgebra.induction_linear with | |
| | zero => simp | |
| | add bβ bβ hbβ hbβ => | |
| simp only [map_add] | |
| exact hbβ.add_right hbβ | |
| | single k d => | |
| simpa [MonoidAlgebra.mapDomainAlgHom] using | |
| (MonoidAlgebra.single_commute_single (h g g.property k k.property) (Commute.all c d)) | |
| end GroupRestriction | |
| end PartialPermutation | |
| end | |
| end OAI | |