File: Mathlib/Algebra/Lie/Quotient.lean

full_name: LieSubmodule.instHasQuotient
code: /-- The quotient of a Lie module by a Lie submodule. It is a Lie module. -/
instance : HasQuotient M (LieSubmodule R L M) 
goal: HasQuotient M (LieSubmodule R L M)

full_name: LieSubmodule.Quotient.addCommGroup
code: instance addCommGroup : AddCommGroup (M ⧸ N) 
goal: AddCommGroup (M ⧸ N)

full_name: LieSubmodule.Quotient.module'
code: instance module' {S : Type*} [Semiring S] [SMul S R] [Module S M] [IsScalarTower S R M] :
    Module S (M ⧸ N) 
goal: Module S (M ⧸ N)

full_name: LieSubmodule.Quotient.module
code: instance module : Module R (M ⧸ N) 
goal: Module R (M ⧸ N)

full_name: LieSubmodule.Quotient.isCentralScalar
code: instance isCentralScalar {S : Type*} [Semiring S] [SMul S R] [Module S M] [IsScalarTower S R M]
    [SMul Sᵐᵒᵖ R] [Module Sᵐᵒᵖ M] [IsScalarTower Sᵐᵒᵖ R M] [IsCentralScalar S M] :
    IsCentralScalar S (M ⧸ N) 
goal: IsCentralScalar S (M ⧸ N)

full_name: LieSubmodule.Quotient.inhabited
code: instance inhabited : Inhabited (M ⧸ N) 
goal: Inhabited (M ⧸ N)

full_name: LieSubmodule.Quotient.mk
code: /-- Map sending an element of `M` to the corresponding element of `M/N`, when `N` is a
lie_submodule of the lie_module `N`. -/
abbrev mk : M → M ⧸ N 
goal: M → M ⧸ N

full_name: LieSubmodule.Quotient.is_quotient_mk
code: theorem is_quotient_mk (m : M) : Quotient.mk'' m = (mk m : M ⧸ N) 
goal: Quotient.mk'' m = LieSubmodule.Quotient.mk m

full_name: LieSubmodule.Quotient.lieSubmoduleInvariant
code: /-- Given a Lie module `M` over a Lie algebra `L`, together with a Lie submodule `N ⊆ M`, there
is a natural linear map from `L` to the endomorphisms of `M` leaving `N` invariant. -/
def lieSubmoduleInvariant : L →ₗ[R] Submodule.compatibleMaps N.toSubmodule N.toSubmodule 
goal: L →ₗ[R] ↥((↑N).compatibleMaps ↑N)

full_name: LieSubmodule.Quotient.actionAsEndoMap
code: /-- Given a Lie module `M` over a Lie algebra `L`, together with a Lie submodule `N ⊆ M`, there
is a natural Lie algebra morphism from `L` to the linear endomorphism of the quotient `M/N`. -/
def actionAsEndoMap : L →ₗ⁅R⁆ Module.End R (M ⧸ N) 
goal: L →ₗ⁅R⁆ Module.End R (M ⧸ N)

full_name: LieSubmodule.Quotient.actionAsEndoMapBracket
code: /-- Given a Lie module `M` over a Lie algebra `L`, together with a Lie submodule `N ⊆ M`, there is
a natural bracket action of `L` on the quotient `M/N`. -/
instance actionAsEndoMapBracket : Bracket L (M ⧸ N) 
goal: Bracket L (M ⧸ N)

full_name: LieSubmodule.Quotient.lieQuotientLieRingModule
code: instance lieQuotientLieRingModule : LieRingModule L (M ⧸ N) 
goal: LieRingModule L (M ⧸ N)

full_name: LieSubmodule.Quotient.lieQuotientLieModule
code: /-- The quotient of a Lie module by a Lie submodule, is a Lie module. -/
instance lieQuotientLieModule : LieModule R L (M ⧸ N) 
goal: LieModule R L (M ⧸ N)

full_name: LieSubmodule.Quotient.lieQuotientHasBracket
code: instance lieQuotientHasBracket : Bracket (L ⧸ I) (L ⧸ I) 
goal: Bracket (L ⧸ I) (L ⧸ I)

full_name: LieSubmodule.Quotient.mk_bracket
code: @[simp]
theorem mk_bracket (x y : L) : mk ⁅x, y⁆ = ⁅(mk x : L ⧸ I), (mk y : L ⧸ I)⁆ 
goal: LieSubmodule.Quotient.mk ⁅x, y⁆ = ⁅LieSubmodule.Quotient.mk x, LieSubmodule.Quotient.mk y⁆

full_name: LieSubmodule.Quotient.lieQuotientLieRing
code: instance lieQuotientLieRing : LieRing (L ⧸ I) 
goal: LieRing (L ⧸ I)

full_name: LieSubmodule.Quotient.lieQuotientLieAlgebra
code: instance lieQuotientLieAlgebra : LieAlgebra R (L ⧸ I) 
goal: LieAlgebra R (L ⧸ I)

full_name: LieSubmodule.Quotient.mk'
code: /-- `LieSubmodule.Quotient.mk` as a `LieModuleHom`. -/
@[simps]
def mk' : M →ₗ⁅R,L⁆ M ⧸ N 
goal: M →ₗ⁅R,L⁆ M ⧸ N

full_name: LieSubmodule.Quotient.mk'_apply
code: /-- `LieSubmodule.Quotient.mk` as a `LieModuleHom`. -/
@[simps]
def mk' : M →ₗ⁅R,L⁆ M ⧸ N 
goal: ∀ (a : M), (LieSubmodule.Quotient.mk' N) a = LieSubmodule.Quotient.mk a

full_name: LieSubmodule.Quotient.surjective_mk'
code: @[simp]
theorem surjective_mk' : Function.Surjective (mk' N) 
goal: Function.Surjective ⇑(LieSubmodule.Quotient.mk' N)

full_name: LieSubmodule.Quotient.range_mk'
code: @[simp]
theorem range_mk' : LieModuleHom.range (mk' N) = ⊤ 
goal: (LieSubmodule.Quotient.mk' N).range = ⊤

full_name: LieSubmodule.Quotient.isNoetherian
code: instance isNoetherian [IsNoetherian R M] : IsNoetherian R (M ⧸ N) 
goal: IsNoetherian R (M ⧸ N)

full_name: LieSubmodule.Quotient.mk_eq_zero
code: theorem mk_eq_zero {m : M} : mk' N m = 0 ↔ m ∈ N 
goal: (LieSubmodule.Quotient.mk' N) m = 0 ↔ m ∈ N

full_name: LieSubmodule.Quotient.mk_eq_zero'
code: @[simp]
theorem mk_eq_zero' {m : M} : mk (N := N) m = 0 ↔ m ∈ N 
goal: LieSubmodule.Quotient.mk m = 0 ↔ m ∈ N

full_name: LieSubmodule.Quotient.mk'_ker
code: @[simp]
theorem mk'_ker : (mk' N).ker = N 
goal: (LieSubmodule.Quotient.mk' N).ker = N

full_name: LieSubmodule.Quotient.map_mk'_eq_bot_le
code: @[simp]
theorem map_mk'_eq_bot_le : map (mk' N) N' = ⊥ ↔ N' ≤ N 
goal: LieSubmodule.map (LieSubmodule.Quotient.mk' N) N' = ⊥ ↔ N' ≤ N

full_name: LieSubmodule.Quotient.lieModuleHom_ext
code: /-- Two `LieModuleHom`s from a quotient lie module are equal if their compositions with
`LieSubmodule.Quotient.mk'` are equal.

See note [partially-applied ext lemmas]. -/
@[ext]
theorem lieModuleHom_ext ⦃f g : M ⧸ N →ₗ⁅R,L⁆ M⦄ (h : f.comp (mk' N) = g.comp (mk' N)) : f = g 
goal: f = g

full_name: LieSubmodule.Quotient.toEnd_comp_mk'
code: lemma toEnd_comp_mk' (x : L) :
    LieModule.toEnd R L (M ⧸ N) x ∘ₗ mk' N = mk' N ∘ₗ LieModule.toEnd R L M x 
goal: (LieModule.toEnd R L (M ⧸ N)) x ∘ₗ ↑(LieSubmodule.Quotient.mk' N) =
  ↑(LieSubmodule.Quotient.mk' N) ∘ₗ (LieModule.toEnd R L M) x

full_name: LieHom.quotKerEquivRange_toFun
code: /-- The first isomorphism theorem for morphisms of Lie algebras. -/
@[simps]
noncomputable def quotKerEquivRange : (L ⧸ f.ker) ≃ₗ⁅R⁆ f.range 
goal: f.quotKerEquivRange a = (↑f).quotKerEquivRange a

full_name: LieHom.quotKerEquivRange_invFun
code: /-- The first isomorphism theorem for morphisms of Lie algebras. -/
@[simps]
noncomputable def quotKerEquivRange : (L ⧸ f.ker) ≃ₗ⁅R⁆ f.range 
goal: ∀ (a : ↥(LinearMap.range ↑f)), f.quotKerEquivRange.invFun a = (↑f).quotKerEquivRange.invFun a

full_name: LieHom.quotKerEquivRange
code: /-- The first isomorphism theorem for morphisms of Lie algebras. -/
@[simps]
noncomputable def quotKerEquivRange : (L ⧸ f.ker) ≃ₗ⁅R⁆ f.range 
goal: (L ⧸ f.ker) ≃ₗ⁅R⁆ ↥f.range