Documentation

Mathlib.Algebra.Lie.Submodule

Lie submodules of a Lie algebra #

In this file we define Lie submodules and Lie ideals, we construct the lattice structure on Lie submodules and we use it to define various important operations, notably the Lie span of a subset of a Lie module.

Main definitions #

Tags #

lie algebra, lie submodule, lie ideal, lattice structure

structure LieSubmodule (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] extends Submodule :
  • carrier : Set M
  • add_mem' : ∀ {a b : M}, a s.carrierb s.carriera + b s.carrier
  • zero_mem' : 0 s.carrier
  • smul_mem' : ∀ (c : R) {x : M}, x s.carrierc x s.carrier
  • lie_mem : ∀ {x : L} {m : M}, m s.carrierx, m s.carrier

A Lie submodule of a Lie module is a submodule that is closed under the Lie bracket. This is a sufficient condition for the subset itself to form a Lie module.

Instances For
    instance LieSubmodule.instZeroLieSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :

    The zero module is a Lie submodule of any Lie module.

    instance LieSubmodule.coeSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
    theorem LieSubmodule.coe_toSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) :
    N = N
    @[simp]
    theorem LieSubmodule.mem_carrier {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) {x : M} :
    x N.carrier x N
    theorem LieSubmodule.mem_mk_iff {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (S : Set M) (h₁ : ∀ {a b : M}, a Sb Sa + b S) (h₂ : S 0) (h₃ : ∀ (c : R) {x : M}, x { toAddSubsemigroup := { carrier := S, add_mem' := h₁ }, zero_mem' := h₂ }.toAddSubsemigroup.carrierc x { toAddSubsemigroup := { carrier := S, add_mem' := h₁ }, zero_mem' := h₂ }.toAddSubsemigroup.carrier) (h₄ : ∀ {x : L} {m : M}, m { toAddSubmonoid := { toAddSubsemigroup := { carrier := S, add_mem' := h₁ }, zero_mem' := h₂ }, smul_mem' := h₃ }.toAddSubmonoid.toAddSubsemigroup.carrierx, m { toAddSubmonoid := { toAddSubsemigroup := { carrier := S, add_mem' := h₁ }, zero_mem' := h₂ }, smul_mem' := h₃ }.toAddSubmonoid.toAddSubsemigroup.carrier) {x : M} :
    x { toSubmodule := { toAddSubmonoid := { toAddSubsemigroup := { carrier := S, add_mem' := h₁ }, zero_mem' := h₂ }, smul_mem' := h₃ }, lie_mem := h₄ } x S
    @[simp]
    theorem LieSubmodule.mem_mk_iff' {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (p : Submodule R M) (h : ∀ {x : L} {m : M}, m p.carrierx, m p.carrier) {x : M} :
    x { toSubmodule := p, lie_mem := h } x p
    @[simp]
    theorem LieSubmodule.mem_coeSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) {x : M} :
    x N x N
    theorem LieSubmodule.mem_coe {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) {x : M} :
    x N x N
    @[simp]
    theorem LieSubmodule.zero_mem {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) :
    0 N
    theorem LieSubmodule.mk_eq_zero {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) {x : M} (h : x N) :
    { val := x, property := h } = 0 x = 0
    @[simp]
    theorem LieSubmodule.coe_toSet_mk {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (S : Set M) (h₁ : ∀ {a b : M}, a Sb Sa + b S) (h₂ : S 0) (h₃ : ∀ (c : R) {x : M}, x { toAddSubsemigroup := { carrier := S, add_mem' := h₁ }, zero_mem' := h₂ }.toAddSubsemigroup.carrierc x { toAddSubsemigroup := { carrier := S, add_mem' := h₁ }, zero_mem' := h₂ }.toAddSubsemigroup.carrier) (h₄ : ∀ {x : L} {m : M}, m { toAddSubmonoid := { toAddSubsemigroup := { carrier := S, add_mem' := h₁ }, zero_mem' := h₂ }, smul_mem' := h₃ }.toAddSubmonoid.toAddSubsemigroup.carrierx, m { toAddSubmonoid := { toAddSubsemigroup := { carrier := S, add_mem' := h₁ }, zero_mem' := h₂ }, smul_mem' := h₃ }.toAddSubmonoid.toAddSubsemigroup.carrier) :
    { toSubmodule := { toAddSubmonoid := { toAddSubsemigroup := { carrier := S, add_mem' := h₁ }, zero_mem' := h₂ }, smul_mem' := h₃ }, lie_mem := h₄ } = S
    @[simp]
    theorem LieSubmodule.coe_toSubmodule_mk {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (p : Submodule R M) (h : ∀ {x : L} {m : M}, m { toAddSubmonoid := p.toAddSubmonoid, smul_mem' := (_ : ∀ (c : R) {x : M}, x p.carrierc x p.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrierx, m { toAddSubmonoid := p.toAddSubmonoid, smul_mem' := (_ : ∀ (c : R) {x : M}, x p.carrierc x p.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier) :
    { toSubmodule := { toAddSubmonoid := p.toAddSubmonoid, smul_mem' := (_ : ∀ (c : R) {x : M}, x p.carrierc x p.carrier) }, lie_mem := h } = p
    theorem LieSubmodule.coeSubmodule_injective {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
    Function.Injective LieSubmodule.toSubmodule
    theorem LieSubmodule.ext {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (N' : LieSubmodule R L M) (h : ∀ (m : M), m N m N') :
    N = N'
    @[simp]
    theorem LieSubmodule.coe_toSubmodule_eq_iff {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (N' : LieSubmodule R L M) :
    N = N' N = N'
    def LieSubmodule.copy {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (s : Set M) (hs : s = N) :

    Copy of a LieSubmodule with a new carrier equal to the old one. Useful to fix definitional equalities.

    Instances For
      @[simp]
      theorem LieSubmodule.coe_copy {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (S : LieSubmodule R L M) (s : Set M) (hs : s = S) :
      ↑(LieSubmodule.copy S s hs) = s
      theorem LieSubmodule.copy_eq {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (S : LieSubmodule R L M) (s : Set M) (hs : s = S) :
      instance LieSubmodule.module' {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) {S : Type u_1} [Semiring S] [SMul S R] [Module S M] [IsScalarTower S R M] :
      Module S { x // x N }
      @[simp]
      theorem LieSubmodule.coe_zero {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) :
      0 = 0
      @[simp]
      theorem LieSubmodule.coe_add {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (m : { x // x N }) (m' : { x // x N }) :
      ↑(m + m') = m + m'
      @[simp]
      theorem LieSubmodule.coe_neg {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (m : { x // x N }) :
      ↑(-m) = -m
      @[simp]
      theorem LieSubmodule.coe_sub {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (m : { x // x N }) (m' : { x // x N }) :
      ↑(m - m') = m - m'
      @[simp]
      theorem LieSubmodule.coe_smul {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (t : R) (m : { x // x N }) :
      ↑(t m) = t m
      @[simp]
      theorem LieSubmodule.coe_bracket {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (x : L) (m : { x // x N }) :
      x, m = x, m
      @[inline, reducible]
      abbrev LieIdeal (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] :

      An ideal of a Lie algebra is a Lie submodule of the Lie algebra as a Lie module over itself.

      Instances For
        theorem lie_mem_right (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (x : L) (y : L) (h : y I) :
        theorem lie_mem_left (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (x : L) (y : L) (h : x I) :
        def lieIdealSubalgebra (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :

        An ideal of a Lie algebra is a Lie subalgebra.

        Instances For
          theorem LieIdeal.coe_toSubalgebra (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :
          ↑(R L I) = I
          theorem LieIdeal.coe_to_lieSubalgebra_to_submodule (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :
          (R L I).toSubmodule = I
          instance LieIdeal.lieRing (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :
          LieRing { x // x I }

          An ideal of L is a Lie subalgebra of L, so it is a Lie ring.

          instance LieIdeal.lieAlgebra (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :
          LieAlgebra R { x // x I }

          Transfer the LieAlgebra instance from the coercion LieIdealLieSubalgebra.

          instance LieIdeal.lieRingModule (M : Type w) [AddCommGroup M] {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) [LieRingModule L M] :
          LieRingModule { x // x I } M

          Transfer the LieRingModule instance from the coercion LieIdealLieSubalgebra.

          @[simp]
          theorem LieIdeal.coe_bracket_of_module (M : Type w) [AddCommGroup M] {R : Type u_1} {L : Type u_2} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) [LieRingModule L M] (x : { x // x I }) (m : M) :
          x, m = x, m
          instance LieIdeal.lieModule (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [LieAlgebra R L] [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M] (I : LieIdeal R L) :
          LieModule R { x // x I } M

          Transfer the LieModule instance from the coercion LieIdealLieSubalgebra.

          theorem Submodule.exists_lieSubmodule_coe_eq_iff {R : Type u} (L : Type v) {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (p : Submodule R M) :
          (N, N = p) ∀ (x : L) (m : M), m px, m p
          def LieSubalgebra.toLieSubmodule {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (K : LieSubalgebra R L) :
          LieSubmodule R { x // x K } L

          Given a Lie subalgebra K ⊆ L, if we view L as a K-module by restriction, it contains a distinguished Lie submodule for the action of K, namely K itself.

          Instances For
            @[simp]
            theorem LieSubalgebra.coe_toLieSubmodule {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (K : LieSubalgebra R L) :
            ↑(LieSubalgebra.toLieSubmodule K) = K.toSubmodule
            @[simp]
            theorem LieSubalgebra.exists_lieIdeal_coe_eq_iff {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] {K : LieSubalgebra R L} :
            (I, R L I = K) ∀ (x y : L), y Kx, y K
            theorem LieSubalgebra.exists_nested_lieIdeal_coe_eq_iff {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] {K : LieSubalgebra R L} {K' : LieSubalgebra R L} (h : K K') :
            (I, R { x // x K' } I = LieSubalgebra.ofLe h) ∀ (x y : L), x K'y Kx, y K
            theorem LieSubmodule.coe_injective {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
            Function.Injective SetLike.coe
            @[simp]
            theorem LieSubmodule.coeSubmodule_le_coeSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (N' : LieSubmodule R L M) :
            N N' N N'
            instance LieSubmodule.instBotLieSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
            @[simp]
            theorem LieSubmodule.bot_coe {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
            = {0}
            @[simp]
            theorem LieSubmodule.bot_coeSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
            =
            @[simp]
            theorem LieSubmodule.mem_bot {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (x : M) :
            x x = 0
            instance LieSubmodule.instTopLieSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
            @[simp]
            theorem LieSubmodule.top_coe {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
            = Set.univ
            @[simp]
            theorem LieSubmodule.top_coeSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
            =
            @[simp]
            theorem LieSubmodule.mem_top {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (x : M) :
            instance LieSubmodule.instInfLieSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
            @[simp]
            theorem LieSubmodule.inf_coe {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (N' : LieSubmodule R L M) :
            ↑(N N') = N N'
            @[simp]
            theorem LieSubmodule.sInf_coe_toSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (S : Set (LieSubmodule R L M)) :
            ↑(sInf S) = sInf {x | s, s S s = x}
            @[simp]
            theorem LieSubmodule.iInf_coe_toSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {ι : Sort u_1} (p : ιLieSubmodule R L M) :
            ↑(⨅ (i : ι), p i) = ⨅ (i : ι), ↑(p i)
            @[simp]
            theorem LieSubmodule.sInf_coe {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (S : Set (LieSubmodule R L M)) :
            ↑(sInf S) = ⋂ (s : LieSubmodule R L M) (_ : s S), s
            @[simp]
            theorem LieSubmodule.iInf_coe {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {ι : Sort u_1} (p : ιLieSubmodule R L M) :
            ↑(⨅ (i : ι), p i) = ⋂ (i : ι), ↑(p i)
            @[simp]
            theorem LieSubmodule.mem_iInf {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {ι : Sort u_1} (p : ιLieSubmodule R L M) {x : M} :
            x ⨅ (i : ι), p i ∀ (i : ι), x p i
            theorem LieSubmodule.sInf_glb {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (S : Set (LieSubmodule R L M)) :
            IsGLB S (sInf S)

            The set of Lie submodules of a Lie module form a complete lattice.

            We provide explicit values for the fields bot, top, inf to get more convenient definitions than we would otherwise obtain from completeLatticeOfInf.

            @[simp]
            theorem LieSubmodule.add_eq_sup {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (N' : LieSubmodule R L M) :
            N + N' = N N'
            @[simp]
            theorem LieSubmodule.sup_coe_toSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (N' : LieSubmodule R L M) :
            ↑(N N') = N N'
            @[simp]
            theorem LieSubmodule.inf_coe_toSubmodule {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (N' : LieSubmodule R L M) :
            ↑(N N') = N N'
            @[simp]
            theorem LieSubmodule.mem_inf {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (N' : LieSubmodule R L M) (x : M) :
            x N N' x N x N'
            theorem LieSubmodule.mem_sup {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (N' : LieSubmodule R L M) (x : M) :
            x N N' y, y N z, z N' y + z = x
            theorem LieSubmodule.eq_bot_iff {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) :
            N = ∀ (m : M), m Nm = 0
            instance LieSubmodule.subsingleton_of_bot {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
            Subsingleton (LieSubmodule R L { x // x })
            theorem LieSubmodule.wellFounded_of_noetherian (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [IsNoetherian R M] :
            WellFounded fun x x_1 => x > x_1
            @[simp]
            theorem LieSubmodule.nontrivial_iff_ne_bot (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : LieSubmodule R L M} :
            Nontrivial { x // x N } N
            def LieSubmodule.incl {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) :
            { x // x N } →ₗ⁅R,L M

            The inclusion of a Lie submodule into its ambient space is a morphism of Lie modules.

            Instances For
              @[simp]
              theorem LieSubmodule.incl_coe {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) :
              @[simp]
              theorem LieSubmodule.incl_apply {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) (m : { x // x N }) :
              ↑(LieSubmodule.incl N) m = m
              theorem LieSubmodule.incl_eq_val {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) :
              ↑(LieSubmodule.incl N) = Subtype.val
              def LieSubmodule.homOfLe {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : LieSubmodule R L M} {N' : LieSubmodule R L M} (h : N N') :
              { x // x N } →ₗ⁅R,L { x // x N' }

              Given two nested Lie submodules N ⊆ N', the inclusion N ↪ N' is a morphism of Lie modules.

              Instances For
                @[simp]
                theorem LieSubmodule.coe_homOfLe {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : LieSubmodule R L M} {N' : LieSubmodule R L M} (h : N N') (m : { x // x N }) :
                ↑(↑(LieSubmodule.homOfLe h) m) = m
                theorem LieSubmodule.homOfLe_apply {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : LieSubmodule R L M} {N' : LieSubmodule R L M} (h : N N') (m : { x // x N }) :
                ↑(LieSubmodule.homOfLe h) m = { val := m, property := h m (_ : m N) }
                theorem LieSubmodule.homOfLe_injective {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : LieSubmodule R L M} {N' : LieSubmodule R L M} (h : N N') :
                def LieSubmodule.lieSpan (R : Type u) (L : Type v) {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (s : Set M) :

                The lieSpan of a set s ⊆ M is the smallest Lie submodule of M that contains s.

                Instances For
                  theorem LieSubmodule.mem_lieSpan {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {s : Set M} {x : M} :
                  x LieSubmodule.lieSpan R L s ∀ (N : LieSubmodule R L M), s Nx N
                  theorem LieSubmodule.subset_lieSpan {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {s : Set M} :
                  theorem LieSubmodule.lieSpan_le {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {s : Set M} {N : LieSubmodule R L M} :
                  theorem LieSubmodule.lieSpan_mono {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {s : Set M} {t : Set M} (h : s t) :
                  theorem LieSubmodule.lieSpan_eq {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) :
                  theorem LieSubmodule.coe_lieSpan_submodule_eq_iff {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {p : Submodule R M} :
                  ↑(LieSubmodule.lieSpan R L p) = p N, N = p
                  def LieSubmodule.gi (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :

                  lieSpan forms a Galois insertion with the coercion from LieSubmodule to Set.

                  Instances For
                    @[simp]
                    theorem LieSubmodule.span_empty (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
                    @[simp]
                    theorem LieSubmodule.span_univ (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
                    theorem LieSubmodule.lieSpan_eq_bot_iff (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {s : Set M} :
                    LieSubmodule.lieSpan R L s = ∀ (m : M), m sm = 0
                    theorem LieSubmodule.span_union (R : Type u) (L : Type v) {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (s : Set M) (t : Set M) :
                    theorem LieSubmodule.span_iUnion (R : Type u) (L : Type v) {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {ι : Sort u_1} (s : ιSet M) :
                    LieSubmodule.lieSpan R L (⋃ (i : ι), s i) = ⨆ (i : ι), LieSubmodule.lieSpan R L (s i)
                    def LieSubmodule.map {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup M'] [Module R M'] [LieRingModule L M'] (f : M →ₗ⁅R,L M') (N : LieSubmodule R L M) :

                    A morphism of Lie modules f : M → M' pushes forward Lie submodules of M to Lie submodules of M'.

                    Instances For
                      @[simp]
                      theorem LieSubmodule.coeSubmodule_map {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup M'] [Module R M'] [LieRingModule L M'] (f : M →ₗ⁅R,L M') (N : LieSubmodule R L M) :
                      ↑(LieSubmodule.map f N) = Submodule.map f N
                      def LieSubmodule.comap {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup M'] [Module R M'] [LieRingModule L M'] (f : M →ₗ⁅R,L M') (N' : LieSubmodule R L M') :

                      A morphism of Lie modules f : M → M' pulls back Lie submodules of M' to Lie submodules of M.

                      Instances For
                        @[simp]
                        theorem LieSubmodule.coeSubmodule_comap {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup M'] [Module R M'] [LieRingModule L M'] (f : M →ₗ⁅R,L M') (N' : LieSubmodule R L M') :
                        ↑(LieSubmodule.comap f N') = Submodule.comap f N'
                        theorem LieSubmodule.map_le_iff_le_comap {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup M'] [Module R M'] [LieRingModule L M'] {f : M →ₗ⁅R,L M'} {N : LieSubmodule R L M} {N' : LieSubmodule R L M'} :
                        theorem LieSubmodule.gc_map_comap {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup M'] [Module R M'] [LieRingModule L M'] (f : M →ₗ⁅R,L M') :
                        @[simp]
                        theorem LieSubmodule.map_sup {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup M'] [Module R M'] [LieRingModule L M'] {f : M →ₗ⁅R,L M'} {N : LieSubmodule R L M} {N₂ : LieSubmodule R L M} :
                        @[simp]
                        theorem LieSubmodule.mem_map {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup M'] [Module R M'] [LieRingModule L M'] {f : M →ₗ⁅R,L M'} {N : LieSubmodule R L M} (m' : M') :
                        m' LieSubmodule.map f N m, m N f m = m'
                        @[simp]
                        theorem LieSubmodule.mem_comap {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup M'] [Module R M'] [LieRingModule L M'] {f : M →ₗ⁅R,L M'} {N' : LieSubmodule R L M'} {m : M} :
                        m LieSubmodule.comap f N' f m N'
                        theorem LieSubmodule.comap_incl_eq_top {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : LieSubmodule R L M} {N₂ : LieSubmodule R L M} :
                        theorem LieSubmodule.comap_incl_eq_bot {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] {N : LieSubmodule R L M} {N₂ : LieSubmodule R L M} :
                        @[simp]
                        theorem LieIdeal.top_coe_lieSubalgebra {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] :
                        R L =
                        def LieIdeal.map {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') (I : LieIdeal R L) :

                        A morphism of Lie algebras f : L → L' pushes forward Lie ideals of L to Lie ideals of L'.

                        Note that unlike LieSubmodule.map, we must take the lieSpan of the image. Mathematically this is because although f makes L' into a Lie module over L, in general the L submodules of L' are not the same as the ideals of L'.

                        Instances For
                          def LieIdeal.comap {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') (J : LieIdeal R L') :

                          A morphism of Lie algebras f : L → L' pulls back Lie ideals of L' to Lie ideals of L.

                          Note that f makes L' into a Lie module over L (turning f into a morphism of Lie modules) and so this is a special case of LieSubmodule.comap but we do not exploit this fact.

                          Instances For
                            @[simp]
                            theorem LieIdeal.map_coeSubmodule {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') (I : LieIdeal R L) (h : ↑(LieIdeal.map f I) = f '' I) :
                            ↑(LieIdeal.map f I) = Submodule.map f I
                            @[simp]
                            theorem LieIdeal.comap_coeSubmodule {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') (J : LieIdeal R L') :
                            ↑(LieIdeal.comap f J) = Submodule.comap f J
                            theorem LieIdeal.map_le {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') (I : LieIdeal R L) (J : LieIdeal R L') :
                            LieIdeal.map f I J f '' I J
                            theorem LieIdeal.mem_map {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} {x : L} (hx : x I) :
                            f x LieIdeal.map f I
                            @[simp]
                            theorem LieIdeal.mem_comap {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {J : LieIdeal R L'} {x : L} :
                            x LieIdeal.comap f J f x J
                            theorem LieIdeal.map_le_iff_le_comap {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} {J : LieIdeal R L'} :
                            theorem LieIdeal.gc_map_comap {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :
                            @[simp]
                            theorem LieIdeal.map_sup {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} {I₂ : LieIdeal R L} :
                            theorem LieIdeal.map_comap_le {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {J : LieIdeal R L'} :
                            theorem LieIdeal.comap_map_le {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} :

                            See also LieIdeal.map_comap_eq.

                            theorem LieIdeal.map_mono {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} :
                            theorem LieIdeal.comap_mono {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} :
                            theorem LieIdeal.map_of_image {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} {J : LieIdeal R L'} (h : f '' I = J) :
                            instance LieIdeal.subsingleton_of_bot {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] :
                            Subsingleton (LieIdeal R { x // x })

                            Note that this is not a special case of LieSubmodule.subsingleton_of_bot. Indeed, given I : LieIdeal R L, in general the two lattices LieIdeal R I and LieSubmodule R L I are different (though the latter does naturally inject into the former).

                            In other words, in general, ideals of I, regarded as a Lie algebra in its own right, are not the same as ideals of L contained in I.

                            def LieHom.ker {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :

                            The kernel of a morphism of Lie algebras, as an ideal in the domain.

                            Instances For
                              def LieHom.idealRange {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :

                              The range of a morphism of Lie algebras as an ideal in the codomain.

                              Instances For
                                theorem LieHom.idealRange_eq_map {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :
                                def LieHom.IsIdealMorphism {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :

                                The condition that the image of a morphism of Lie algebras is an ideal.

                                Instances For
                                  @[simp]
                                  theorem LieHom.isIdealMorphism_def {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :
                                  theorem LieHom.isIdealMorphism_iff {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :
                                  LieHom.IsIdealMorphism f ∀ (x : L') (y : L), z, x, f y = f z
                                  theorem LieHom.range_subset_idealRange {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :
                                  theorem LieHom.map_le_idealRange {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') (I : LieIdeal R L) :
                                  theorem LieHom.ker_le_comap {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') (J : LieIdeal R L') :
                                  @[simp]
                                  theorem LieHom.ker_coeSubmodule {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :
                                  @[simp]
                                  theorem LieHom.mem_ker {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') {x : L} :
                                  x LieHom.ker f f x = 0
                                  theorem LieHom.mem_idealRange {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') {x : L} :
                                  @[simp]
                                  theorem LieHom.mem_idealRange_iff {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') (h : LieHom.IsIdealMorphism f) {y : L'} :
                                  y LieHom.idealRange f x, f x = y
                                  theorem LieHom.le_ker_iff {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') (I : LieIdeal R L) :
                                  I LieHom.ker f ∀ (x : L), x If x = 0
                                  theorem LieHom.ker_eq_bot {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :
                                  @[simp]
                                  theorem LieHom.range_coeSubmodule {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :
                                  (LieHom.range f).toSubmodule = LinearMap.range f
                                  theorem LieHom.range_eq_top {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') :
                                  @[simp]
                                  theorem LieHom.idealRange_eq_top_of_surjective {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] (f : L →ₗ⁅R L') (h : Function.Surjective f) :
                                  @[simp]
                                  theorem LieIdeal.map_eq_bot_iff {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} :
                                  theorem LieIdeal.coe_map_of_surjective {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} (h : Function.Surjective f) :
                                  ↑(LieIdeal.map f I) = Submodule.map f I
                                  theorem LieIdeal.mem_map_of_surjective {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} {y : L'} (h₁ : Function.Surjective f) (h₂ : y LieIdeal.map f I) :
                                  x, f x = y
                                  theorem LieIdeal.bot_of_map_eq_bot {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} (h₁ : Function.Injective f) (h₂ : LieIdeal.map f I = ) :
                                  I =
                                  def LieIdeal.homOfLe {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] {I₁ : LieIdeal R L} {I₂ : LieIdeal R L} (h : I₁ I₂) :
                                  { x // x I₁ } →ₗ⁅R { x // x I₂ }

                                  Given two nested Lie ideals I₁ ⊆ I₂, the inclusion I₁ ↪ I₂ is a morphism of Lie algebras.

                                  Instances For
                                    @[simp]
                                    theorem LieIdeal.coe_homOfLe {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] {I₁ : LieIdeal R L} {I₂ : LieIdeal R L} (h : I₁ I₂) (x : { x // x I₁ }) :
                                    ↑(↑(LieIdeal.homOfLe h) x) = x
                                    theorem LieIdeal.homOfLe_apply {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] {I₁ : LieIdeal R L} {I₂ : LieIdeal R L} (h : I₁ I₂) (x : { x // x I₁ }) :
                                    ↑(LieIdeal.homOfLe h) x = { val := x, property := h x (_ : x I₁) }
                                    theorem LieIdeal.homOfLe_injective {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] {I₁ : LieIdeal R L} {I₂ : LieIdeal R L} (h : I₁ I₂) :
                                    theorem LieIdeal.map_sup_ker_eq_map {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} :
                                    @[simp]
                                    theorem LieIdeal.map_sup_ker_eq_map' {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} :
                                    @[simp]
                                    theorem LieIdeal.map_comap_eq {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {J : LieIdeal R L'} (h : LieHom.IsIdealMorphism f) :
                                    @[simp]
                                    theorem LieIdeal.comap_map_eq {R : Type u} {L : Type v} {L' : Type w₂} [CommRing R] [LieRing L] [LieAlgebra R L] [LieRing L'] [LieAlgebra R L'] {f : L →ₗ⁅R L'} {I : LieIdeal R L} (h : ↑(LieIdeal.map f I) = f '' I) :
                                    def LieIdeal.incl {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :
                                    { x // x I } →ₗ⁅R L

                                    Regarding an ideal I as a subalgebra, the inclusion map into its ambient space is a morphism of Lie algebras.

                                    Instances For
                                      @[simp]
                                      theorem LieIdeal.incl_range {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :
                                      @[simp]
                                      theorem LieIdeal.incl_apply {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) (x : { x // x I }) :
                                      ↑(LieIdeal.incl I) x = x
                                      @[simp]
                                      theorem LieIdeal.incl_coe {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :
                                      ↑(LieIdeal.incl I) = Submodule.subtype (R L I).toSubmodule
                                      @[simp]
                                      theorem LieIdeal.comap_incl_self {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :
                                      @[simp]
                                      theorem LieIdeal.ker_incl {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :
                                      @[simp]
                                      theorem LieIdeal.incl_idealRange {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (I : LieIdeal R L) :
                                      def LieModuleHom.ker {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] (f : M →ₗ⁅R,L N) :

                                      The kernel of a morphism of Lie algebras, as an ideal in the domain.

                                      Instances For
                                        @[simp]
                                        theorem LieModuleHom.ker_coeSubmodule {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] (f : M →ₗ⁅R,L N) :
                                        theorem LieModuleHom.ker_eq_bot {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] (f : M →ₗ⁅R,L N) :
                                        @[simp]
                                        theorem LieModuleHom.mem_ker {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] {f : M →ₗ⁅R,L N} (m : M) :
                                        m LieModuleHom.ker f f m = 0
                                        @[simp]
                                        theorem LieModuleHom.ker_id {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] :
                                        LieModuleHom.ker LieModuleHom.id =
                                        @[simp]
                                        theorem LieModuleHom.comp_ker_incl {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] {f : M →ₗ⁅R,L N} :
                                        theorem LieModuleHom.le_ker_iff_map {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] {f : M →ₗ⁅R,L N} (M' : LieSubmodule R L M) :
                                        def LieModuleHom.range {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] (f : M →ₗ⁅R,L N) :

                                        The range of a morphism of Lie modules f : M → N is a Lie submodule of N. See Note [range copy pattern].

                                        Instances For
                                          @[simp]
                                          theorem LieModuleHom.coe_range {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] (f : M →ₗ⁅R,L N) :
                                          @[simp]
                                          theorem LieModuleHom.coeSubmodule_range {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] (f : M →ₗ⁅R,L N) :
                                          @[simp]
                                          theorem LieModuleHom.mem_range {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] (f : M →ₗ⁅R,L N) (n : N) :
                                          n LieModuleHom.range f m, f m = n
                                          theorem LieModuleHom.map_top {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] [AddCommGroup N] [Module R N] [LieRingModule L N] (f : M →ₗ⁅R,L N) :
                                          @[simp]
                                          theorem LieSubmodule.ker_incl {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) :
                                          @[simp]
                                          theorem LieSubmodule.range_incl {R : Type u} {L : Type v} {M : Type w} [CommRing R] [LieRing L] [AddCommGroup M] [Module R M] [LieRingModule L M] (N : LieSubmodule R L M) :
                                          @[simp]
                                          def LieSubalgebra.topEquiv {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] :
                                          { x // x } ≃ₗ⁅R L

                                          The natural equivalence between the 'top' Lie subalgebra and the enclosing Lie algebra.

                                          This is the Lie subalgebra version of Submodule.topEquiv.

                                          Instances For
                                            @[simp]
                                            theorem LieSubalgebra.topEquiv_apply {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (x : { x // x }) :
                                            LieSubalgebra.topEquiv x = x
                                            def LieIdeal.topEquiv {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] :
                                            { x // x } ≃ₗ⁅R L

                                            The natural equivalence between the 'top' Lie ideal and the enclosing Lie algebra.

                                            This is the Lie ideal version of Submodule.topEquiv.

                                            Instances For
                                              @[simp]
                                              theorem LieIdeal.topEquiv_apply {R : Type u} {L : Type v} [CommRing R] [LieRing L] [LieAlgebra R L] (x : { x // x }) :
                                              LieIdeal.topEquiv x = x