File: Mathlib/Algebra/Lie/Submodule.lean

full_name: LieSubmodule.lie_mem
code: /-- 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. -/
structure LieSubmodule extends Submodule R M where
  lie_mem : ∀ {x : L} {m : M}, m ∈ carrier → ⁅x, m⁆ ∈ carrier
goal: m ∈ (↑self).carrier → ⁅x, m⁆ ∈ (↑self).carrier

full_name: LieSubmodule
code: /-- 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. -/
structure LieSubmodule extends Submodule R M where
  lie_mem : ∀ {x : L} {m : M}, m ∈ carrier → ⁅x, m⁆ ∈ carrier
goal: Type w

full_name: LieSubmodule.instSetLike
code: instance : SetLike (LieSubmodule R L M) M 
goal: SetLike (LieSubmodule R L M) M

full_name: LieSubmodule.instAddSubgroupClass
code: instance : AddSubgroupClass (LieSubmodule R L M) M 
goal: AddSubgroupClass (LieSubmodule R L M) M

full_name: LieSubmodule.instSMulMemClass
code: instance instSMulMemClass : SMulMemClass (LieSubmodule R L M) R M 
goal: SMulMemClass (LieSubmodule R L M) R M

full_name: LieSubmodule.instZero
code: /-- The zero module is a Lie submodule of any Lie module. -/
instance : Zero (LieSubmodule R L M) 
goal: Zero (LieSubmodule R L M)

full_name: LieSubmodule.instInhabited
code: instance : Inhabited (LieSubmodule R L M) 
goal: Inhabited (LieSubmodule R L M)

full_name: LieSubmodule.coeSubmodule
code: instance coeSubmodule : CoeOut (LieSubmodule R L M) (Submodule R M) 
goal: CoeOut (LieSubmodule R L M) (Submodule R M)

full_name: LieSubmodule.instCanLiftSubmoduleLieSubmodule
code: instance instCanLiftSubmoduleLieSubmodule : CanLift (Submodule R M) (LieSubmodule R L M) (·)
    (fun N ↦ ∀ {x : L} {m : M}, m ∈ N → ⁅x, m⁆ ∈ N) 
goal: CanLift (Submodule R M) (LieSubmodule R L M) (fun x => ↑x) fun N => ∀ {x : L} {m : M}, m ∈ N → ⁅x, m⁆ ∈ N

full_name: LieSubmodule.coe_toSubmodule
code: @[norm_cast]
theorem coe_toSubmodule : ((N : Submodule R M) : Set M) = N 
goal: ↑↑N = ↑N

full_name: LieSubmodule.mem_carrier
code: @[simp, nolint simpNF]
theorem mem_carrier {x : M} : x ∈ N.carrier ↔ x ∈ (N : Set M) 
goal: x ∈ (↑N).carrier ↔ x ∈ ↑N

full_name: LieSubmodule.mem_mk_iff
code: theorem mem_mk_iff (S : Set M) (h₁ h₂ h₃ h₄) {x : M} :
    x ∈ (⟨⟨⟨⟨S, h₁⟩, h₂⟩, h₃⟩, h₄⟩ : LieSubmodule R L M) ↔ x ∈ S 
goal: x ∈ { carrier := S, add_mem' := h₁, zero_mem' := h₂, smul_mem' := h₃, lie_mem := h₄ } ↔ x ∈ S

full_name: LieSubmodule.mem_mk_iff'
code: @[simp]
theorem mem_mk_iff' (p : Submodule R M) (h) {x : M} :
    x ∈ (⟨p, h⟩ : LieSubmodule R L M) ↔ x ∈ p 
goal: x ∈ { toSubmodule := p, lie_mem := h } ↔ x ∈ p

full_name: LieSubmodule.mem_coeSubmodule
code: @[simp]
theorem mem_coeSubmodule {x : M} : x ∈ (N : Submodule R M) ↔ x ∈ N 
goal: x ∈ ↑N ↔ x ∈ N

full_name: LieSubmodule.mem_coe
code: theorem mem_coe {x : M} : x ∈ (N : Set M) ↔ x ∈ N 
goal: x ∈ ↑N ↔ x ∈ N

full_name: LieSubmodule.zero_mem
code: @[simp]
protected theorem zero_mem : (0 : M) ∈ N 
goal: 0 ∈ N

full_name: LieSubmodule.mk_eq_zero
code: theorem mk_eq_zero {x} (h : x ∈ N) : (⟨x, h⟩ : N) = 0 ↔ x = 0 
goal: ⟨x, h⟩ = 0 ↔ x = 0

full_name: LieSubmodule.coe_toSet_mk
code: @[simp]
theorem coe_toSet_mk (S : Set M) (h₁ h₂ h₃ h₄) :
    ((⟨⟨⟨⟨S, h₁⟩, h₂⟩, h₃⟩, h₄⟩ : LieSubmodule R L M) : Set M) = S 
goal: ↑{ carrier := S, add_mem' := h₁, zero_mem' := h₂, smul_mem' := h₃, lie_mem := h₄ } = S

full_name: LieSubmodule.coe_toSubmodule_mk
code: theorem coe_toSubmodule_mk (p : Submodule R M) (h) :
    (({ p with lie_mem := h } : LieSubmodule R L M) : Submodule R M) = p 
goal: ↑{ toSubmodule := p, lie_mem := h } = p

full_name: LieSubmodule.coeSubmodule_injective
code: theorem coeSubmodule_injective :
    Function.Injective (toSubmodule : LieSubmodule R L M → Submodule R M) 
goal: Function.Injective LieSubmodule.toSubmodule

full_name: LieSubmodule.ext
code: @[ext]
theorem ext (h : ∀ m, m ∈ N ↔ m ∈ N') : N = N' 
goal: N = N'

full_name: LieSubmodule.coe_toSubmodule_eq_iff
code: @[simp]
theorem coe_toSubmodule_eq_iff : (N : Submodule R M) = (N' : Submodule R M) ↔ N = N' 
goal: ↑N = ↑N' ↔ N = N'

full_name: LieSubmodule.copy
code: /-- Copy of a `LieSubmodule` with a new `carrier` equal to the old one. Useful to fix definitional
equalities. -/
protected def copy (s : Set M) (hs : s = ↑N) : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieSubmodule.coe_copy
code: @[simp]
theorem coe_copy (S : LieSubmodule R L M) (s : Set M) (hs : s = ↑S) : (S.copy s hs : Set M) = s 
goal: ↑(S.copy s hs) = s

full_name: LieSubmodule.copy_eq
code: theorem copy_eq (S : LieSubmodule R L M) (s : Set M) (hs : s = ↑S) : S.copy s hs = S 
goal: S.copy s hs = S

full_name: LieSubmodule.instLieRingModuleSubtypeMemSubmodule
code: instance : LieRingModule L N 
goal: LieRingModule L ↥↑N

full_name: LieSubmodule.module'
code: instance module' {S : Type*} [Semiring S] [SMul S R] [Module S M] [IsScalarTower S R M] :
    Module S N 
goal: Module S ↥↑N

full_name: LieSubmodule.instModuleSubtypeMemSubmodule
code: instance : Module R N 
goal: Module R ↥↑N

full_name: LieSubmodule.instIsCentralScalarSubtypeMemSubmodule
code: instance {S : Type*} [Semiring S] [SMul S R] [SMul Sᵐᵒᵖ R] [Module S M] [Module Sᵐᵒᵖ M]
    [IsScalarTower S R M] [IsScalarTower Sᵐᵒᵖ R M] [IsCentralScalar S M] : IsCentralScalar S N 
goal: IsCentralScalar S ↥↑N

full_name: LieSubmodule.instLieModule
code: instance instLieModule : LieModule R L N 
goal: LieModule R L ↥↑N

full_name: LieSubmodule.coe_zero
code: @[simp, norm_cast]
theorem coe_zero : ((0 : N) : M) = (0 : M) 
goal: ↑0 = 0

full_name: LieSubmodule.coe_add
code: @[simp, norm_cast]
theorem coe_add (m m' : N) : (↑(m + m') : M) = (m : M) + (m' : M) 
goal: ↑(m + m') = ↑m + ↑m'

full_name: LieSubmodule.coe_neg
code: @[simp, norm_cast]
theorem coe_neg (m : N) : (↑(-m) : M) = -(m : M) 
goal: ↑(-m) = -↑m

full_name: LieSubmodule.coe_sub
code: @[simp, norm_cast]
theorem coe_sub (m m' : N) : (↑(m - m') : M) = (m : M) - (m' : M) 
goal: ↑(m - m') = ↑m - ↑m'

full_name: LieSubmodule.coe_smul
code: @[simp, norm_cast]
theorem coe_smul (t : R) (m : N) : (↑(t • m) : M) = t • (m : M) 
goal: ↑(t • m) = t • ↑m

full_name: LieSubmodule.coe_bracket
code: @[simp, norm_cast]
theorem coe_bracket (x : L) (m : N) : (↑⁅x, m⁆ : M) = ⁅x, ↑m⁆ 
goal: ↑⁅x, m⁆ = ⁅x, ↑m⁆

full_name: LieSubmodule.instUniqueOfSubsingleton
code: instance [Subsingleton M] : Unique (LieSubmodule R L M) 
goal: Unique (LieSubmodule R L M)

full_name: LieIdeal
code: /-- An ideal of a Lie algebra is a Lie submodule of the Lie algebra as a Lie module over itself. -/
abbrev LieIdeal 
goal: Type v

full_name: lie_mem_right
code: theorem lie_mem_right (I : LieIdeal R L) (x y : L) (h : y ∈ I) : ⁅x, y⁆ ∈ I 
goal: ⁅x, y⁆ ∈ I

full_name: lie_mem_left
code: theorem lie_mem_left (I : LieIdeal R L) (x y : L) (h : x ∈ I) : ⁅x, y⁆ ∈ I 
goal: ⁅x, y⁆ ∈ I

full_name: lieIdealSubalgebra
code: /-- An ideal of a Lie algebra is a Lie subalgebra. -/
def lieIdealSubalgebra (I : LieIdeal R L) : LieSubalgebra R L 
goal: LieSubalgebra R L

full_name: instCoeLieIdealLieSubalgebra
code: instance : Coe (LieIdeal R L) (LieSubalgebra R L) 
goal: Coe (LieIdeal R L) (LieSubalgebra R L)

full_name: LieIdeal.coe_toSubalgebra
code: @[simp]
theorem LieIdeal.coe_toSubalgebra (I : LieIdeal R L) : ((I : LieSubalgebra R L) : Set L) = I 
goal: ↑(lieIdealSubalgebra R L I) = ↑I

full_name: LieIdeal.coe_to_lieSubalgebra_to_submodule
code: @[simp]
theorem LieIdeal.coe_to_lieSubalgebra_to_submodule (I : LieIdeal R L) :
    ((I : LieSubalgebra R L) : Submodule R L) = LieSubmodule.toSubmodule I 
goal: (lieIdealSubalgebra R L I).toSubmodule = ↑I

full_name: LieIdeal.lieRing
code: /-- An ideal of `L` is a Lie subalgebra of `L`, so it is a Lie ring. -/
instance LieIdeal.lieRing (I : LieIdeal R L) : LieRing I 
goal: LieRing ↥↑I

full_name: LieIdeal.lieAlgebra
code: /-- Transfer the `LieAlgebra` instance from the coercion `LieIdeal → LieSubalgebra`. -/
instance LieIdeal.lieAlgebra (I : LieIdeal R L) : LieAlgebra R I 
goal: LieAlgebra R ↥↑I

full_name: LieIdeal.lieRingModule
code: /-- Transfer the `LieRingModule` instance from the coercion `LieIdeal → LieSubalgebra`. -/
instance LieIdeal.lieRingModule {R L : Type*} [CommRing R] [LieRing L] [LieAlgebra R L]
    (I : LieIdeal R L) [LieRingModule L M] : LieRingModule I M 
goal: LieRingModule (↥↑I) M

full_name: LieIdeal.coe_bracket_of_module
code: @[simp]
theorem LieIdeal.coe_bracket_of_module {R L : Type*} [CommRing R] [LieRing L] [LieAlgebra R L]
    (I : LieIdeal R L) [LieRingModule L M] (x : I) (m : M) : ⁅x, m⁆ = ⁅(↑x : L), m⁆ 
goal: ⁅x, m⁆ = ⁅↑x, m⁆

full_name: LieIdeal.lieModule
code: /-- Transfer the `LieModule` instance from the coercion `LieIdeal → LieSubalgebra`. -/
instance LieIdeal.lieModule (I : LieIdeal R L) : LieModule R I M 
goal: LieModule R (↥↑I) M

full_name: Submodule.exists_lieSubmodule_coe_eq_iff
code: theorem Submodule.exists_lieSubmodule_coe_eq_iff (p : Submodule R M) :
    (∃ N : LieSubmodule R L M, ↑N = p) ↔ ∀ (x : L) (m : M), m ∈ p → ⁅x, m⁆ ∈ p 
goal: (∃ N, ↑N = p) ↔ ∀ (x : L), ∀ m ∈ p, ⁅x, m⁆ ∈ p

full_name: LieSubalgebra.toLieSubmodule
code: /-- 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. -/
def toLieSubmodule : LieSubmodule R K L 
goal: LieSubmodule R (↥K) L

full_name: LieSubalgebra.coe_toLieSubmodule
code: @[simp]
theorem coe_toLieSubmodule : (K.toLieSubmodule : Submodule R L) = K 
goal: ↑K.toLieSubmodule = K.toSubmodule

full_name: LieSubalgebra.mem_toLieSubmodule
code: @[simp]
theorem mem_toLieSubmodule (x : L) : x ∈ K.toLieSubmodule ↔ x ∈ K 
goal: x ∈ K.toLieSubmodule ↔ x ∈ K

full_name: LieSubalgebra.exists_lieIdeal_coe_eq_iff
code: theorem exists_lieIdeal_coe_eq_iff :
    (∃ I : LieIdeal R L, ↑I = K) ↔ ∀ x y : L, y ∈ K → ⁅x, y⁆ ∈ K 
goal: (∃ I, lieIdealSubalgebra R L I = K) ↔ ∀ (x y : L), y ∈ K → ⁅x, y⁆ ∈ K

full_name: LieSubalgebra.exists_nested_lieIdeal_coe_eq_iff
code: theorem exists_nested_lieIdeal_coe_eq_iff {K' : LieSubalgebra R L} (h : K ≤ K') :
    (∃ I : LieIdeal R K', ↑I = ofLe h) ↔ ∀ x y : L, x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K 
goal: (∃ I, lieIdealSubalgebra R (↥K') I = LieSubalgebra.ofLe h) ↔ ∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K

full_name: LieSubmodule.coe_injective
code: theorem coe_injective : Function.Injective ((↑) : LieSubmodule R L M → Set M) 
goal: Function.Injective SetLike.coe

full_name: LieSubmodule.coeSubmodule_le_coeSubmodule
code: @[simp, norm_cast]
theorem coeSubmodule_le_coeSubmodule : (N : Submodule R M) ≤ N' ↔ N ≤ N' 
goal: ↑N ≤ ↑N' ↔ N ≤ N'

full_name: LieSubmodule.instBot
code: instance : Bot (LieSubmodule R L M) 
goal: Bot (LieSubmodule R L M)

full_name: LieSubmodule.bot_coe
code: @[simp]
theorem bot_coe : ((⊥ : LieSubmodule R L M) : Set M) = {0} 
goal: ↑⊥ = {0}

full_name: LieSubmodule.bot_coeSubmodule
code: @[simp]
theorem bot_coeSubmodule : ((⊥ : LieSubmodule R L M) : Submodule R M) = ⊥ 
goal: ↑⊥ = ⊥

full_name: LieSubmodule.coeSubmodule_eq_bot_iff
code: @[simp]
theorem coeSubmodule_eq_bot_iff : (N : Submodule R M) = ⊥ ↔ N = ⊥ 
goal: ↑N = ⊥ ↔ N = ⊥

full_name: LieSubmodule.mk_eq_bot_iff
code: @[simp] theorem mk_eq_bot_iff {N : Submodule R M} {h} :
    (⟨N, h⟩ : LieSubmodule R L M) = ⊥ ↔ N = ⊥ 
goal: { toSubmodule := N, lie_mem := h } = ⊥ ↔ N = ⊥

full_name: LieSubmodule.mem_bot
code: @[simp]
theorem mem_bot (x : M) : x ∈ (⊥ : LieSubmodule R L M) ↔ x = 0 
goal: x ∈ ⊥ ↔ x = 0

full_name: LieSubmodule.instTop
code: instance : Top (LieSubmodule R L M) 
goal: Top (LieSubmodule R L M)

full_name: LieSubmodule.top_coe
code: @[simp]
theorem top_coe : ((⊤ : LieSubmodule R L M) : Set M) = univ 
goal: ↑⊤ = Set.univ

full_name: LieSubmodule.top_coeSubmodule
code: @[simp]
theorem top_coeSubmodule : ((⊤ : LieSubmodule R L M) : Submodule R M) = ⊤ 
goal: ↑⊤ = ⊤

full_name: LieSubmodule.coeSubmodule_eq_top_iff
code: @[simp]
theorem coeSubmodule_eq_top_iff : (N : Submodule R M) = ⊤ ↔ N = ⊤ 
goal: ↑N = ⊤ ↔ N = ⊤

full_name: LieSubmodule.mk_eq_top_iff
code: @[simp] theorem mk_eq_top_iff {N : Submodule R M} {h} :
    (⟨N, h⟩ : LieSubmodule R L M) = ⊤ ↔ N = ⊤ 
goal: { toSubmodule := N, lie_mem := h } = ⊤ ↔ N = ⊤

full_name: LieSubmodule.mem_top
code: @[simp]
theorem mem_top (x : M) : x ∈ (⊤ : LieSubmodule R L M) 
goal: x ∈ ⊤

full_name: LieSubmodule.instInf
code: instance : Inf (LieSubmodule R L M) 
goal: Inf (LieSubmodule R L M)

full_name: LieSubmodule.instInfSet
code: instance : InfSet (LieSubmodule R L M) 
goal: InfSet (LieSubmodule R L M)

full_name: LieSubmodule.inf_coe
code: @[simp]
theorem inf_coe : (↑(N ⊓ N') : Set M) = ↑N ∩ ↑N' 
goal: ↑(N ⊓ N') = ↑N ∩ ↑N'

full_name: LieSubmodule.inf_coe_toSubmodule
code: @[norm_cast, simp]
theorem inf_coe_toSubmodule :
    (↑(N ⊓ N') : Submodule R M) = (N : Submodule R M) ⊓ (N' : Submodule R M) 
goal: ↑(N ⊓ N') = ↑N ⊓ ↑N'

full_name: LieSubmodule.sInf_coe_toSubmodule
code: @[simp]
theorem sInf_coe_toSubmodule (S : Set (LieSubmodule R L M)) :
    (↑(sInf S) : Submodule R M) = sInf {(s : Submodule R M) | s ∈ S} 
goal: ↑(sInf S) = sInf {x | ∃ s ∈ S, ↑s = x}

full_name: LieSubmodule.sInf_coe_toSubmodule'
code: theorem sInf_coe_toSubmodule' (S : Set (LieSubmodule R L M)) :
    (↑(sInf S) : Submodule R M) = ⨅ N ∈ S, (N : Submodule R M) 
goal: ↑(sInf S) = ⨅ N ∈ S, ↑N

full_name: LieSubmodule.iInf_coe_toSubmodule
code: @[simp]
theorem iInf_coe_toSubmodule {ι} (p : ι → LieSubmodule R L M) :
    (↑(⨅ i, p i) : Submodule R M) = ⨅ i, (p i : Submodule R M) 
goal: ↑(⨅ i, p i) = ⨅ i, ↑(p i)

full_name: LieSubmodule.sInf_coe
code: @[simp]
theorem sInf_coe (S : Set (LieSubmodule R L M)) : (↑(sInf S) : Set M) = ⋂ s ∈ S, (s : Set M) 
goal: ↑(sInf S) = ⋂ s ∈ S, ↑s

full_name: LieSubmodule.iInf_coe
code: @[simp]
theorem iInf_coe {ι} (p : ι → LieSubmodule R L M) : (↑(⨅ i, p i) : Set M) = ⋂ i, ↑(p i) 
goal: ↑(⨅ i, p i) = ⋂ i, ↑(p i)

full_name: LieSubmodule.mem_iInf
code: @[simp]
theorem mem_iInf {ι} (p : ι → LieSubmodule R L M) {x} : (x ∈ ⨅ i, p i) ↔ ∀ i, x ∈ p i 
goal: x ∈ ⨅ i, p i ↔ ∀ (i : ι), x ∈ p i

full_name: LieSubmodule.instSup
code: instance : Sup (LieSubmodule R L M) 
goal: Sup (LieSubmodule R L M)

full_name: LieSubmodule.instSupSet
code: instance : SupSet (LieSubmodule R L M) 
goal: SupSet (LieSubmodule R L M)

full_name: LieSubmodule.sup_coe_toSubmodule
code: @[norm_cast, simp]
theorem sup_coe_toSubmodule :
    (↑(N ⊔ N') : Submodule R M) = (N : Submodule R M) ⊔ (N' : Submodule R M) 
goal: ↑(N ⊔ N') = ↑N ⊔ ↑N'

full_name: LieSubmodule.sSup_coe_toSubmodule
code: @[simp]
theorem sSup_coe_toSubmodule (S : Set (LieSubmodule R L M)) :
    (↑(sSup S) : Submodule R M) = sSup {(s : Submodule R M) | s ∈ S} 
goal: ↑(sSup S) = sSup {x | ∃ s ∈ S, ↑s = x}

full_name: LieSubmodule.sSup_coe_toSubmodule'
code: theorem sSup_coe_toSubmodule' (S : Set (LieSubmodule R L M)) :
    (↑(sSup S) : Submodule R M) = ⨆ N ∈ S, (N : Submodule R M) 
goal: ↑(sSup S) = ⨆ N ∈ S, ↑N

full_name: LieSubmodule.iSup_coe_toSubmodule
code: @[simp]
theorem iSup_coe_toSubmodule {ι} (p : ι → LieSubmodule R L M) :
    (↑(⨆ i, p i) : Submodule R M) = ⨆ i, (p i : Submodule R M) 
goal: ↑(⨆ i, p i) = ⨆ i, ↑(p i)

full_name: LieSubmodule.instCompleteLattice
code: /-- The set of Lie submodules of a Lie module form a complete lattice. -/
instance : CompleteLattice (LieSubmodule R L M) 
goal: CompleteLattice (LieSubmodule R L M)

full_name: LieSubmodule.mem_iSup_of_mem
code: theorem mem_iSup_of_mem {ι} {b : M} {N : ι → LieSubmodule R L M} (i : ι) (h : b ∈ N i) :
    b ∈ ⨆ i, N i 
goal: b ∈ ⨆ i, N i

full_name: LieSubmodule.iSup_induction
code: lemma iSup_induction {ι} (N : ι → LieSubmodule R L M) {C : M → Prop} {x : M}
    (hx : x ∈ ⨆ i, N i) (hN : ∀ i, ∀ y ∈ N i, C y) (h0 : C 0)
    (hadd : ∀ y z, C y → C z → C (y + z)) : C x 
goal: C x

full_name: LieSubmodule.iSup_induction'
code: @[elab_as_elim]
theorem iSup_induction' {ι} (N : ι → LieSubmodule R L M) {C : (x : M) → (x ∈ ⨆ i, N i) → Prop}
    (hN : ∀ (i) (x) (hx : x ∈ N i), C x (mem_iSup_of_mem i hx)) (h0 : C 0 (zero_mem _))
    (hadd : ∀ x y hx hy, C x hx → C y hy → C (x + y) (add_mem ‹_› ‹_›)) {x : M}
    (hx : x ∈ ⨆ i, N i) : C x hx 
goal: C x hx

full_name: LieSubmodule.disjoint_iff_coe_toSubmodule
code: theorem disjoint_iff_coe_toSubmodule :
    Disjoint N N' ↔ Disjoint (N : Submodule R M) (N' : Submodule R M) 
goal: Disjoint N N' ↔ Disjoint ↑N ↑N'

full_name: LieSubmodule.codisjoint_iff_coe_toSubmodule
code: theorem codisjoint_iff_coe_toSubmodule :
    Codisjoint N N' ↔ Codisjoint (N : Submodule R M) (N' : Submodule R M) 
goal: Codisjoint N N' ↔ Codisjoint ↑N ↑N'

full_name: LieSubmodule.isCompl_iff_coe_toSubmodule
code: theorem isCompl_iff_coe_toSubmodule :
    IsCompl N N' ↔ IsCompl (N : Submodule R M) (N' : Submodule R M) 
goal: IsCompl N N' ↔ IsCompl ↑N ↑N'

full_name: LieSubmodule.independent_iff_coe_toSubmodule
code: theorem independent_iff_coe_toSubmodule {ι : Type*} {N : ι → LieSubmodule R L M} :
    CompleteLattice.Independent N ↔ CompleteLattice.Independent fun i ↦ (N i : Submodule R M) 
goal: CompleteLattice.Independent N ↔ CompleteLattice.Independent fun i => ↑(N i)

full_name: LieSubmodule.iSup_eq_top_iff_coe_toSubmodule
code: theorem iSup_eq_top_iff_coe_toSubmodule {ι : Sort*} {N : ι → LieSubmodule R L M} :
    ⨆ i, N i = ⊤ ↔ ⨆ i, (N i : Submodule R M) = ⊤ 
goal: ⨆ i, N i = ⊤ ↔ ⨆ i, ↑(N i) = ⊤

full_name: LieSubmodule.instAdd
code: instance : Add (LieSubmodule R L M) 
goal: Add (LieSubmodule R L M)

full_name: LieSubmodule.instZero_1
code: instance : Zero (LieSubmodule R L M) 
goal: Zero (LieSubmodule R L M)

full_name: LieSubmodule.instAddCommMonoid
code: instance : AddCommMonoid (LieSubmodule R L M) 
goal: AddCommMonoid (LieSubmodule R L M)

full_name: LieSubmodule.add_eq_sup
code: @[simp]
theorem add_eq_sup : N + N' = N ⊔ N' 
goal: N + N' = N ⊔ N'

full_name: LieSubmodule.mem_inf
code: @[simp]
theorem mem_inf (x : M) : x ∈ N ⊓ N' ↔ x ∈ N ∧ x ∈ N' 
goal: x ∈ N ⊓ N' ↔ x ∈ N ∧ x ∈ N'

full_name: LieSubmodule.mem_sup
code: theorem mem_sup (x : M) : x ∈ N ⊔ N' ↔ ∃ y ∈ N, ∃ z ∈ N', y + z = x 
goal: x ∈ N ⊔ N' ↔ ∃ y ∈ N, ∃ z ∈ N', y + z = x

full_name: LieSubmodule.eq_bot_iff
code: nonrec theorem eq_bot_iff : N = ⊥ ↔ ∀ m : M, m ∈ N → m = 0 
goal: N = ⊥ ↔ ∀ m ∈ N, m = 0

full_name: LieSubmodule.subsingleton_of_bot
code: instance subsingleton_of_bot : Subsingleton (LieSubmodule R L ↑(⊥ : LieSubmodule R L M)) 
goal: Subsingleton (LieSubmodule R L ↥↑⊥)

full_name: LieSubmodule.instIsModularLattice
code: instance : IsModularLattice (LieSubmodule R L M) 
goal: IsModularLattice (LieSubmodule R L M)

full_name: LieSubmodule.toSubmodule_orderEmbedding
code: /-- The natural functor that forgets the action of `L` as an order embedding. -/
@[simps] def toSubmodule_orderEmbedding : LieSubmodule R L M ↪o Submodule R M 
goal: LieSubmodule R L M ↪o Submodule R M

full_name: LieSubmodule.toSubmodule_orderEmbedding_apply
code: /-- The natural functor that forgets the action of `L` as an order embedding. -/
@[simps] def toSubmodule_orderEmbedding : LieSubmodule R L M ↪o Submodule R M 
goal: (LieSubmodule.toSubmodule_orderEmbedding R L M) self = ↑self

full_name: LieSubmodule.wellFounded_of_noetherian
code: theorem wellFounded_of_noetherian [IsNoetherian R M] :
    WellFounded ((· > ·) : LieSubmodule R L M → LieSubmodule R L M → Prop) 
goal: WellFounded fun x x_1 => x > x_1

full_name: LieSubmodule.wellFounded_of_isArtinian
code: theorem wellFounded_of_isArtinian [IsArtinian R M] :
    WellFounded ((· < ·) : LieSubmodule R L M → LieSubmodule R L M → Prop) 
goal: WellFounded fun x x_1 => x < x_1

full_name: LieSubmodule.instIsAtomicOfIsArtinian
code: instance [IsArtinian R M] : IsAtomic (LieSubmodule R L M) 
goal: IsAtomic (LieSubmodule R L M)

full_name: LieSubmodule.subsingleton_iff
code: @[simp]
theorem subsingleton_iff : Subsingleton (LieSubmodule R L M) ↔ Subsingleton M 
goal: Subsingleton (LieSubmodule R L M) ↔ Subsingleton M

full_name: LieSubmodule.nontrivial_iff
code: @[simp]
theorem nontrivial_iff : Nontrivial (LieSubmodule R L M) ↔ Nontrivial M 
goal: Nontrivial (LieSubmodule R L M) ↔ Nontrivial M

full_name: LieSubmodule.instNontrivial
code: instance [Nontrivial M] : Nontrivial (LieSubmodule R L M) 
goal: Nontrivial (LieSubmodule R L M)

full_name: LieSubmodule.nontrivial_iff_ne_bot
code: theorem nontrivial_iff_ne_bot {N : LieSubmodule R L M} : Nontrivial N ↔ N ≠ ⊥ 
goal: Nontrivial ↥↑N ↔ N ≠ ⊥

full_name: LieSubmodule.incl
code: /-- The inclusion of a Lie submodule into its ambient space is a morphism of Lie modules. -/
def incl : N →ₗ⁅R,L⁆ M 
goal: ↥↑N →ₗ⁅R,L⁆ M

full_name: LieSubmodule.incl_coe
code: @[simp]
theorem incl_coe : (N.incl : N →ₗ[R] M) = (N : Submodule R M).subtype 
goal: ↑N.incl = (↑N).subtype

full_name: LieSubmodule.incl_apply
code: @[simp]
theorem incl_apply (m : N) : N.incl m = m 
goal: N.incl m = ↑m

full_name: LieSubmodule.incl_eq_val
code: theorem incl_eq_val : (N.incl : N → M) = Subtype.val 
goal: ⇑N.incl = Subtype.val

full_name: LieSubmodule.injective_incl
code: theorem injective_incl : Function.Injective N.incl 
goal: Function.Injective ⇑N.incl

full_name: LieSubmodule.inclusion
code: /-- Given two nested Lie submodules `N ⊆ N'`,
the inclusion `N ↪ N'` is a morphism of Lie modules. -/
def inclusion : N →ₗ⁅R,L⁆ N' 
goal: ↥↑N →ₗ⁅R,L⁆ ↥↑N'

full_name: LieSubmodule.coe_inclusion
code: @[simp]
theorem coe_inclusion (m : N) : (inclusion h m : M) = m 
goal: ↑((LieSubmodule.inclusion h) m) = ↑m

full_name: LieSubmodule.inclusion_apply
code: theorem inclusion_apply (m : N) : inclusion h m = ⟨m.1, h m.2⟩ 
goal: (LieSubmodule.inclusion h) m = ⟨↑m, ⋯⟩

full_name: LieSubmodule.inclusion_injective
code: theorem inclusion_injective : Function.Injective (inclusion h) 
goal: Function.Injective ⇑(LieSubmodule.inclusion h)

full_name: LieSubmodule.lieSpan
code: /-- The `lieSpan` of a set `s ⊆ M` is the smallest Lie submodule of `M` that contains `s`. -/
def lieSpan : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieSubmodule.mem_lieSpan
code: theorem mem_lieSpan {x : M} : x ∈ lieSpan R L s ↔ ∀ N : LieSubmodule R L M, s ⊆ N → x ∈ N 
goal: x ∈ LieSubmodule.lieSpan R L s ↔ ∀ (N : LieSubmodule R L M), s ⊆ ↑N → x ∈ N

full_name: LieSubmodule.subset_lieSpan
code: theorem subset_lieSpan : s ⊆ lieSpan R L s 
goal: s ⊆ ↑(LieSubmodule.lieSpan R L s)

full_name: LieSubmodule.submodule_span_le_lieSpan
code: theorem submodule_span_le_lieSpan : Submodule.span R s ≤ lieSpan R L s 
goal: Submodule.span R s ≤ ↑(LieSubmodule.lieSpan R L s)

full_name: LieSubmodule.lieSpan_le
code: @[simp]
theorem lieSpan_le {N} : lieSpan R L s ≤ N ↔ s ⊆ N 
goal: LieSubmodule.lieSpan R L s ≤ N ↔ s ⊆ ↑N

full_name: LieSubmodule.lieSpan_mono
code: theorem lieSpan_mono {t : Set M} (h : s ⊆ t) : lieSpan R L s ≤ lieSpan R L t 
goal: LieSubmodule.lieSpan R L s ≤ LieSubmodule.lieSpan R L t

full_name: LieSubmodule.lieSpan_eq
code: theorem lieSpan_eq : lieSpan R L (N : Set M) = N 
goal: LieSubmodule.lieSpan R L ↑N = N

full_name: LieSubmodule.coe_lieSpan_submodule_eq_iff
code: theorem coe_lieSpan_submodule_eq_iff {p : Submodule R M} :
    (lieSpan R L (p : Set M) : Submodule R M) = p ↔ ∃ N : LieSubmodule R L M, ↑N = p 
goal: ↑(LieSubmodule.lieSpan R L ↑p) = p ↔ ∃ N, ↑N = p

full_name: LieSubmodule.gi
code: /-- `lieSpan` forms a Galois insertion with the coercion from `LieSubmodule` to `Set`. -/
protected def gi : GaloisInsertion (lieSpan R L : Set M → LieSubmodule R L M) (↑) 
goal: GaloisInsertion (LieSubmodule.lieSpan R L) SetLike.coe

full_name: LieSubmodule.span_empty
code: @[simp]
theorem span_empty : lieSpan R L (∅ : Set M) = ⊥ 
goal: LieSubmodule.lieSpan R L ∅ = ⊥

full_name: LieSubmodule.span_univ
code: @[simp]
theorem span_univ : lieSpan R L (Set.univ : Set M) = ⊤ 
goal: LieSubmodule.lieSpan R L Set.univ = ⊤

full_name: LieSubmodule.lieSpan_eq_bot_iff
code: theorem lieSpan_eq_bot_iff : lieSpan R L s = ⊥ ↔ ∀ m ∈ s, m = (0 : M) 
goal: LieSubmodule.lieSpan R L s = ⊥ ↔ ∀ m ∈ s, m = 0

full_name: LieSubmodule.span_union
code: theorem span_union (s t : Set M) : lieSpan R L (s ∪ t) = lieSpan R L s ⊔ lieSpan R L t 
goal: LieSubmodule.lieSpan R L (s ∪ t) = LieSubmodule.lieSpan R L s ⊔ LieSubmodule.lieSpan R L t

full_name: LieSubmodule.span_iUnion
code: theorem span_iUnion {ι} (s : ι → Set M) : lieSpan R L (⋃ i, s i) = ⨆ i, lieSpan R L (s i) 
goal: LieSubmodule.lieSpan R L (⋃ i, s i) = ⨆ i, LieSubmodule.lieSpan R L (s i)

full_name: LieSubmodule.isCompactElement_lieSpan_singleton
code: lemma isCompactElement_lieSpan_singleton (m : M) :
    CompleteLattice.IsCompactElement (lieSpan R L {m}) 
goal: CompleteLattice.IsCompactElement (LieSubmodule.lieSpan R L {m})

full_name: LieSubmodule.sSup_image_lieSpan_singleton
code: @[simp]
lemma sSup_image_lieSpan_singleton : sSup ((fun x ↦ lieSpan R L {x}) '' N) = N 
goal: sSup ((fun x => LieSubmodule.lieSpan R L {x}) '' ↑N) = N

full_name: LieSubmodule.instIsCompactlyGenerated
code: instance instIsCompactlyGenerated : IsCompactlyGenerated (LieSubmodule R L M) 
goal: IsCompactlyGenerated (LieSubmodule R L M)

full_name: LieSubmodule.map
code: /-- A morphism of Lie modules `f : M → M'` pushes forward Lie submodules of `M` to Lie submodules
of `M'`. -/
def map : LieSubmodule R L M' 
goal: LieSubmodule R L M'

full_name: LieSubmodule.coe_map
code: @[simp] theorem coe_map : (N.map f : Set M') = f '' N 
goal: ↑(LieSubmodule.map f N) = ⇑f '' ↑N

full_name: LieSubmodule.coeSubmodule_map
code: @[simp]
theorem coeSubmodule_map : (N.map f : Submodule R M') = (N : Submodule R M).map (f : M →ₗ[R] M') 
goal: ↑(LieSubmodule.map f N) = Submodule.map ↑f ↑N

full_name: LieSubmodule.comap
code: /-- A morphism of Lie modules `f : M → M'` pulls back Lie submodules of `M'` to Lie submodules of
`M`. -/
def comap : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieSubmodule.coeSubmodule_comap
code: @[simp]
theorem coeSubmodule_comap :
    (N'.comap f : Submodule R M) = (N' : Submodule R M').comap (f : M →ₗ[R] M') 
goal: ↑(LieSubmodule.comap f N') = Submodule.comap ↑f ↑N'

full_name: LieSubmodule.map_le_iff_le_comap
code: theorem map_le_iff_le_comap : map f N ≤ N' ↔ N ≤ comap f N' 
goal: LieSubmodule.map f N ≤ N' ↔ N ≤ LieSubmodule.comap f N'

full_name: LieSubmodule.gc_map_comap
code: theorem gc_map_comap : GaloisConnection (map f) (comap f) 
goal: GaloisConnection (LieSubmodule.map f) (LieSubmodule.comap f)

full_name: LieSubmodule.map_inf_le
code: theorem map_inf_le : (N ⊓ N₂).map f ≤ N.map f ⊓ N₂.map f 
goal: LieSubmodule.map f (N ⊓ N₂) ≤ LieSubmodule.map f N ⊓ LieSubmodule.map f N₂

full_name: LieSubmodule.map_inf
code: theorem map_inf (hf : Function.Injective f) :
    (N ⊓ N₂).map f = N.map f ⊓ N₂.map f 
goal: LieSubmodule.map f (N ⊓ N₂) = LieSubmodule.map f N ⊓ LieSubmodule.map f N₂

full_name: LieSubmodule.map_sup
code: @[simp]
theorem map_sup : (N ⊔ N₂).map f = N.map f ⊔ N₂.map f 
goal: LieSubmodule.map f (N ⊔ N₂) = LieSubmodule.map f N ⊔ LieSubmodule.map f N₂

full_name: LieSubmodule.comap_inf
code: @[simp]
theorem comap_inf {N₂' : LieSubmodule R L M'} :
    (N' ⊓ N₂').comap f = N'.comap f ⊓ N₂'.comap f 
goal: LieSubmodule.comap f (N' ⊓ N₂') = LieSubmodule.comap f N' ⊓ LieSubmodule.comap f N₂'

full_name: LieSubmodule.map_iSup
code: @[simp]
theorem map_iSup {ι : Sort*} (N : ι → LieSubmodule R L M) :
    (⨆ i, N i).map f = ⨆ i, (N i).map f 
goal: LieSubmodule.map f (⨆ i, N i) = ⨆ i, LieSubmodule.map f (N i)

full_name: LieSubmodule.mem_map
code: @[simp]
theorem mem_map (m' : M') : m' ∈ N.map f ↔ ∃ m, m ∈ N ∧ f m = m' 
goal: m' ∈ LieSubmodule.map f N ↔ ∃ m ∈ N, f m = m'

full_name: LieSubmodule.mem_map_of_mem
code: theorem mem_map_of_mem {m : M} (h : m ∈ N) : f m ∈ N.map f 
goal: f m ∈ LieSubmodule.map f N

full_name: LieSubmodule.mem_comap
code: @[simp]
theorem mem_comap {m : M} : m ∈ comap f N' ↔ f m ∈ N' 
goal: m ∈ LieSubmodule.comap f N' ↔ f m ∈ N'

full_name: LieSubmodule.comap_incl_eq_top
code: theorem comap_incl_eq_top : N₂.comap N.incl = ⊤ ↔ N ≤ N₂ 
goal: LieSubmodule.comap N.incl N₂ = ⊤ ↔ N ≤ N₂

full_name: LieSubmodule.comap_incl_eq_bot
code: theorem comap_incl_eq_bot : N₂.comap N.incl = ⊥ ↔ N ⊓ N₂ = ⊥ 
goal: LieSubmodule.comap N.incl N₂ = ⊥ ↔ N ⊓ N₂ = ⊥

full_name: LieSubmodule.map_mono
code: @[mono]
theorem map_mono (h : N ≤ N₂) : N.map f ≤ N₂.map f 
goal: LieSubmodule.map f N ≤ LieSubmodule.map f N₂

full_name: LieSubmodule.map_comp
code: theorem map_comp
    {M'' : Type*} [AddCommGroup M''] [Module R M''] [LieRingModule L M''] {g : M' →ₗ⁅R,L⁆ M''} :
    N.map (g.comp f) = (N.map f).map g 
goal: LieSubmodule.map (g.comp f) N = LieSubmodule.map g (LieSubmodule.map f N)

full_name: LieSubmodule.map_id
code: @[simp]
theorem map_id : N.map LieModuleHom.id = N 
goal: LieSubmodule.map LieModuleHom.id N = N

full_name: LieSubmodule.map_bot
code: @[simp] theorem map_bot :
    (⊥ : LieSubmodule R L M).map f = ⊥ 
goal: LieSubmodule.map f ⊥ = ⊥

full_name: LieSubmodule.map_le_map_iff
code: lemma map_le_map_iff (hf : Function.Injective f) :
    N.map f ≤ N₂.map f ↔ N ≤ N₂ 
goal: LieSubmodule.map f N ≤ LieSubmodule.map f N₂ ↔ N ≤ N₂

full_name: LieSubmodule.map_injective_of_injective
code: lemma map_injective_of_injective (hf : Function.Injective f) :
    Function.Injective (map f) 
goal: Function.Injective (LieSubmodule.map f)

full_name: LieSubmodule.mapOrderEmbedding_apply
code: /-- An injective morphism of Lie modules embeds the lattice of submodules of the domain into that
of the target. -/
@[simps] def mapOrderEmbedding {f : M →ₗ⁅R,L⁆ M'} (hf : Function.Injective f) :
  LieSubmodule R L M ↪o LieSubmodule R L M' 
goal: (LieSubmodule.mapOrderEmbedding hf) N = LieSubmodule.map f N

full_name: LieSubmodule.mapOrderEmbedding
code: /-- An injective morphism of Lie modules embeds the lattice of submodules of the domain into that
of the target. -/
@[simps] def mapOrderEmbedding {f : M →ₗ⁅R,L⁆ M'} (hf : Function.Injective f) :
  LieSubmodule R L M ↪o LieSubmodule R L M' 
goal: LieSubmodule R L M ↪o LieSubmodule R L M'

full_name: LieSubmodule.equivMapOfInjective
code: /-- For an injective morphism of Lie modules, any Lie submodule is equivalent to its image. -/
noncomputable def equivMapOfInjective (hf : Function.Injective f) :
    N ≃ₗ⁅R,L⁆ N.map f 
goal: ↥↑N ≃ₗ⁅R,L⁆ ↥↑(LieSubmodule.map f N)

full_name: LieSubmodule.orderIsoMapComap_apply
code: /-- An equivalence of Lie modules yields an order-preserving equivalence of their lattices of Lie
Submodules. -/
@[simps] def orderIsoMapComap (e : M ≃ₗ⁅R,L⁆ M') :
    LieSubmodule R L M ≃o LieSubmodule R L M' 
goal: (LieSubmodule.orderIsoMapComap e) N = LieSubmodule.map e.toLieModuleHom N

full_name: LieSubmodule.orderIsoMapComap_symm_apply
code: /-- An equivalence of Lie modules yields an order-preserving equivalence of their lattices of Lie
Submodules. -/
@[simps] def orderIsoMapComap (e : M ≃ₗ⁅R,L⁆ M') :
    LieSubmodule R L M ≃o LieSubmodule R L M' 
goal: (RelIso.symm (LieSubmodule.orderIsoMapComap e)) N' = LieSubmodule.comap e.toLieModuleHom N'

full_name: LieSubmodule.orderIsoMapComap
code: /-- An equivalence of Lie modules yields an order-preserving equivalence of their lattices of Lie
Submodules. -/
@[simps] def orderIsoMapComap (e : M ≃ₗ⁅R,L⁆ M') :
    LieSubmodule R L M ≃o LieSubmodule R L M' 
goal: LieSubmodule R L M ≃o LieSubmodule R L M'

full_name: LieIdeal.top_coe_lieSubalgebra
code: @[simp]
theorem top_coe_lieSubalgebra : ((⊤ : LieIdeal R L) : LieSubalgebra R L) = ⊤ 
goal: lieIdealSubalgebra R L ⊤ = ⊤

full_name: LieIdeal.map
code: /-- 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'`. -/
def map : LieIdeal R L' 
goal: LieIdeal R L'

full_name: LieIdeal.comap
code: /-- 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. -/
def comap : LieIdeal R L 
goal: LieIdeal R L

full_name: LieIdeal.map_coeSubmodule
code: @[simp]
theorem map_coeSubmodule (h : ↑(map f I) = f '' I) :
    LieSubmodule.toSubmodule (map f I) = (LieSubmodule.toSubmodule I).map (f : L →ₗ[R] L') 
goal: ↑(LieIdeal.map f I) = Submodule.map ↑f ↑I

full_name: LieIdeal.comap_coeSubmodule
code: @[simp]
theorem comap_coeSubmodule :
    (LieSubmodule.toSubmodule (comap f J)) = (LieSubmodule.toSubmodule J).comap (f : L →ₗ[R] L') 
goal: ↑(LieIdeal.comap f J) = Submodule.comap ↑f ↑J

full_name: LieIdeal.map_le
code: theorem map_le : map f I ≤ J ↔ f '' I ⊆ J 
goal: LieIdeal.map f I ≤ J ↔ ⇑f '' ↑I ⊆ ↑J

full_name: LieIdeal.mem_map
code: theorem mem_map {x : L} (hx : x ∈ I) : f x ∈ map f I 
goal: f x ∈ LieIdeal.map f I

full_name: LieIdeal.mem_comap
code: @[simp]
theorem mem_comap {x : L} : x ∈ comap f J ↔ f x ∈ J 
goal: x ∈ LieIdeal.comap f J ↔ f x ∈ J

full_name: LieIdeal.map_le_iff_le_comap
code: theorem map_le_iff_le_comap : map f I ≤ J ↔ I ≤ comap f J 
goal: LieIdeal.map f I ≤ J ↔ I ≤ LieIdeal.comap f J

full_name: LieIdeal.gc_map_comap
code: theorem gc_map_comap : GaloisConnection (map f) (comap f) 
goal: GaloisConnection (LieIdeal.map f) (LieIdeal.comap f)

full_name: LieIdeal.map_sup
code: @[simp]
theorem map_sup : (I ⊔ I₂).map f = I.map f ⊔ I₂.map f 
goal: LieIdeal.map f (I ⊔ I₂) = LieIdeal.map f I ⊔ LieIdeal.map f I₂

full_name: LieIdeal.map_comap_le
code: theorem map_comap_le : map f (comap f J) ≤ J 
goal: LieIdeal.map f (LieIdeal.comap f J) ≤ J

full_name: LieIdeal.comap_map_le
code: /-- See also `LieIdeal.map_comap_eq`. -/
theorem comap_map_le : I ≤ comap f (map f I) 
goal: I ≤ LieIdeal.comap f (LieIdeal.map f I)

full_name: LieIdeal.map_mono
code: @[mono]
theorem map_mono : Monotone (map f) 
goal: Monotone (LieIdeal.map f)

full_name: LieIdeal.comap_mono
code: @[mono]
theorem comap_mono : Monotone (comap f) 
goal: Monotone (LieIdeal.comap f)

full_name: LieIdeal.map_of_image
code: theorem map_of_image (h : f '' I = J) : I.map f = J 
goal: LieIdeal.map f I = J

full_name: LieIdeal.subsingleton_of_bot
code: /-- 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`. -/
instance subsingleton_of_bot : Subsingleton (LieIdeal R (⊥ : LieIdeal R L)) 
goal: Subsingleton (LieIdeal R ↥↑⊥)

full_name: LieHom.ker
code: /-- The kernel of a morphism of Lie algebras, as an ideal in the domain. -/
def ker : LieIdeal R L 
goal: LieIdeal R L

full_name: LieHom.idealRange
code: /-- The range of a morphism of Lie algebras as an ideal in the codomain. -/
def idealRange : LieIdeal R L' 
goal: LieIdeal R L'

full_name: LieHom.idealRange_eq_lieSpan_range
code: theorem idealRange_eq_lieSpan_range : f.idealRange = LieSubmodule.lieSpan R L' f.range 
goal: f.idealRange = LieSubmodule.lieSpan R L' ↑f.range

full_name: LieHom.idealRange_eq_map
code: theorem idealRange_eq_map : f.idealRange = LieIdeal.map f ⊤ 
goal: f.idealRange = LieIdeal.map f ⊤

full_name: LieHom.IsIdealMorphism
code: /-- The condition that the range of a morphism of Lie algebras is an ideal. -/
def IsIdealMorphism : Prop 
goal: Prop

full_name: LieHom.isIdealMorphism_def
code: @[simp]
theorem isIdealMorphism_def : f.IsIdealMorphism ↔ (f.idealRange : LieSubalgebra R L') = f.range 
goal: f.IsIdealMorphism ↔ lieIdealSubalgebra R L' f.idealRange = f.range

full_name: LieHom.IsIdealMorphism.eq
code: theorem IsIdealMorphism.eq (hf : f.IsIdealMorphism) : f.idealRange = f.range 
goal: lieIdealSubalgebra R L' f.idealRange = f.range

full_name: LieHom.isIdealMorphism_iff
code: theorem isIdealMorphism_iff : f.IsIdealMorphism ↔ ∀ (x : L') (y : L), ∃ z : L, ⁅x, f y⁆ = f z 
goal: f.IsIdealMorphism ↔ ∀ (x : L') (y : L), ∃ z, ⁅x, f y⁆ = f z

full_name: LieHom.range_subset_idealRange
code: theorem range_subset_idealRange : (f.range : Set L') ⊆ f.idealRange 
goal: ↑f.range ⊆ ↑f.idealRange

full_name: LieHom.map_le_idealRange
code: theorem map_le_idealRange : I.map f ≤ f.idealRange 
goal: LieIdeal.map f I ≤ f.idealRange

full_name: LieHom.ker_le_comap
code: theorem ker_le_comap : f.ker ≤ J.comap f 
goal: f.ker ≤ LieIdeal.comap f J

full_name: LieHom.ker_coeSubmodule
code: @[simp]
theorem ker_coeSubmodule : LieSubmodule.toSubmodule (ker f) = LinearMap.ker (f : L →ₗ[R] L') 
goal: ↑f.ker = LinearMap.ker ↑f

full_name: LieHom.mem_ker
code: @[simp]
theorem mem_ker {x : L} : x ∈ ker f ↔ f x = 0 
goal: x ∈ f.ker ↔ f x = 0

full_name: LieHom.mem_idealRange
code: theorem mem_idealRange (x : L) : f x ∈ idealRange f 
goal: f x ∈ f.idealRange

full_name: LieHom.mem_idealRange_iff
code: @[simp]
theorem mem_idealRange_iff (h : IsIdealMorphism f) {y : L'} :
    y ∈ idealRange f ↔ ∃ x : L, f x = y 
goal: y ∈ f.idealRange ↔ ∃ x, f x = y

full_name: LieHom.le_ker_iff
code: theorem le_ker_iff : I ≤ f.ker ↔ ∀ x, x ∈ I → f x = 0 
goal: I ≤ f.ker ↔ ∀ x ∈ I, f x = 0

full_name: LieHom.ker_eq_bot
code: theorem ker_eq_bot : f.ker = ⊥ ↔ Function.Injective f 
goal: f.ker = ⊥ ↔ Function.Injective ⇑f

full_name: LieHom.range_coeSubmodule
code: @[simp]
theorem range_coeSubmodule : (f.range : Submodule R L') = LinearMap.range (f : L →ₗ[R] L') 
goal: f.range.toSubmodule = LinearMap.range ↑f

full_name: LieHom.range_eq_top
code: theorem range_eq_top : f.range = ⊤ ↔ Function.Surjective f 
goal: f.range = ⊤ ↔ Function.Surjective ⇑f

full_name: LieHom.idealRange_eq_top_of_surjective
code: @[simp]
theorem idealRange_eq_top_of_surjective (h : Function.Surjective f) : f.idealRange = ⊤ 
goal: f.idealRange = ⊤

full_name: LieHom.isIdealMorphism_of_surjective
code: theorem isIdealMorphism_of_surjective (h : Function.Surjective f) : f.IsIdealMorphism 
goal: f.IsIdealMorphism

full_name: LieIdeal.map_eq_bot_iff
code: @[simp]
theorem map_eq_bot_iff : I.map f = ⊥ ↔ I ≤ f.ker 
goal: LieIdeal.map f I = ⊥ ↔ I ≤ f.ker

full_name: LieIdeal.coe_map_of_surjective
code: theorem coe_map_of_surjective (h : Function.Surjective f) :
    LieSubmodule.toSubmodule (I.map f) = (LieSubmodule.toSubmodule I).map (f : L →ₗ[R] L') 
goal: ↑(LieIdeal.map f I) = Submodule.map ↑f ↑I

full_name: LieIdeal.mem_map_of_surjective
code: theorem mem_map_of_surjective {y : L'} (h₁ : Function.Surjective f) (h₂ : y ∈ I.map f) :
    ∃ x : I, f x = y 
goal: ∃ x, f ↑x = y

full_name: LieIdeal.bot_of_map_eq_bot
code: theorem bot_of_map_eq_bot {I : LieIdeal R L} (h₁ : Function.Injective f) (h₂ : I.map f = ⊥) :
    I = ⊥ 
goal: I = ⊥

full_name: LieIdeal.inclusion
code: /-- Given two nested Lie ideals `I₁ ⊆ I₂`, the inclusion `I₁ ↪ I₂` is a morphism of Lie algebras. -/
def inclusion {I₁ I₂ : LieIdeal R L} (h : I₁ ≤ I₂) : I₁ →ₗ⁅R⁆ I₂ 
goal: ↥↑I₁ →ₗ⁅R⁆ ↥↑I₂

full_name: LieIdeal.coe_inclusion
code: @[simp]
theorem coe_inclusion {I₁ I₂ : LieIdeal R L} (h : I₁ ≤ I₂) (x : I₁) : (inclusion h x : L) = x 
goal: ↑((LieIdeal.inclusion h) x) = ↑x

full_name: LieIdeal.inclusion_apply
code: theorem inclusion_apply {I₁ I₂ : LieIdeal R L} (h : I₁ ≤ I₂) (x : I₁) :
    inclusion h x = ⟨x.1, h x.2⟩ 
goal: (LieIdeal.inclusion h) x = ⟨↑x, ⋯⟩

full_name: LieIdeal.inclusion_injective
code: theorem inclusion_injective {I₁ I₂ : LieIdeal R L} (h : I₁ ≤ I₂) :
    Function.Injective (inclusion h) 
goal: Function.Injective ⇑(LieIdeal.inclusion h)

full_name: LieIdeal.map_sup_ker_eq_map
code: theorem map_sup_ker_eq_map : LieIdeal.map f (I ⊔ f.ker) = LieIdeal.map f I 
goal: LieIdeal.map f (I ⊔ f.ker) = LieIdeal.map f I

full_name: LieIdeal.map_sup_ker_eq_map'
code: @[simp]
theorem map_sup_ker_eq_map' :
    LieIdeal.map f I ⊔ LieIdeal.map f (LieHom.ker f) = LieIdeal.map f I 
goal: LieIdeal.map f I ⊔ LieIdeal.map f f.ker = LieIdeal.map f I

full_name: LieIdeal.map_comap_eq
code: @[simp]
theorem map_comap_eq (h : f.IsIdealMorphism) : map f (comap f J) = f.idealRange ⊓ J 
goal: LieIdeal.map f (LieIdeal.comap f J) = f.idealRange ⊓ J

full_name: LieIdeal.comap_map_eq
code: @[simp]
theorem comap_map_eq (h : ↑(map f I) = f '' I) : comap f (map f I) = I ⊔ f.ker 
goal: LieIdeal.comap f (LieIdeal.map f I) = I ⊔ f.ker

full_name: LieIdeal.incl
code: /-- Regarding an ideal `I` as a subalgebra, the inclusion map into its ambient space is a morphism
of Lie algebras. -/
def incl : I →ₗ⁅R⁆ L 
goal: ↥↑I →ₗ⁅R⁆ L

full_name: LieIdeal.incl_range
code: @[simp]
theorem incl_range : I.incl.range = I 
goal: I.incl.range = lieIdealSubalgebra R L I

full_name: LieIdeal.incl_apply
code: @[simp]
theorem incl_apply (x : I) : I.incl x = x 
goal: I.incl x = ↑x

full_name: LieIdeal.incl_coe
code: @[simp]
theorem incl_coe : (I.incl.toLinearMap : I →ₗ[R] L) = (I : Submodule R L).subtype 
goal: ↑I.incl = (lieIdealSubalgebra R L I).subtype

full_name: LieIdeal.incl_injective
code: lemma incl_injective (I : LieIdeal R L) : Function.Injective I.incl 
goal: Function.Injective ⇑I.incl

full_name: LieIdeal.comap_incl_self
code: @[simp]
theorem comap_incl_self : comap I.incl I = ⊤ 
goal: LieIdeal.comap I.incl I = ⊤

full_name: LieIdeal.ker_incl
code: @[simp]
theorem ker_incl : I.incl.ker = ⊥ 
goal: I.incl.ker = ⊥

full_name: LieIdeal.incl_idealRange
code: @[simp]
theorem incl_idealRange : I.incl.idealRange = I 
goal: I.incl.idealRange = I

full_name: LieIdeal.incl_isIdealMorphism
code: theorem incl_isIdealMorphism : I.incl.IsIdealMorphism 
goal: I.incl.IsIdealMorphism

full_name: LieModuleHom.ker
code: /-- The kernel of a morphism of Lie algebras, as an ideal in the domain. -/
def ker : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieModuleHom.ker_coeSubmodule
code: @[simp]
theorem ker_coeSubmodule : (f.ker : Submodule R M) = LinearMap.ker (f : M →ₗ[R] N) 
goal: ↑f.ker = LinearMap.ker ↑f

full_name: LieModuleHom.ker_eq_bot
code: theorem ker_eq_bot : f.ker = ⊥ ↔ Function.Injective f 
goal: f.ker = ⊥ ↔ Function.Injective ⇑f

full_name: LieModuleHom.mem_ker
code: @[simp]
theorem mem_ker (m : M) : m ∈ f.ker ↔ f m = 0 
goal: m ∈ f.ker ↔ f m = 0

full_name: LieModuleHom.ker_id
code: @[simp]
theorem ker_id : (LieModuleHom.id : M →ₗ⁅R,L⁆ M).ker = ⊥ 
goal: LieModuleHom.id.ker = ⊥

full_name: LieModuleHom.comp_ker_incl
code: @[simp]
theorem comp_ker_incl : f.comp f.ker.incl = 0 
goal: f.comp f.ker.incl = 0

full_name: LieModuleHom.le_ker_iff_map
code: theorem le_ker_iff_map (M' : LieSubmodule R L M) : M' ≤ f.ker ↔ LieSubmodule.map f M' = ⊥ 
goal: M' ≤ f.ker ↔ LieSubmodule.map f M' = ⊥

full_name: LieModuleHom.range
code: /-- The range of a morphism of Lie modules `f : M → N` is a Lie submodule of `N`.
See Note [range copy pattern]. -/
def range : LieSubmodule R L N 
goal: LieSubmodule R L N

full_name: LieModuleHom.coe_range
code: @[simp]
theorem coe_range : (f.range : Set N) = Set.range f 
goal: ↑f.range = Set.range ⇑f

full_name: LieModuleHom.coeSubmodule_range
code: @[simp]
theorem coeSubmodule_range : (f.range : Submodule R N) = LinearMap.range (f : M →ₗ[R] N) 
goal: ↑f.range = LinearMap.range ↑f

full_name: LieModuleHom.mem_range
code: @[simp]
theorem mem_range (n : N) : n ∈ f.range ↔ ∃ m, f m = n 
goal: n ∈ f.range ↔ ∃ m, f m = n

full_name: LieModuleHom.map_top
code: @[simp]
theorem map_top : LieSubmodule.map f ⊤ = f.range 
goal: LieSubmodule.map f ⊤ = f.range

full_name: LieModuleHom.range_eq_top
code: theorem range_eq_top : f.range = ⊤ ↔ Function.Surjective f 
goal: f.range = ⊤ ↔ Function.Surjective ⇑f

full_name: LieModuleHom.codRestrict
code: /-- A morphism of Lie modules `f : M → N` whose values lie in a Lie submodule `P ⊆ N` can be
restricted to a morphism of Lie modules `M → P`. -/
def codRestrict (P : LieSubmodule R L N) (f : M →ₗ⁅R,L⁆ N) (h : ∀ m, f m ∈ P) :
    M →ₗ⁅R,L⁆ P 
goal: M →ₗ⁅R,L⁆ ↥↑P

full_name: LieModuleHom.codRestrict_apply
code: @[simp]
lemma codRestrict_apply (P : LieSubmodule R L N) (f : M →ₗ⁅R,L⁆ N) (h : ∀ m, f m ∈ P) (m : M) :
    (f.codRestrict P h m : N) = f m 
goal: ↑((LieModuleHom.codRestrict P f h) m) = f m

full_name: LieSubmodule.ker_incl
code: @[simp]
theorem ker_incl : N.incl.ker = ⊥ 
goal: N.incl.ker = ⊥

full_name: LieSubmodule.range_incl
code: @[simp]
theorem range_incl : N.incl.range = N 
goal: N.incl.range = N

full_name: LieSubmodule.comap_incl_self
code: @[simp]
theorem comap_incl_self : comap N.incl N = ⊤ 
goal: LieSubmodule.comap N.incl N = ⊤

full_name: LieSubmodule.map_incl_top
code: theorem map_incl_top : (⊤ : LieSubmodule R L N).map N.incl = N 
goal: LieSubmodule.map N.incl ⊤ = N

full_name: LieSubmodule.map_le_range
code: @[simp]
lemma map_le_range {M' : Type*}
    [AddCommGroup M'] [Module R M'] [LieRingModule L M'] (f : M →ₗ⁅R,L⁆ M') :
    N.map f ≤ f.range 
goal: LieSubmodule.map f N ≤ f.range

full_name: LieSubmodule.map_incl_lt_iff_lt_top
code: @[simp]
lemma map_incl_lt_iff_lt_top {N' : LieSubmodule R L N} :
    N'.map (LieSubmodule.incl N) < N ↔ N' < ⊤ 
goal: LieSubmodule.map N.incl N' < N ↔ N' < ⊤

full_name: LieSubmodule.map_incl_le
code: @[simp]
lemma map_incl_le {N' : LieSubmodule R L N} :
    N'.map N.incl ≤ N 
goal: LieSubmodule.map N.incl N' ≤ N

full_name: LieSubalgebra.topEquiv
code: /-- The natural equivalence between the 'top' Lie subalgebra and the enclosing Lie algebra.

This is the Lie subalgebra version of `Submodule.topEquiv`. -/
def LieSubalgebra.topEquiv : (⊤ : LieSubalgebra R L) ≃ₗ⁅R⁆ L 
goal: ↥⊤ ≃ₗ⁅R⁆ L

full_name: LieSubalgebra.topEquiv_apply
code: @[simp]
theorem LieSubalgebra.topEquiv_apply (x : (⊤ : LieSubalgebra R L)) : LieSubalgebra.topEquiv x = x 
goal: LieSubalgebra.topEquiv x = ↑x

full_name: LieIdeal.topEquiv
code: /-- The natural equivalence between the 'top' Lie ideal and the enclosing Lie algebra.

This is the Lie ideal version of `Submodule.topEquiv`. -/
def LieIdeal.topEquiv : (⊤ : LieIdeal R L) ≃ₗ⁅R⁆ L 
goal: ↥↑⊤ ≃ₗ⁅R⁆ L

full_name: LieIdeal.topEquiv_apply
code: @[simp, nolint simpNF]
theorem LieIdeal.topEquiv_apply (x : (⊤ : LieIdeal R L)) : LieIdeal.topEquiv x = x 
goal: LieIdeal.topEquiv x = ↑x

full_name: LieModuleEquiv.ofTop
code: /-- The natural equivalence between the 'top' Lie submodule and the enclosing Lie module. -/
def LieModuleEquiv.ofTop : (⊤ : LieSubmodule R L M) ≃ₗ⁅R,L⁆ M 
goal: ↥↑⊤ ≃ₗ⁅R,L⁆ M

full_name: LieModuleEquiv.ofTop_apply
code: @[simp, nolint simpNF] lemma LieModuleEquiv.ofTop_apply (x : (⊤ : LieSubmodule R L M)) :
    LieModuleEquiv.ofTop R L M x = x 
goal: (LieModuleEquiv.ofTop R L M) x = ↑x

full_name: LieModuleEquiv.range_coe
code: @[simp] lemma LieModuleEquiv.range_coe {M' : Type*}
    [AddCommGroup M'] [Module R M'] [LieRingModule L M'] (e : M ≃ₗ⁅R,L⁆ M') :
    LieModuleHom.range (e : M →ₗ⁅R,L⁆ M') = ⊤ 
goal: e.range = ⊤