| 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 |
|
|
