fact stringlengths 6 3.84k | type stringclasses 11
values | library stringclasses 32
values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
isSemisimpleModule_of_isSemisimpleModule_submodule' {p : ι → Submodule R M}
(hp : ∀ i, IsSemisimpleModule R (p i)) (hp' : ⨆ i, p i = ⊤) :
IsSemisimpleModule R M :=
isSemisimpleModule_of_isSemisimpleModule_submodule (s := Set.univ) (fun i _ ↦ hp i) (by simpa) | lemma | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | isSemisimpleModule_of_isSemisimpleModule_submodule' | null |
IsSemisimpleModule.exists_linearEquiv_dfinsupp [IsSemisimpleModule R M] :
∃ (s : Set (Submodule R M)) (_ : M ≃ₗ[R] Π₀ m : s, m.1),
sSupIndep s ∧ ∀ m : s, IsSimpleModule R m.1 := by
have ⟨s, ind, sSup, simple⟩ := IsSemisimpleModule.exists_sSupIndep_sSup_simples_eq_top R M
refine ⟨s, ?_, ind, SetCoe.forall.mpr simple⟩
rw [sSupIndep_iff] at ind
classical
exact .symm <| .trans (.ofInjective _ ind.dfinsupp_lsum_injective) <| .trans (.ofEq _ ⊤ <|
by rw [← Submodule.iSup_eq_range_dfinsupp_lsum, ← sSup, sSup_eq_iSup']) Submodule.topEquiv | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | IsSemisimpleModule.exists_linearEquiv_dfinsupp | null |
isSemisimpleModule_iff_exists_linearEquiv_dfinsupp : IsSemisimpleModule R M ↔
∃ (s : Set (Submodule R M)) (_ : M ≃ₗ[R] Π₀ m : s, m.1), ∀ m : s, IsSimpleModule R m.1 := by
refine ⟨fun _ ↦ ?_, fun ⟨s, e, h⟩ ↦ .congr e⟩
have ⟨s, e, h⟩ := IsSemisimpleModule.exists_linearEquiv_dfinsupp R M
exact ⟨s, e, h.2⟩
variable (R M) in | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | isSemisimpleModule_iff_exists_linearEquiv_dfinsupp | null |
IsSemisimpleModule.exists_linearEquiv_fin_dfinsupp [IsSemisimpleModule R M]
[Module.Finite R M] : ∃ (n : ℕ) (S : Fin n → Submodule R M)
(_ : M ≃ₗ[R] Π₀ i : Fin n, S i), ∀ i, IsSimpleModule R (S i) :=
have ⟨s, e, h, simple⟩ := IsSemisimpleModule.exists_linearEquiv_dfinsupp R M
have := WellFoundedGT.finite_of_iSupIndep ((sSupIndep_iff _).mp h)
fun S ↦ (S.1.nontrivial_iff_ne_bot).mp <| IsSimpleModule.nontrivial R S
⟨_, _, e.trans <| DirectSum.lequivCongrLeft R (Finite.equivFin s), fun _ ↦ simple _⟩
open LinearMap in | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | IsSemisimpleModule.exists_linearEquiv_fin_dfinsupp | null |
IsSemisimpleModule.sup {p q : Submodule R M}
(_ : IsSemisimpleModule R p) (_ : IsSemisimpleModule R q) :
IsSemisimpleModule R ↥(p ⊔ q) := by
let f : Bool → Submodule R M := Bool.rec q p
rw [show p ⊔ q = ⨆ i ∈ Set.univ, f i by rw [iSup_univ, iSup_bool_eq]]
exact isSemisimpleModule_biSup_of_isSemisimpleModule_submodule
(by rintro (_ | _) _ <;> assumption) | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | IsSemisimpleModule.sup | null |
IsSemisimpleRing.isSemisimpleModule [IsSemisimpleRing R] : IsSemisimpleModule R M :=
have : IsSemisimpleModule R (M →₀ R) := isSemisimpleModule_of_isSemisimpleModule_submodule'
(fun _ ↦ .congr (LinearMap.quotKerEquivRange _).symm) Finsupp.iSup_lsingle_range
.congr (LinearMap.quotKerEquivOfSurjective _ <| Finsupp.linearCombination_id_surjective R M).symm | instance | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | IsSemisimpleRing.isSemisimpleModule | null |
IsSemisimpleModule.isCoatomic_submodule [IsSemisimpleModule R M] :
IsCoatomic (Submodule R M) :=
isCoatomic_of_isAtomic_of_complementedLattice_of_isModular
open LinearMap in | instance | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | IsSemisimpleModule.isCoatomic_submodule | null |
bijective_or_eq_zero [IsSimpleModule R M] [IsSimpleModule R N] (f : M →ₗ[R] N) :
Function.Bijective f ∨ f = 0 :=
or_iff_not_imp_right.mpr fun h ↦ ⟨injective_of_ne_zero h, surjective_of_ne_zero h⟩ | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | bijective_or_eq_zero | A finite product of semisimple rings is semisimple. -/
instance {ι} [Finite ι] (R : ι → Type*) [Π i, Ring (R i)] [∀ i, IsSemisimpleRing (R i)] :
IsSemisimpleRing (Π i, R i) := by
letI _ (i) : Module (Π i, R i) (R i) := Module.compHom _ (Pi.evalRingHom R i)
let e (i) : R i →ₛₗ[Pi.evalRingHom R i] R i :=
{ AddMonoidHom.id (R i) with map_smul' := fun _ _ ↦ rfl }
have (i : _) : IsSemisimpleModule (Π i, R i) (R i) :=
((e i).isSemisimpleModule_iff_of_bijective Function.bijective_id).mpr inferInstance
infer_instance
/-- A binary product of semisimple rings is semisimple. -/
instance [hR : IsSemisimpleRing R] [hS : IsSemisimpleRing S] : IsSemisimpleRing (R × S) := by
letI : Module (R × S) R := Module.compHom _ (.fst R S)
letI : Module (R × S) S := Module.compHom _ (.snd R S)
-- e₁, e₂ got falsely flagged by the unused argument linter
let _e₁ : R →ₛₗ[.fst R S] R := { AddMonoidHom.id R with map_smul' := fun _ _ ↦ rfl }
let _e₂ : S →ₛₗ[.snd R S] S := { AddMonoidHom.id S with map_smul' := fun _ _ ↦ rfl }
rw [IsSemisimpleRing, ← _e₁.isSemisimpleModule_iff_of_bijective Function.bijective_id] at hR
rw [IsSemisimpleRing, ← _e₂.isSemisimpleModule_iff_of_bijective Function.bijective_id] at hS
rw [IsSemisimpleRing, ← Submodule.topEquiv.isSemisimpleModule_iff_of_bijective
(LinearEquiv.bijective _), ← LinearMap.sup_range_inl_inr]
exact .sup (.range _) (.range _)
theorem RingHom.isSemisimpleRing_of_surjective (f : R →+* S) (hf : Function.Surjective f)
[IsSemisimpleRing R] : IsSemisimpleRing S := by
letI : Module R S := Module.compHom _ f
haveI : RingHomSurjective f := ⟨hf⟩
let e : S →ₛₗ[f] S := { AddMonoidHom.id S with map_smul' := fun _ _ ↦ rfl }
rw [IsSemisimpleRing, ← e.isSemisimpleModule_iff_of_bijective Function.bijective_id]
infer_instance
theorem IsSemisimpleRing.ideal_eq_span_idempotent [IsSemisimpleRing R] (I : Ideal R) :
∃ e : R, IsIdempotentElem e ∧ I = .span {e} := by
obtain ⟨J, h⟩ := exists_isCompl I
obtain ⟨f, idem, rfl⟩ := I.isIdempotentElemEquiv.symm (I.isComplEquivProj ⟨J, h⟩)
exact ⟨f 1, LinearMap.isIdempotentElem_apply_one_iff.mpr idem, by
rw [LinearMap.range_eq_map, ← Ideal.span_one, ← Ideal.submodule_span_eq, LinearMap.map_span,
Set.image_one, Ideal.submodule_span_eq]⟩
instance [IsSemisimpleRing R] : IsPrincipalIdealRing R where
principal I := have ⟨e, _, he⟩ := IsSemisimpleRing.ideal_eq_span_idempotent I; ⟨e, he⟩
variable (ι R)
proof_wanted IsSemisimpleRing.mulOpposite [IsSemisimpleRing R] : IsSemisimpleRing Rᵐᵒᵖ
proof_wanted IsSemisimpleRing.module_end [IsSemisimpleModule R M] [Module.Finite R M] :
IsSemisimpleRing (Module.End R M)
proof_wanted IsSemisimpleRing.matrix [Fintype ι] [DecidableEq ι] [IsSemisimpleRing R] :
IsSemisimpleRing (Matrix ι ι R)
universe u in
/-- The existence part of the Artin–Wedderburn theorem. -/
proof_wanted isSemisimpleRing_iff_pi_matrix_divisionRing {R : Type u} [Ring R] :
IsSemisimpleRing R ↔
∃ (n : ℕ) (S : Fin n → Type u) (d : Fin n → ℕ) (_ : Π i, DivisionRing (S i)),
Nonempty (R ≃+* Π i, Matrix (Fin (d i)) (Fin (d i)) (S i))
variable {ι R}
namespace LinearMap
theorem injective_or_eq_zero [IsSimpleModule R M] (f : M →ₗ[R] N) :
Function.Injective f ∨ f = 0 := by
rw [← ker_eq_bot, ← ker_eq_top]
apply eq_bot_or_eq_top
theorem injective_of_ne_zero [IsSimpleModule R M] {f : M →ₗ[R] N} (h : f ≠ 0) :
Function.Injective f :=
f.injective_or_eq_zero.resolve_right h
theorem surjective_or_eq_zero [IsSimpleModule R N] (f : M →ₗ[R] N) :
Function.Surjective f ∨ f = 0 := by
rw [← range_eq_top, ← range_eq_bot, or_comm]
apply eq_bot_or_eq_top
theorem surjective_of_ne_zero [IsSimpleModule R N] {f : M →ₗ[R] N} (h : f ≠ 0) :
Function.Surjective f :=
f.surjective_or_eq_zero.resolve_right h
/-- **Schur's Lemma** for linear maps between (possibly distinct) simple modules |
bijective_of_ne_zero [IsSimpleModule R M] [IsSimpleModule R N] {f : M →ₗ[R] N} (h : f ≠ 0) :
Function.Bijective f :=
f.bijective_or_eq_zero.resolve_right h | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | bijective_of_ne_zero | null |
isCoatom_ker_of_surjective [IsSimpleModule R N] {f : M →ₗ[R] N}
(hf : Function.Surjective f) : IsCoatom (LinearMap.ker f) := by
rw [← isSimpleModule_iff_isCoatom]
exact IsSimpleModule.congr (f.quotKerEquivOfSurjective hf) | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | isCoatom_ker_of_surjective | null |
linearEquiv_of_ne_zero [IsSemisimpleModule R M] [IsSimpleModule R N]
{f : M →ₗ[R] N} (h : f ≠ 0) : ∃ S : Submodule R M, Nonempty (N ≃ₗ[R] S) :=
have ⟨m, (_ : IsSimpleModule R m), ne⟩ :=
exists_ne_zero_of_sSup_eq_top h _ (IsSemisimpleModule.sSup_simples_eq_top ..)
⟨m, ⟨.symm <| .ofBijective _ ((bijective_or_eq_zero _).resolve_right ne)⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | linearEquiv_of_ne_zero | null |
noncomputable _root_.Module.End.instDivisionRing
[DecidableEq (Module.End R M)] [IsSimpleModule R M] : DivisionRing (Module.End R M) where
inv f := if h : f = 0 then 0 else (LinearEquiv.ofBijective _ <| bijective_of_ne_zero h).symm
exists_pair_ne := ⟨0, 1, have := IsSimpleModule.nontrivial R M; zero_ne_one⟩
mul_inv_cancel a a0 := by
simp_rw [dif_neg a0]; ext
exact (LinearEquiv.ofBijective _ <| bijective_of_ne_zero a0).right_inv _
inv_zero := dif_pos rfl
nnqsmul := _
nnqsmul_def := fun _ _ => rfl
qsmul := _
qsmul_def := fun _ _ => rfl | instance | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | _root_.Module.End.instDivisionRing | Schur's Lemma makes the endomorphism ring of a simple module a division ring. |
instJordanHolderLattice : JordanHolderLattice (Submodule R M) where
IsMaximal := (· ⋖ ·)
lt_of_isMaximal := CovBy.lt
sup_eq_of_isMaximal hxz hyz := WCovBy.sup_eq hxz.wcovBy hyz.wcovBy
isMaximal_inf_left_of_isMaximal_sup := inf_covBy_of_covBy_sup_of_covBy_sup_left
Iso X Y := Nonempty <| (X.2 ⧸ X.1.comap X.2.subtype) ≃ₗ[R] Y.2 ⧸ Y.1.comap Y.2.subtype
iso_symm := fun ⟨f⟩ => ⟨f.symm⟩
iso_trans := fun ⟨f⟩ ⟨g⟩ => ⟨f.trans g⟩
second_iso {X} {Y} _ := by
constructor
rw [sup_comm, inf_comm]
dsimp
exact (LinearMap.quotientInfEquivSupQuotient Y X).symm | instance | RingTheory | [
"Mathlib.Algebra.DirectSum.Module",
"Mathlib.Data.Finite.Card",
"Mathlib.Data.Matrix.Mul",
"Mathlib.LinearAlgebra.DFinsupp",
"Mathlib.LinearAlgebra.Finsupp.Span",
"Mathlib.LinearAlgebra.Isomorphisms",
"Mathlib.LinearAlgebra.Projection",
"Mathlib.Order.Atoms.Finite",
"Mathlib.Order.CompactlyGenerated... | Mathlib/RingTheory/SimpleModule/Basic.lean | instJordanHolderLattice | null |
injective_of_isSemisimpleRing : Module.Injective R M where
out X Y _ _ _ _ f hf g :=
let ⟨h, comp⟩ := IsSemisimpleModule.extension_property f hf g
⟨h, fun _ ↦ by rw [← comp, LinearMap.comp_apply]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.SimpleModule.Basic",
"Mathlib.Algebra.Module.Injective",
"Mathlib.Algebra.Module.Projective"
] | Mathlib/RingTheory/SimpleModule/InjectiveProjective.lean | injective_of_isSemisimpleRing | null |
projective_of_isSemisimpleRing : Module.Projective R M :=
.of_lifting_property'' (IsSemisimpleModule.lifting_property · · _)
@[deprecated (since := "2025-09-12")]
alias injective_of_semisimple_ring := injective_of_isSemisimpleRing
@[deprecated (since := "2025-09-12")]
alias projective_of_semisimple_ring := projective_of_isSemisimpleRing | theorem | RingTheory | [
"Mathlib.RingTheory.SimpleModule.Basic",
"Mathlib.Algebra.Module.Injective",
"Mathlib.Algebra.Module.Projective"
] | Mathlib/RingTheory/SimpleModule/InjectiveProjective.lean | projective_of_isSemisimpleRing | null |
IsSimpleRing.exists_algEquiv_matrix_of_isAlgClosed
[IsSimpleRing R] [FiniteDimensional F R] :
∃ (n : ℕ) (_ : NeZero n), Nonempty (R ≃ₐ[F] Matrix (Fin n) (Fin n) F) :=
have := IsArtinianRing.of_finite F R
have ⟨n, hn, D, _, _, _, ⟨e⟩⟩ := exists_algEquiv_matrix_divisionRing_finite F R
⟨n, hn, ⟨e.trans <| .mapMatrix <| .symm <| .ofBijective (Algebra.ofId F D)
IsAlgClosed.algebraMap_bijective_of_isIntegral⟩⟩ | theorem | RingTheory | [
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.RingTheory.SimpleModule.WedderburnArtin"
] | Mathlib/RingTheory/SimpleModule/IsAlgClosed.lean | IsSimpleRing.exists_algEquiv_matrix_of_isAlgClosed | The **Wedderburn–Artin Theorem** over algebraically closed fields: a finite-dimensional
simple algebra over an algebraically closed field is isomorphic to a matrix algebra over the field. |
IsSemisimpleRing.exists_algEquiv_pi_matrix_of_isAlgClosed
[IsSemisimpleRing R] [FiniteDimensional F R] :
∃ (n : ℕ) (d : Fin n → ℕ), (∀ i, NeZero (d i)) ∧
Nonempty (R ≃ₐ[F] Π i, Matrix (Fin (d i)) (Fin (d i)) F) :=
have ⟨n, D, d, _, _, _, hd, ⟨e⟩⟩ := exists_algEquiv_pi_matrix_divisionRing_finite F R
⟨n, d, hd, ⟨e.trans <| .piCongrRight fun i ↦ .mapMatrix <| .symm <| .ofBijective
(Algebra.ofId F (D i)) IsAlgClosed.algebraMap_bijective_of_isIntegral⟩⟩ | theorem | RingTheory | [
"Mathlib.FieldTheory.IsAlgClosed.Basic",
"Mathlib.RingTheory.SimpleModule.WedderburnArtin"
] | Mathlib/RingTheory/SimpleModule/IsAlgClosed.lean | IsSemisimpleRing.exists_algEquiv_pi_matrix_of_isAlgClosed | The **Wedderburn–Artin Theorem** over algebraically closed fields: a finite-dimensional
semisimple algebra over an algebraically closed field is isomorphic to a product of matrix algebras
over the field. |
IsIsotypicOfType : Prop := ∀ (m : Submodule R M) [IsSimpleModule R m], Nonempty (m ≃ₗ[R] S) | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypicOfType | An `R`-module `M` is isotypic of type `S` if all simple submodules of `M` are isomorphic
to `S`. If `M` is semisimple, it is equivalent to requiring that all simple quotients of `M` are
isomorphic to `S`. |
IsIsotypic : Prop := ∀ (m : Submodule R M) [IsSimpleModule R m], IsIsotypicOfType R M m
variable {R M S} in | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypic | An `R`-module `M` is isotypic if all its simple submodules are isomorphic. |
IsIsotypicOfType.isIsotypic (h : IsIsotypicOfType R M S) : IsIsotypic R M :=
fun m _ m' _ ↦ ⟨(h m').some.trans (h m).some.symm⟩
@[nontriviality] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypicOfType.isIsotypic | null |
IsIsotypicOfType.of_subsingleton [Subsingleton M] : IsIsotypicOfType R M S :=
fun S ↦ have := IsSimpleModule.nontrivial R S
(not_subsingleton _ S.subtype_injective.subsingleton).elim
@[nontriviality] theorem IsIsotypic.of_subsingleton [Subsingleton M] : IsIsotypic R M :=
fun S ↦ (IsIsotypicOfType.of_subsingleton R M S).isIsotypic S | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypicOfType.of_subsingleton | null |
IsIsotypicOfType.of_isSimpleModule [IsSimpleModule R M] : IsIsotypicOfType R M M :=
fun S hS ↦ by
rw [isSimpleModule_iff_isAtom, isAtom_iff_eq_top] at hS
exact ⟨.trans (.ofEq _ _ hS) Submodule.topEquiv⟩
variable {R M N S} | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypicOfType.of_isSimpleModule | null |
IsIsotypicOfType.of_linearEquiv_type (h : IsIsotypicOfType R M S) (e : S ≃ₗ[R] N) :
IsIsotypicOfType R M N := fun m _ ↦ ⟨(h m).some.trans e⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypicOfType.of_linearEquiv_type | null |
IsIsotypicOfType.of_injective (h : IsIsotypicOfType R N S) (f : M →ₗ[R] N)
(inj : Function.Injective f) : IsIsotypicOfType R M S := fun m ↦
have em := m.equivMapOfInjective f inj
have := IsSimpleModule.congr em.symm
⟨em.trans (h (m.map f)).some⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypicOfType.of_injective | null |
IsIsotypic.of_injective (h : IsIsotypic R N) (f : M →ₗ[R] N) (inj : Function.Injective f) :
IsIsotypic R M := fun m _ ↦
have em := (m.equivMapOfInjective f inj).symm
have := IsSimpleModule.congr em
((h (m.map f)).of_injective f inj).of_linearEquiv_type em | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypic.of_injective | null |
LinearEquiv.isIsotypicOfType_iff (e : M ≃ₗ[R] N) :
IsIsotypicOfType R M S ↔ IsIsotypicOfType R N S :=
⟨(·.of_injective _ e.symm.injective), (·.of_injective _ e.injective)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | LinearEquiv.isIsotypicOfType_iff | null |
LinearEquiv.isIsotypicOfType_iff_type (e : N ≃ₗ[R] S) :
IsIsotypicOfType R M N ↔ IsIsotypicOfType R M S :=
⟨(·.of_linearEquiv_type e), (·.of_linearEquiv_type e.symm)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | LinearEquiv.isIsotypicOfType_iff_type | null |
LinearEquiv.isIsotypic_iff (e : M ≃ₗ[R] N) : IsIsotypic R M ↔ IsIsotypic R N :=
⟨(·.of_injective _ e.symm.injective), (·.of_injective _ e.injective)⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | LinearEquiv.isIsotypic_iff | null |
isIsotypicOfType_submodule_iff {N : Submodule R M} :
IsIsotypicOfType R N S ↔ ∀ m ≤ N, [IsSimpleModule R m] → Nonempty (m ≃ₗ[R] S) := by
rw [Subtype.forall', ← (Submodule.MapSubtype.orderIso N).forall_congr_right]
have e := Submodule.equivMapOfInjective _ N.subtype_injective
simp_rw [Submodule.MapSubtype.orderIso, Equiv.coe_fn_mk, ← (e _).isSimpleModule_iff]
exact forall₂_congr fun m _ ↦ ⟨fun ⟨e'⟩ ↦ ⟨(e m).symm.trans e'⟩, fun ⟨e'⟩ ↦ ⟨(e m).trans e'⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | isIsotypicOfType_submodule_iff | null |
isIsotypic_submodule_iff {N : Submodule R M} :
IsIsotypic R N ↔ ∀ m ≤ N, [IsSimpleModule R m] → IsIsotypicOfType R N m := by
rw [Subtype.forall', ← (Submodule.MapSubtype.orderIso N).forall_congr_right]
have e := Submodule.equivMapOfInjective _ N.subtype_injective
simp_rw [Submodule.MapSubtype.orderIso, Equiv.coe_fn_mk, ← (e _).isSimpleModule_iff,
← (e _).isIsotypicOfType_iff_type, IsIsotypic] | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | isIsotypic_submodule_iff | null |
IsIsotypicOfType.linearEquiv_finsupp (h : IsIsotypicOfType R M S) :
∃ ι : Type u, Nonempty (M ≃ₗ[R] ι →₀ S) := by
have ⟨s, e, _, hs⟩ := IsSemisimpleModule.exists_linearEquiv_dfinsupp R M
classical exact ⟨s, ⟨e.trans (DFinsupp.mapRange.linearEquiv fun m : s ↦ (h m.1).some)
|>.trans (finsuppLequivDFinsupp R).symm⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypicOfType.linearEquiv_finsupp | null |
IsIsotypic.linearEquiv_finsupp [Nontrivial M] (h : IsIsotypic R M) :
∃ (ι : Type u) (_ : Nonempty ι) (S : Submodule R M),
IsSimpleModule R S ∧ Nonempty (M ≃ₗ[R] ι →₀ S) := by
have ⟨S, hS⟩ := IsAtomic.exists_atom (Submodule R M)
rw [← isSimpleModule_iff_isAtom] at hS
have ⟨ι, e⟩ := (h S).linearEquiv_finsupp
exact ⟨ι, (isEmpty_or_nonempty ι).resolve_left fun _ ↦ not_subsingleton _ (e.some.subsingleton),
S, hS, e⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypic.linearEquiv_finsupp | null |
IsIsotypicOfType.linearEquiv_fun [Module.Finite R M] (h : IsIsotypicOfType R M S) :
∃ n : ℕ, Nonempty (M ≃ₗ[R] Fin n → S) := by
have ⟨n, S, e, hs⟩ := IsSemisimpleModule.exists_linearEquiv_fin_dfinsupp R M
classical exact ⟨n, ⟨e.trans (DFinsupp.mapRange.linearEquiv fun i ↦ (h (S i)).some)
|>.trans (finsuppLequivDFinsupp R).symm |>.trans (Finsupp.linearEquivFunOnFinite ..)⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypicOfType.linearEquiv_fun | null |
IsIsotypic.linearEquiv_fun [Module.Finite R M] [Nontrivial M] (h : IsIsotypic R M) :
∃ (n : ℕ) (_ : NeZero n) (S : Submodule R M),
IsSimpleModule R S ∧ Nonempty (M ≃ₗ[R] Fin n → S) := by
have ⟨S, hS⟩ := IsAtomic.exists_atom (Submodule R M)
rw [← isSimpleModule_iff_isAtom] at hS
have ⟨n, e⟩ := (h S).linearEquiv_fun
exact ⟨n, neZero_iff.2 <| by rintro rfl; exact not_subsingleton _ (e.some.subsingleton), S, hS, e⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypic.linearEquiv_fun | null |
IsIsotypic.submodule_linearEquiv_fun {m : Submodule R M} [Module.Finite R m] [Nontrivial m]
(h : IsIsotypic R m) : ∃ (n : ℕ) (_ : NeZero n) (S : Submodule R M),
S ≤ m ∧ IsSimpleModule R S ∧ Nonempty (m ≃ₗ[R] Fin n → S) :=
have ⟨n, hn, S, _, ⟨e⟩⟩ := h.linearEquiv_fun
let e' := S.equivMapOfInjective _ m.subtype_injective
⟨n, hn, _, m.map_subtype_le S, .congr e'.symm, ⟨e.trans <| .piCongrRight fun _ ↦ e'⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypic.submodule_linearEquiv_fun | null |
isotypicComponent : Submodule R M := sSup {m | Nonempty (m ≃ₗ[R] S)} | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | isotypicComponent | If `S` is a simple `R`-module, the `S`-isotypic component in an `R`-module `M` is the sum of
all submodules of `M` isomorphic to `S`. |
isotypicComponents : Set (Submodule R M) :=
{ m | ∃ S : Submodule R M, IsSimpleModule R S ∧ m = isotypicComponent R M S }
variable {R M} | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | isotypicComponents | The set of all (nontrivial) isotypic components of a module. |
Submodule.le_isotypicComponent (m : Submodule R M) : m ≤ isotypicComponent R M m :=
le_sSup ⟨.refl ..⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | Submodule.le_isotypicComponent | null |
bot_lt_isotypicComponent (S : Submodule R M) [IsSimpleModule R S] :
⊥ < isotypicComponent R M S :=
(bot_lt_iff_ne_bot.mpr <| (S.nontrivial_iff_ne_bot).mp <| IsSimpleModule.nontrivial R S).trans_le
S.le_isotypicComponent | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | bot_lt_isotypicComponent | null |
bot_lt_isotypicComponents {m : Submodule R M} (h : m ∈ isotypicComponents R M) : ⊥ < m := by
obtain ⟨_, _, rfl⟩ := h; exact bot_lt_isotypicComponent .. | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | bot_lt_isotypicComponents | null |
LinearEquiv.isotypicComponent_eq (e : N ≃ₗ[R] S) :
isotypicComponent R M N = isotypicComponent R M S :=
congr_arg sSup <| Set.ext fun _ ↦ Nonempty.congr (·.trans e) (·.trans e.symm) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | LinearEquiv.isotypicComponent_eq | null |
Submodule.le_linearEquiv_of_sSup_eq_top [IsSemisimpleModule R M]
(hs : sSup s = ⊤) : ∃ m ∈ s, ∃ S ≤ m, Nonempty (N ≃ₗ[R] S) := by
have := IsSimpleModule.nontrivial R N
have ⟨_, compl⟩ := exists_isCompl N
have ⟨m, hm, ne⟩ := exists_ne_zero_of_sSup_eq_top (ne_zero_of_surjective
(N.linearProjOfIsCompl_surjective compl)) _ hs
have ⟨S, ⟨e⟩⟩ := linearEquiv_of_ne_zero ne
exact ⟨m, hm, _, m.map_subtype_le S, ⟨e.trans (S.equivMapOfInjective _ m.subtype_injective)⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | Submodule.le_linearEquiv_of_sSup_eq_top | null |
Submodule.linearEquiv_of_sSup_eq_top [h : ∀ m : s, IsSimpleModule R m]
(hs : sSup s = ⊤) : ∃ S ∈ s, Nonempty (N ≃ₗ[R] S) :=
have := isSemisimpleModule_of_isSemisimpleModule_submodule' (fun _ ↦ inferInstance)
(sSup_eq_iSup' s ▸ hs)
have ⟨m, hm, _S, le, ⟨e⟩⟩ := N.le_linearEquiv_of_sSup_eq_top _ hs
have := isSimpleModule_iff_isAtom.mp (IsSimpleModule.congr e.symm)
have := ((isSimpleModule_iff_isAtom.mp <| h ⟨m, hm⟩).le_iff_eq this.1).mp le
⟨m, hm, ⟨e.trans (.ofEq _ _ this)⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | Submodule.linearEquiv_of_sSup_eq_top | null |
Submodule.le_linearEquiv_of_le_sSup [hs : ∀ m : s, IsSemisimpleModule R m]
(hN : N ≤ sSup s) : ∃ m ∈ s, ∃ S ≤ m, Nonempty (N ≃ₗ[R] S) := by
rw [sSup_eq_iSup] at hN
have e := LinearEquiv.ofInjective _ (inclusion_injective hN)
have := IsSimpleModule.congr e.symm
have := isSemisimpleModule_biSup_of_isSemisimpleModule_submodule fun m hm ↦ hs ⟨m, hm⟩
obtain ⟨_, ⟨m, hm, rfl⟩, S, le, ⟨e'⟩⟩ := LinearMap.range (inclusion hN)
|>.le_linearEquiv_of_sSup_eq_top (comap (⨆ i ∈ s, i).subtype '' s) <| by
rw [sSup_image, biSup_comap_subtype_eq_top]
exact ⟨m, hm, _, map_le_iff_le_comap.mpr le,
⟨(e.trans e').trans (equivMapOfInjective _ (subtype_injective _) _)⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | Submodule.le_linearEquiv_of_le_sSup | If a simple module is contained in a sum of semisimple modules, it must be isomorphic
to a submodule of one of the summands. |
Submodule.linearEquiv_of_le_sSup [simple : ∀ m : s, IsSimpleModule R m]
(hs : N ≤ sSup s) : ∃ S ∈ s, Nonempty (N ≃ₗ[R] S) :=
have ⟨m, hm, _S, le, ⟨e⟩⟩ := N.le_linearEquiv_of_le_sSup _ hs
have := isSimpleModule_iff_isAtom.mp (.congr e.symm)
have := ((isSimpleModule_iff_isAtom.mp <| simple ⟨m, hm⟩).le_iff_eq this.1).mp le
⟨m, hm, ⟨e.trans (.ofEq _ _ this)⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | Submodule.linearEquiv_of_le_sSup | null |
protected IsIsotypicOfType.isotypicComponent :
IsIsotypicOfType R (isotypicComponent R M S) S :=
isIsotypicOfType_submodule_iff.mpr fun m h _ ↦
have ⟨_, ⟨e⟩, ⟨e'⟩⟩ := m.linearEquiv_of_le_sSup _ h
⟨e'.trans e⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypicOfType.isotypicComponent | null |
protected IsIsotypic.isotypicComponent : IsIsotypic R (isotypicComponent R M S) :=
(IsIsotypicOfType.isotypicComponent R M S).isIsotypic
variable {R M} in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypic.isotypicComponent | null |
protected IsIsotypic.isotypicComponents {m : Submodule R M}
(h : m ∈ isotypicComponents R M) : IsIsotypic R m := by
obtain ⟨_, _, rfl⟩ := h; exact .isotypicComponent R M _
variable {R M} in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypic.isotypicComponents | null |
eq_isotypicComponent_of_le {S c : Submodule R M} (hc : c ∈ isotypicComponents R M)
[IsSimpleModule R S] (le : S ≤ c) : c = isotypicComponent R M S := by
obtain ⟨S', _, rfl⟩ := hc
have ⟨e⟩ := isIsotypicOfType_submodule_iff.mp (.isotypicComponent R M S') _ le
exact e.symm.isotypicComponent_eq | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | eq_isotypicComponent_of_le | null |
sSupIndep_isotypicComponents : sSupIndep (isotypicComponents R M) :=
fun c hc ↦ disjoint_iff.mpr <| of_not_not fun ne ↦ by
set s := isotypicComponents R M \ {c}
have : IsSemisimpleModule R c := by obtain ⟨S, _, rfl⟩ := hc; infer_instance
have := IsSemisimpleModule.of_injective _
(Submodule.inclusion_injective (inf_le_left : c ⊓ sSup s ≤ c))
have (c : s) : IsSemisimpleModule R c := by obtain ⟨_, ⟨_, _, rfl⟩, _⟩ := c; infer_instance
have ⟨S, le, _⟩ := (IsSemisimpleModule.eq_bot_or_exists_simple_le _).resolve_left ne
have ⟨c', hc', S', le', ⟨e⟩⟩ := S.le_linearEquiv_of_le_sSup _ (le.trans inf_le_right)
have := IsSimpleModule.congr e.symm
refine hc'.2 ?_
rw [eq_isotypicComponent_of_le hc (le.trans inf_le_left), eq_isotypicComponent_of_le hc'.1 le']
exact e.symm.isotypicComponent_eq | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | sSupIndep_isotypicComponents | null |
IsIsotypicOfType.of_isotypicComponent_eq_top (h : isotypicComponent R M S = ⊤) :
IsIsotypicOfType R M S :=
fun m _ ↦ have ⟨_, ⟨e⟩, ⟨e'⟩⟩ := m.linearEquiv_of_sSup_eq_top _ h; ⟨e'.trans e⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | IsIsotypicOfType.of_isotypicComponent_eq_top | null |
Submodule.map_le_isotypicComponent (S : Submodule R M) [IsSimpleModule R S]
(f : M →ₗ[R] N) : S.map f ≤ isotypicComponent R N S := by
conv_lhs => rw [← S.range_subtype, ← LinearMap.range_comp]
obtain inj | eq := (f ∘ₗ S.subtype).injective_or_eq_zero
· exact le_sSup ⟨.symm <| .ofInjective _ inj⟩
· simp_rw [eq, LinearMap.range_zero, bot_le]
variable (S) in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | Submodule.map_le_isotypicComponent | null |
LinearMap.le_comap_isotypicComponent (f : M →ₗ[R] N) :
isotypicComponent R M S ≤ (isotypicComponent R N S).comap f :=
sSup_le fun m ⟨e⟩ ↦ Submodule.map_le_iff_le_comap.mp <|
have := IsSimpleModule.congr e
(m.map_le_isotypicComponent f).trans_eq e.isotypicComponent_eq | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | LinearMap.le_comap_isotypicComponent | null |
Submodule.IsFullyInvariant (N : Submodule R M) : Prop :=
∀ f : Module.End R M, N ≤ N.comap f | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | Submodule.IsFullyInvariant | A submodule `N` an `R`-module `M` is fully invariant if `N` is mapped into itself by all
`R`-linear endomorphisms of `M`.
If `M` is semisimple, this is equivalent to `N` being a sum of isotypic components of `M`:
see `isFullyInvariant_iff_sSup_isotypicComponents`. |
isFullyInvariant_iff_isTwoSided {I : Ideal R} : I.IsFullyInvariant ↔ I.IsTwoSided := by
simpa only [Submodule.IsFullyInvariant, ← MulOpposite.opEquiv.trans (RingEquiv.moduleEndSelf R
|>.toEquiv) |>.forall_congr_right, SetLike.le_def, I.isTwoSided_iff] using forall_comm
variable (R M) in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | isFullyInvariant_iff_isTwoSided | null |
fullyInvariantSubmodule : CompleteSublattice (Submodule R M) :=
.mk' { N : Submodule R M | N.IsFullyInvariant }
(fun _s hs f ↦ sSup_le fun _N hN ↦ (hs hN f).trans <| Submodule.comap_mono <| le_sSup hN)
fun _s hs f ↦ Submodule.map_le_iff_le_comap.mp <| le_sInf fun _N hN ↦
Submodule.map_le_iff_le_comap.mpr <| (sInf_le hN).trans (hs hN f) | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | fullyInvariantSubmodule | The fully invariant submodules of a module form a complete sublattice in the lattice of
submodules. |
mem_fullyInvariantSubmodule_iff {m : Submodule R M} :
m ∈ fullyInvariantSubmodule R M ↔ m.IsFullyInvariant := Iff.rfl | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | mem_fullyInvariantSubmodule_iff | null |
noncomputable iSupIndep.ringEquiv : Module.End R M ≃+* Π i, Module.End R (N i) where
toFun f i := f.restrict (invar i f)
invFun f := letI e := ind.linearEquiv iSup_top; e ∘ₗ DFinsupp.mapRange.linearMap f ∘ₗ e.symm
left_inv f := LinearMap.ext fun x ↦ by
exact Submodule.iSup_induction _ (motive := (_ = f ·)) (iSup_top ▸ Submodule.mem_top (x := x))
(fun i x h ↦ by simp [ind.linearEquiv_symm_apply _ h]) (by simp)
fun _ _ h₁ h₂ ↦ by simpa only [map_add] using congr($h₁ + $h₂)
right_inv f := by ext i x; simp [ind.linearEquiv_symm_apply _ x.2]
map_add' _ _ := rfl
map_mul' _ _ := rfl | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | iSupIndep.ringEquiv | If an `R`-module `M` is the direct sum of fully invariant submodules `Nᵢ`,
then `End R M` is isomorphic to `Πᵢ End R Nᵢ` as a ring. |
noncomputable iSupIndep.algEquiv [Module R₀ M] [IsScalarTower R₀ R M] :
Module.End R M ≃ₐ[R₀] Π i, Module.End R (N i) where
__ := ind.ringEquiv iSup_top invar
commutes' _ := rfl | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | iSupIndep.algEquiv | If an `R`-module `M` is the direct sum of fully invariant submodules `Nᵢ`,
then `End R M` is isomorphic to `Πᵢ End R Nᵢ` as an algebra. |
protected Submodule.IsFullyInvariant.isotypicComponent :
(isotypicComponent R M S).IsFullyInvariant :=
LinearMap.le_comap_isotypicComponent S | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | Submodule.IsFullyInvariant.isotypicComponent | null |
Submodule.IsFullyInvariant.of_mem_isotypicComponents {m : Submodule R M}
(h : m ∈ isotypicComponents R M) : m.IsFullyInvariant := by
obtain ⟨_, _, rfl⟩ := h; exact .isotypicComponent R M _
variable (R M) in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | Submodule.IsFullyInvariant.of_mem_isotypicComponents | null |
GaloisCoinsertion.setIsotypicComponents :
GaloisCoinsertion (α := Set (isotypicComponents R M)) (β := fullyInvariantSubmodule R M)
(fun s ↦ ⨆ c ∈ s, ⟨c, .of_mem_isotypicComponents c.2⟩) fun m ↦ {c | c.1 ≤ m} :=
GaloisConnection.toGaloisCoinsertion (fun _ _ ↦ iSup₂_le_iff) fun s c hc ↦ of_not_not fun hcs ↦
(bot_lt_isotypicComponents c.2).ne' <| (sSupIndep_isotypicComponents R M c.2).eq_bot_of_le <|
hc.trans <| by
simp_rw [CompleteSublattice.coe_iSup, iSup₂_le_iff]
exact fun c hc ↦ le_sSup ⟨c.2, Subtype.coe_ne_coe.mpr (ne_of_mem_of_not_mem hc hcs)⟩ | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | GaloisCoinsertion.setIsotypicComponents | The Galois coinsertion from sets of isotypic components to fully invariant submodules. |
le_isotypicComponent_iff [IsSemisimpleModule R M] {m : Submodule R M} :
m ≤ isotypicComponent R M S ↔ IsIsotypicOfType R m S where
mp h := .of_injective (.isotypicComponent R M S) _ (Submodule.inclusion_injective h)
mpr h := (IsSemisimpleModule.sSup_simples_le m).ge.trans
(sSup_le_sSup fun S ⟨_, le⟩ ↦ isIsotypicOfType_submodule_iff.mp h S le) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | le_isotypicComponent_iff | null |
isotypicComponent_eq_top_iff [IsSemisimpleModule R M] :
isotypicComponent R M S = ⊤ ↔ IsIsotypicOfType R M S := by
rw [← top_le_iff, le_isotypicComponent_iff, Submodule.topEquiv.isIsotypicOfType_iff]
open IsSemisimpleModule in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | isotypicComponent_eq_top_iff | null |
isFullyInvariant_iff_le_imp_isotypicComponent_le [IsSemisimpleModule R M]
{m : Submodule R M} :
m.IsFullyInvariant ↔ ∀ S ≤ m, [IsSimpleModule R S] → isotypicComponent R M S ≤ m where
mp h S le _ := sSup_le fun S' ⟨e⟩ ↦ by
have ⟨p, eq⟩ := extension_property _ S.subtype_injective (S'.subtype ∘ₗ e.symm)
refine le_trans ?_ (Submodule.map_le_iff_le_comap.mpr (le.trans (h p)))
rw [← S.range_subtype, ← LinearMap.range_comp, eq, e.symm.range_comp, S'.range_subtype]
mpr h f := (sSup_simples_le m).ge.trans <| sSup_le fun S ⟨_, le⟩ ↦
Submodule.map_le_iff_le_comap.mp ((S.map_le_isotypicComponent f).trans (h S le)) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | isFullyInvariant_iff_le_imp_isotypicComponent_le | null |
eq_isotypicComponent_iff [IsSemisimpleModule R M] {m : Submodule R M} (ne : m ≠ ⊥) :
m = isotypicComponent R M S ↔ IsIsotypicOfType R m S ∧ m.IsFullyInvariant where
mp := by rintro rfl; exact ⟨.isotypicComponent R M S, .isotypicComponent R M S⟩
mpr := fun ⟨iso, invar⟩ ↦ (le_isotypicComponent_iff.mpr iso).antisymm <|
have ⟨S', le, _⟩ := (IsSemisimpleModule.eq_bot_or_exists_simple_le m).resolve_left ne
(isIsotypicOfType_submodule_iff.mp iso S' le).some.symm.isotypicComponent_eq.trans_le
(isFullyInvariant_iff_le_imp_isotypicComponent_le.mp invar _ le) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | eq_isotypicComponent_iff | null |
isIsotypic_iff_isFullyInvariant_imp_bot_or_top :
IsIsotypic R M ↔ ∀ N : Submodule R M, N.IsFullyInvariant → N = ⊥ ∨ N = ⊤ where
mp h N hN := (eq_bot_or_exists_simple_le N).imp_right fun ⟨S, le, _⟩ ↦ top_unique <|
(isotypicComponent_eq_top_iff.mpr (h S)).ge.trans
((isFullyInvariant_iff_le_imp_isotypicComponent_le.mp hN) _ le)
mpr h S _ := isotypicComponent_eq_top_iff.mp <|
(h _ (.isotypicComponent R M S)).resolve_left (bot_lt_isotypicComponent S).ne' | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | isIsotypic_iff_isFullyInvariant_imp_bot_or_top | null |
mem_isotypicComponents_iff {m : Submodule R M} :
m ∈ isotypicComponents R M ↔ IsIsotypic R m ∧ m.IsFullyInvariant ∧ m ≠ ⊥ where
mp := by rintro ⟨S, _, rfl⟩; exact ⟨.isotypicComponent R M S,
.isotypicComponent R M S, (bot_lt_isotypicComponent S).ne'⟩
mpr := fun ⟨iso, invar, ne⟩ ↦
have ⟨S, le, simple⟩ := (eq_bot_or_exists_simple_le m).resolve_left ne
⟨S, simple, (eq_isotypicComponent_iff ne).mpr ⟨isIsotypic_submodule_iff.mp iso S le, invar⟩⟩ | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | mem_isotypicComponents_iff | null |
@[simps] OrderIso.setIsotypicComponents :
Set (isotypicComponents R M) ≃o fullyInvariantSubmodule R M where
toFun s := ⨆ c ∈ s, ⟨c, .of_mem_isotypicComponents c.2⟩
invFun m := { c | c.1 ≤ m }
left_inv := (GaloisCoinsertion.setIsotypicComponents R M).u_l_eq
right_inv m := (iSup₂_le fun _ ↦ by exact id).antisymm <| (sSup_simples_le m.1).ge.trans <|
sSup_le fun S ⟨simple, le⟩ ↦ S.le_isotypicComponent.trans <| by
let c : isotypicComponents R M := ⟨_, S, simple, rfl⟩
simp_rw [← show c.1 = isotypicComponent R M S from rfl, CompleteSublattice.coe_iSup]
exact le_biSup _ (isFullyInvariant_iff_le_imp_isotypicComponent_le.mp m.2 _ le)
map_rel_iff' := (GaloisCoinsertion.setIsotypicComponents R M).l_le_l_iff | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | OrderIso.setIsotypicComponents | Sets of isotypic components in a semisimple module are in order-preserving 1-1
correspondence with fully invariant submodules. Consequently, the fully invariant submodules
form a complete atomic Boolean algebra. |
isFullyInvariant_iff_sSup_isotypicComponents {m : Submodule R M} :
m.IsFullyInvariant ↔ ∃ s ⊆ isotypicComponents R M, m = sSup s := by
refine ⟨fun h ↦ ⟨OrderIso.setIsotypicComponents.symm ⟨m, h⟩, ⟨?_, ?_⟩⟩, ?_⟩
· rintro _ ⟨c, _, rfl⟩; exact c.2
· convert Subtype.ext_iff.mp (OrderIso.setIsotypicComponents.right_inv ⟨m, h⟩).symm
simp [sSup_image, OrderIso.setIsotypicComponents, OrderIso.symm]
· rintro ⟨_, hs, rfl⟩
exact (fullyInvariantSubmodule R M).sSupClosed fun _ h ↦ .of_mem_isotypicComponents (hs h)
variable (R M) in | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | isFullyInvariant_iff_sSup_isotypicComponents | null |
sSup_isotypicComponents : sSup (isotypicComponents R M) = ⊤ :=
have ⟨_, h, eq⟩ := isFullyInvariant_iff_sSup_isotypicComponents.mp
(fullyInvariantSubmodule R M).top_mem
top_unique <| eq.le.trans (sSup_le_sSup h) | theorem | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | sSup_isotypicComponents | null |
noncomputable endAlgEquiv :
Module.End R M ≃ₐ[R₀] Π c : isotypicComponents R M, Module.End R c.1 :=
((sSupIndep_iff _).mp <| sSupIndep_isotypicComponents R M).algEquiv R₀
((sSup_eq_iSup' _).symm.trans <| sSup_isotypicComponents R M) (.of_mem_isotypicComponents ·.2) | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | endAlgEquiv | The endomorphism algebra of a semisimple module is the direct product of the endomorphism
algebras of its isotypic components. |
noncomputable endRingEquiv :
Module.End R M ≃+* Π c : isotypicComponents R M, Module.End R c.1 :=
(endAlgEquiv ℕ R M).toRingEquiv | def | RingTheory | [
"Mathlib.Algebra.Algebra.Pi",
"Mathlib.Order.CompleteSublattice",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Isotypic.lean | endRingEquiv | The endomorphism ring of a semisimple module is the direct product of the endomorphism rings
of its isotypic components. |
isSimpleModule_iff_finrank_eq_one {R M} [DivisionRing R] [AddCommGroup M] [Module R M] :
IsSimpleModule R M ↔ Module.finrank R M = 1 :=
⟨fun h ↦ have := h.nontrivial; have ⟨v, hv⟩ := exists_ne (0 : M)
(finrank_eq_one_iff_of_nonzero' v hv).mpr (IsSimpleModule.toSpanSingleton_surjective R hv),
(isSimpleModule_iff ..).mpr ∘ is_simple_module_of_finrank_eq_one⟩ | theorem | RingTheory | [
"Mathlib.LinearAlgebra.FiniteDimensional.Lemmas",
"Mathlib.RingTheory.SimpleModule.Basic"
] | Mathlib/RingTheory/SimpleModule/Rank.lean | isSimpleModule_iff_finrank_eq_one | null |
IsSimpleRing.tfae [IsSimpleRing R] : List.TFAE
[IsSemisimpleRing R, IsArtinianRing R, ∃ I : Ideal R, IsAtom I] := by
tfae_have 1 → 2 := fun _ ↦ inferInstance
tfae_have 2 → 3 := fun _ ↦ IsAtomic.exists_atom _
tfae_have 3 → 1 := fun ⟨I, hI⟩ ↦ by
have ⟨_, h⟩ := isSimpleRing_iff_isTwoSided_imp.mp ‹IsSimpleRing R›
simp_rw [← isFullyInvariant_iff_isTwoSided] at h
have := isSimpleModule_iff_isAtom.mpr hI
obtain eq | eq := h _ (.isotypicComponent R R I)
· exact (hI.bot_lt.not_ge <| (le_sSup <| by exact ⟨.refl ..⟩).trans_eq eq).elim
exact .congr (.symm <| .trans (.ofEq _ _ eq) Submodule.topEquiv)
tfae_finish | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | IsSimpleRing.tfae | A simple ring is semisimple iff it is Artinian, iff it has a minimal left ideal. |
IsSimpleRing.isSemisimpleRing_iff_isArtinianRing [IsSimpleRing R] :
IsSemisimpleRing R ↔ IsArtinianRing R := tfae.out 0 1 | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | IsSimpleRing.isSemisimpleRing_iff_isArtinianRing | null |
isSimpleRing_isArtinianRing_iff :
IsSimpleRing R ∧ IsArtinianRing R ↔ IsSemisimpleRing R ∧ IsIsotypic R R ∧ Nontrivial R := by
refine ⟨fun ⟨_, _⟩ ↦ ?_, fun ⟨_, _, _⟩ ↦ ?_⟩
on_goal 1 => have := IsSimpleRing.isSemisimpleRing_iff_isArtinianRing.mpr ‹_›
all_goals simp_rw [isIsotypic_iff_isFullyInvariant_imp_bot_or_top,
isFullyInvariant_iff_isTwoSided, isSimpleRing_iff_isTwoSided_imp] at *
· exact ⟨this, by rwa [and_comm]⟩
· exact ⟨⟨‹_›, ‹_›⟩, inferInstance⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | isSimpleRing_isArtinianRing_iff | null |
isIsotypic : IsIsotypic R R :=
(isSimpleRing_isArtinianRing_iff.mp ⟨‹_›, ‹_›⟩).2.1 | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | isIsotypic | null |
exists_ringEquiv_matrix_end_mulOpposite :
∃ (n : ℕ) (_ : NeZero n) (I : Ideal R) (_ : IsSimpleModule R I),
Nonempty (R ≃+* Matrix (Fin n) (Fin n) (Module.End R I)ᵐᵒᵖ) := by
have ⟨n, hn, S, hS, ⟨e⟩⟩ := (isIsotypic R).linearEquiv_fun
refine ⟨n, hn, S, hS, ⟨.trans (.opOp R) <| .trans (.op ?_) (.symm .mopMatrix)⟩⟩
exact .trans (.moduleEndSelf R) <| .trans e.conjRingEquiv (endVecRingEquivMatrixEnd ..) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_ringEquiv_matrix_end_mulOpposite | The **Wedderburn–Artin Theorem**: an Artinian simple ring is isomorphic to a matrix
ring over the opposite of the endomorphism ring of its simple module. |
exists_ringEquiv_matrix_divisionRing :
∃ (n : ℕ) (_ : NeZero n) (D : Type u) (_ : DivisionRing D),
Nonempty (R ≃+* Matrix (Fin n) (Fin n) D) := by
have ⟨n, hn, I, _, ⟨e⟩⟩ := exists_ringEquiv_matrix_end_mulOpposite R
classical exact ⟨n, hn, _, _, ⟨e⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_ringEquiv_matrix_divisionRing | The **Wedderburn–Artin Theorem**: an Artinian simple ring is isomorphic to a matrix
ring over a division ring. |
exists_algEquiv_matrix_end_mulOpposite :
∃ (n : ℕ) (_ : NeZero n) (I : Ideal R) (_ : IsSimpleModule R I),
Nonempty (R ≃ₐ[R₀] Matrix (Fin n) (Fin n) (Module.End R I)ᵐᵒᵖ) := by
have ⟨n, hn, S, hS, ⟨e⟩⟩ := (isIsotypic R).linearEquiv_fun
refine ⟨n, hn, S, hS, ⟨.trans (.opOp R₀ R) <| .trans (.op ?_) (.symm .mopMatrix)⟩⟩
exact .trans (.moduleEndSelf R₀) <| .trans (e.algConj R₀) (endVecAlgEquivMatrixEnd ..) | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_algEquiv_matrix_end_mulOpposite | The **Wedderburn–Artin Theorem**, algebra form: an Artinian simple algebra is isomorphic
to a matrix algebra over the opposite of the endomorphism algebra of its simple module. |
exists_algEquiv_matrix_divisionRing :
∃ (n : ℕ) (_ : NeZero n) (D : Type u) (_ : DivisionRing D) (_ : Algebra R₀ D),
Nonempty (R ≃ₐ[R₀] Matrix (Fin n) (Fin n) D) := by
have ⟨n, hn, I, _, ⟨e⟩⟩ := exists_algEquiv_matrix_end_mulOpposite R₀ R
classical exact ⟨n, hn, _, _, _, ⟨e⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_algEquiv_matrix_divisionRing | The **Wedderburn–Artin Theorem**, algebra form: an Artinian simple algebra is isomorphic
to a matrix algebra over a division algebra. |
exists_algEquiv_matrix_divisionRing_finite [Module.Finite R₀ R] :
∃ (n : ℕ) (_ : NeZero n) (D : Type u) (_ : DivisionRing D) (_ : Algebra R₀ D)
(_ : Module.Finite R₀ D), Nonempty (R ≃ₐ[R₀] Matrix (Fin n) (Fin n) D) := by
have ⟨n, hn, I, _, ⟨e⟩⟩ := exists_algEquiv_matrix_end_mulOpposite R₀ R
have := Module.Finite.equiv e.toLinearEquiv
classical exact ⟨n, hn, _, _, _, .of_surjective
(Matrix.entryLinearMap R₀ _ (0 : Fin n) (0 : Fin n)) fun f ↦ ⟨fun _ _ ↦ f, rfl⟩, ⟨e⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_algEquiv_matrix_divisionRing_finite | The **Wedderburn–Artin Theorem**, algebra form, finite case: a finite Artinian simple algebra is
isomorphic to a matrix algebra over a finite division algebra. |
exists_end_algEquiv :
∃ (n : ℕ) (S : Fin n → Submodule R M) (d : Fin n → ℕ),
(∀ i, IsSimpleModule R (S i)) ∧ (∀ i, NeZero (d i)) ∧
Nonempty (End R M ≃ₐ[R₀] Π i, Matrix (Fin (d i)) (Fin (d i)) (End R (S i))) := by
choose d pos S _ simple e using fun c : isotypicComponents R M ↦
(IsIsotypic.isotypicComponents c.2).submodule_linearEquiv_fun
classical exact ⟨_, _, _, fun _ ↦ simple _, fun _ ↦ pos _, ⟨.trans (endAlgEquiv R₀ R M) <| .trans
(.piCongrRight fun c ↦ ((e c).some.algConj R₀).trans (endVecAlgEquivMatrixEnd ..)) <|
(.piCongrLeft' R₀ _ (Finite.equivFin _))⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_end_algEquiv | null |
exists_end_ringEquiv :
∃ (n : ℕ) (S : Fin n → Submodule R M) (d : Fin n → ℕ),
(∀ i, IsSimpleModule R (S i)) ∧ (∀ i, NeZero (d i)) ∧
Nonempty (End R M ≃+* Π i, Matrix (Fin (d i)) (Fin (d i)) (End R (S i))) :=
have ⟨n, S, d, hS, hd, ⟨e⟩⟩ := exists_end_algEquiv ℕ R M; ⟨n, S, d, hS, hd, ⟨e⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_end_ringEquiv | null |
exists_algEquiv_pi_matrix_end_mulOpposite :
∃ (n : ℕ) (S : Fin n → Ideal R) (d : Fin n → ℕ),
(∀ i, IsSimpleModule R (S i)) ∧ (∀ i, NeZero (d i)) ∧
Nonempty (R ≃ₐ[R₀] Π i, Matrix (Fin (d i)) (Fin (d i)) (Module.End R (S i))ᵐᵒᵖ) :=
have ⟨n, S, d, hS, hd, ⟨e⟩⟩ := IsSemisimpleModule.exists_end_algEquiv R₀ R R
⟨n, S, d, hS, hd, ⟨.trans (.opOp R₀ R) <| .trans (.op <| .trans (.moduleEndSelf R₀) e) <|
.trans (.piMulOpposite _ _) (.piCongrRight fun _ ↦ .symm .mopMatrix)⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_algEquiv_pi_matrix_end_mulOpposite | The **Wedderburn–Artin Theorem**, algebra form: a semisimple algebra is isomorphic to a
product of matrix algebras over the opposite of the endomorphism algebras of its simple modules. |
exists_algEquiv_pi_matrix_divisionRing :
∃ (n : ℕ) (D : Fin n → Type u) (d : Fin n → ℕ) (_ : ∀ i, DivisionRing (D i))
(_ : ∀ i, Algebra R₀ (D i)), (∀ i, NeZero (d i)) ∧
Nonempty (R ≃ₐ[R₀] Π i, Matrix (Fin (d i)) (Fin (d i)) (D i)) := by
have ⟨n, S, d, _, hd, ⟨e⟩⟩ := exists_algEquiv_pi_matrix_end_mulOpposite R₀ R
classical exact ⟨n, _, d, inferInstance, inferInstance, hd, ⟨e⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_algEquiv_pi_matrix_divisionRing | The **Wedderburn–Artin Theorem**, algebra form: a semisimple algebra is isomorphic to a
product of matrix algebras over division algebras. |
exists_algEquiv_pi_matrix_divisionRing_finite [Module.Finite R₀ R] :
∃ (n : ℕ) (D : Fin n → Type u) (d : Fin n → ℕ) (_ : ∀ i, DivisionRing (D i))
(_ : ∀ i, Algebra R₀ (D i)) (_ : ∀ i, Module.Finite R₀ (D i)), (∀ i, NeZero (d i)) ∧
Nonempty (R ≃ₐ[R₀] Π i, Matrix (Fin (d i)) (Fin (d i)) (D i)) := by
have ⟨n, D, d, _, _, hd, ⟨e⟩⟩ := exists_algEquiv_pi_matrix_divisionRing R₀ R
have := Module.Finite.equiv e.toLinearEquiv
refine ⟨n, D, d, _, _, fun i ↦ ?_, hd, ⟨e⟩⟩
let l := Matrix.entryLinearMap R₀ (D i) 0 0 ∘ₗ
.proj (φ := fun i ↦ Matrix (Fin (d i)) (Fin (d i)) _) i
exact .of_surjective l fun x ↦ ⟨fun j _ _ ↦ Function.update (fun _ ↦ 0) i x j, by simp [l]⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_algEquiv_pi_matrix_divisionRing_finite | The **Wedderburn–Artin Theorem**, algebra form, finite case: a finite semisimple algebra is
isomorphic to a product of matrix algebras over finite division algebras. |
exists_ringEquiv_pi_matrix_end_mulOpposite :
∃ (n : ℕ) (D : Fin n → Ideal R) (d : Fin n → ℕ),
(∀ i, IsSimpleModule R (D i)) ∧ (∀ i, NeZero (d i)) ∧
Nonempty (R ≃+* Π i, Matrix (Fin (d i)) (Fin (d i)) (Module.End R (D i))ᵐᵒᵖ) :=
have ⟨n, S, d, hS, hd, ⟨e⟩⟩ := exists_algEquiv_pi_matrix_end_mulOpposite ℕ R
⟨n, S, d, hS, hd, ⟨e⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_ringEquiv_pi_matrix_end_mulOpposite | The **Wedderburn–Artin Theorem**: a semisimple ring is isomorphic to a
product of matrix rings over the opposite of the endomorphism rings of its simple modules. |
exists_ringEquiv_pi_matrix_divisionRing :
∃ (n : ℕ) (D : Fin n → Type u) (d : Fin n → ℕ) (_ : ∀ i, DivisionRing (D i)),
(∀ i, NeZero (d i)) ∧ Nonempty (R ≃+* Π i, Matrix (Fin (d i)) (Fin (d i)) (D i)) :=
have ⟨n, D, d, _, _, hd, ⟨e⟩⟩ := exists_algEquiv_pi_matrix_divisionRing ℕ R
⟨n, D, d, _, hd, ⟨e⟩⟩ | theorem | RingTheory | [
"Mathlib.RingTheory.FiniteLength",
"Mathlib.RingTheory.SimpleModule.Isotypic",
"Mathlib.RingTheory.SimpleRing.Congr"
] | Mathlib/RingTheory/SimpleModule/WedderburnArtin.lean | exists_ringEquiv_pi_matrix_divisionRing | The **Wedderburn–Artin Theorem**: a semisimple ring is isomorphic to a
product of matrix rings over division rings. |
one_mem_of_ne_bot {A : Type*} [NonAssocRing A] [IsSimpleRing A] (I : TwoSidedIdeal A)
(hI : I ≠ ⊥) : (1 : A) ∈ I :=
(eq_bot_or_eq_top I).resolve_left hI ▸ ⟨⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Defs",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.RingTheory.TwoSidedIdeal.Kernel"
] | Mathlib/RingTheory/SimpleRing/Basic.lean | one_mem_of_ne_bot | null |
one_mem_of_ne_zero_mem {A : Type*} [NonAssocRing A] [IsSimpleRing A] (I : TwoSidedIdeal A)
{x : A} (hx : x ≠ 0) (hxI : x ∈ I) : (1 : A) ∈ I :=
one_mem_of_ne_bot I (by rintro rfl; exact hx hxI) | lemma | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Defs",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.RingTheory.TwoSidedIdeal.Kernel"
] | Mathlib/RingTheory/SimpleRing/Basic.lean | one_mem_of_ne_zero_mem | null |
of_eq_bot_or_eq_top [Nontrivial R] (h : ∀ I : TwoSidedIdeal R, I = ⊥ ∨ I = ⊤) :
IsSimpleRing R where
simple.eq_bot_or_eq_top := h | lemma | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Defs",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.RingTheory.TwoSidedIdeal.Kernel"
] | Mathlib/RingTheory/SimpleRing/Basic.lean | of_eq_bot_or_eq_top | null |
_root_.DivisionRing.isSimpleRing (A : Type*) [DivisionRing A] : IsSimpleRing A :=
.of_eq_bot_or_eq_top <| fun I ↦ by
rw [or_iff_not_imp_left, ← I.one_mem_iff]
intro H
obtain ⟨x, hx1, hx2 : x ≠ 0⟩ := SetLike.exists_of_lt (bot_lt_iff_ne_bot.mpr H : ⊥ < I)
simpa [inv_mul_cancel₀ hx2] using I.mul_mem_left x⁻¹ _ hx1 | instance | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Defs",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.RingTheory.TwoSidedIdeal.Kernel"
] | Mathlib/RingTheory/SimpleRing/Basic.lean | _root_.DivisionRing.isSimpleRing | null |
injective_ringHom_or_subsingleton_codomain
{R S : Type*} [NonAssocRing R] [IsSimpleRing R] [NonAssocSemiring S]
(f : R →+* S) : Function.Injective f ∨ Subsingleton S :=
simple.eq_bot_or_eq_top (TwoSidedIdeal.ker f) |>.imp (TwoSidedIdeal.ker_eq_bot _ |>.1)
(fun h => subsingleton_iff_zero_eq_one.1 <| by
have mem : 1 ∈ TwoSidedIdeal.ker f := h.symm ▸ TwoSidedIdeal.mem_top _
rwa [TwoSidedIdeal.mem_ker, map_one, eq_comm] at mem) | lemma | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Defs",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.RingTheory.TwoSidedIdeal.Kernel"
] | Mathlib/RingTheory/SimpleRing/Basic.lean | injective_ringHom_or_subsingleton_codomain | null |
protected _root_.RingHom.injective
{R S : Type*} [NonAssocRing R] [IsSimpleRing R] [NonAssocSemiring S] [Nontrivial S]
(f : R →+* S) : Function.Injective f :=
injective_ringHom_or_subsingleton_codomain f |>.resolve_right fun r => not_subsingleton _ r
universe u in | theorem | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Defs",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.RingTheory.TwoSidedIdeal.Kernel"
] | Mathlib/RingTheory/SimpleRing/Basic.lean | _root_.RingHom.injective | null |
iff_injective_ringHom_or_subsingleton_codomain (R : Type u) [NonAssocRing R] [Nontrivial R] :
IsSimpleRing R ↔
∀ {S : Type u} [NonAssocSemiring S] (f : R →+* S), Function.Injective f ∨ Subsingleton S where
mp _ _ _ := injective_ringHom_or_subsingleton_codomain
mpr H := of_eq_bot_or_eq_top fun I => H I.ringCon.mk' |>.imp
(fun h => le_antisymm
(fun _ hx => TwoSidedIdeal.ker_eq_bot _ |>.2 h ▸ I.ker_ringCon_mk'.symm ▸ hx) bot_le)
(fun h => le_antisymm le_top fun x _ => I.mem_iff _ |>.2 (Quotient.eq'.1 (h.elim x 0)))
universe u in | lemma | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Defs",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.RingTheory.TwoSidedIdeal.Kernel"
] | Mathlib/RingTheory/SimpleRing/Basic.lean | iff_injective_ringHom_or_subsingleton_codomain | null |
iff_injective_ringHom (R : Type u) [NonAssocRing R] [Nontrivial R] :
IsSimpleRing R ↔
∀ {S : Type u} [NonAssocSemiring S] [Nontrivial S] (f : R →+* S), Function.Injective f :=
iff_injective_ringHom_or_subsingleton_codomain R |>.trans <|
⟨fun H _ _ _ f => H f |>.resolve_right (by simpa [not_subsingleton_iff_nontrivial]),
fun H S _ f => subsingleton_or_nontrivial S |>.recOn Or.inr fun _ => Or.inl <| H f⟩ | lemma | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Defs",
"Mathlib.Algebra.Ring.Opposite",
"Mathlib.RingTheory.TwoSidedIdeal.Kernel"
] | Mathlib/RingTheory/SimpleRing/Basic.lean | iff_injective_ringHom | null |
of_surjective {R S : Type*} [NonAssocRing R] [NonAssocRing S] [Nontrivial S]
(f : R →+* S) (h : IsSimpleRing R) (hf : Function.Surjective f) : IsSimpleRing S where
simple := OrderIso.isSimpleOrder (RingEquiv.ofBijective f
⟨RingHom.injective f, hf⟩).symm.mapTwoSidedIdeal | lemma | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Basic",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/SimpleRing/Congr.lean | of_surjective | null |
of_ringEquiv {R S : Type*} [NonUnitalNonAssocRing R] [NonUnitalNonAssocRing S]
(f : R ≃+* S) (h : IsSimpleRing R) : IsSimpleRing S where
simple := OrderIso.isSimpleOrder f.symm.mapTwoSidedIdeal | lemma | RingTheory | [
"Mathlib.RingTheory.SimpleRing.Basic",
"Mathlib.RingTheory.TwoSidedIdeal.Operations"
] | Mathlib/RingTheory/SimpleRing/Congr.lean | of_ringEquiv | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.