File: Mathlib/Algebra/Lie/Subalgebra.lean

full_name: LieSubalgebra
code: /-- A Lie subalgebra of a Lie algebra is submodule that is closed under the Lie bracket.
This is a sufficient condition for the subset itself to form a Lie algebra. -/
structure LieSubalgebra extends Submodule R L where
  /-- A Lie subalgebra is closed under Lie bracket. -/
  lie_mem' : ∀ {x y}, x ∈ carrier → y ∈ carrier → ⁅x, y⁆ ∈ carrier
goal: Type v

full_name: LieSubalgebra.lie_mem'
code: /-- A Lie subalgebra of a Lie algebra is submodule that is closed under the Lie bracket.
This is a sufficient condition for the subset itself to form a Lie algebra. -/
structure LieSubalgebra extends Submodule R L where
  /-- A Lie subalgebra is closed under Lie bracket. -/
  lie_mem' : ∀ {x y}, x ∈ carrier → y ∈ carrier → ⁅x, y⁆ ∈ carrier
goal: x ∈ self.carrier → y ∈ self.carrier → ⁅x, y⁆ ∈ self.carrier

full_name: instZeroLieSubalgebra
code: /-- The zero algebra is a subalgebra of any Lie algebra. -/
instance : Zero (LieSubalgebra R L) 
goal: Zero (LieSubalgebra R L)

full_name: instInhabitedLieSubalgebra
code: instance : Inhabited (LieSubalgebra R L) 
goal: Inhabited (LieSubalgebra R L)

full_name: instCoeLieSubalgebraSubmodule
code: instance : Coe (LieSubalgebra R L) (Submodule R L) 
goal: Coe (LieSubalgebra R L) (Submodule R L)

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

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

full_name: LieSubalgebra.lieRing
code: /-- A Lie subalgebra forms a new Lie ring. -/
instance lieRing (L' : LieSubalgebra R L) : LieRing L' 
goal: LieRing ↥L'

full_name: LieSubalgebra.instModuleSubtypeMemOfIsScalarTower
code: /-- A Lie subalgebra inherits module structures from `L`. -/
instance [SMul R₁ R] [Module R₁ L] [IsScalarTower R₁ R L] (L' : LieSubalgebra R L) : Module R₁ L' 
goal: Module R₁ ↥L'

full_name: LieSubalgebra.instIsCentralScalarSubtypeMem
code: instance [SMul R₁ R] [SMul R₁ᵐᵒᵖ R] [Module R₁ L] [Module R₁ᵐᵒᵖ L] [IsScalarTower R₁ R L]
    [IsScalarTower R₁ᵐᵒᵖ R L] [IsCentralScalar R₁ L] (L' : LieSubalgebra R L) :
    IsCentralScalar R₁ L' 
goal: IsCentralScalar R₁ ↥L'

full_name: LieSubalgebra.instIsScalarTowerSubtypeMem
code: instance [SMul R₁ R] [Module R₁ L] [IsScalarTower R₁ R L] (L' : LieSubalgebra R L) :
    IsScalarTower R₁ R L' 
goal: IsScalarTower R₁ R ↥L'

full_name: LieSubalgebra.instIsNoetherianSubtypeMem
code: instance (L' : LieSubalgebra R L) [IsNoetherian R L] : IsNoetherian R L' 
goal: IsNoetherian R ↥L'

full_name: LieSubalgebra.lieAlgebra
code: /-- A Lie subalgebra forms a new Lie algebra. -/
instance lieAlgebra (L' : LieSubalgebra R L) : LieAlgebra R L' 
goal: LieAlgebra R ↥L'

full_name: LieSubalgebra.zero_mem
code: @[simp]
protected theorem zero_mem : (0 : L) ∈ L' 
goal: 0 ∈ L'

full_name: LieSubalgebra.add_mem
code: protected theorem add_mem {x y : L} : x ∈ L' → y ∈ L' → (x + y : L) ∈ L' 
goal: x ∈ L' → y ∈ L' → x + y ∈ L'

full_name: LieSubalgebra.sub_mem
code: protected theorem sub_mem {x y : L} : x ∈ L' → y ∈ L' → (x - y : L) ∈ L' 
goal: x ∈ L' → y ∈ L' → x - y ∈ L'

full_name: LieSubalgebra.smul_mem
code: theorem smul_mem (t : R) {x : L} (h : x ∈ L') : t • x ∈ L' 
goal: t • x ∈ L'

full_name: LieSubalgebra.lie_mem
code: theorem lie_mem {x y : L} (hx : x ∈ L') (hy : y ∈ L') : (⁅x, y⁆ : L) ∈ L' 
goal: ⁅x, y⁆ ∈ L'

full_name: LieSubalgebra.mem_carrier
code: theorem mem_carrier {x : L} : x ∈ L'.carrier ↔ x ∈ (L' : Set L) 
goal: x ∈ L'.carrier ↔ x ∈ ↑L'

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

full_name: LieSubalgebra.mem_coe_submodule
code: @[simp]
theorem mem_coe_submodule {x : L} : x ∈ (L' : Submodule R L) ↔ x ∈ L' 
goal: x ∈ L'.toSubmodule ↔ x ∈ L'

full_name: LieSubalgebra.mem_coe
code: theorem mem_coe {x : L} : x ∈ (L' : Set L) ↔ x ∈ L' 
goal: x ∈ ↑L' ↔ x ∈ L'

full_name: LieSubalgebra.coe_bracket
code: @[simp, norm_cast]
theorem coe_bracket (x y : L') : (↑⁅x, y⁆ : L) = ⁅(↑x : L), ↑y⁆ 
goal: ↑⁅x, y⁆ = ⁅↑x, ↑y⁆

full_name: LieSubalgebra.ext_iff
code: theorem ext_iff (x y : L') : x = y ↔ (x : L) = y 
goal: x = y ↔ ↑x = ↑y

full_name: LieSubalgebra.coe_zero_iff_zero
code: theorem coe_zero_iff_zero (x : L') : (x : L) = 0 ↔ x = 0 
goal: ↑x = 0 ↔ x = 0

full_name: LieSubalgebra.ext
code: @[ext]
theorem ext (L₁' L₂' : LieSubalgebra R L) (h : ∀ x, x ∈ L₁' ↔ x ∈ L₂') : L₁' = L₂' 
goal: L₁' = L₂'

full_name: LieSubalgebra.ext_iff'
code: theorem ext_iff' (L₁' L₂' : LieSubalgebra R L) : L₁' = L₂' ↔ ∀ x, x ∈ L₁' ↔ x ∈ L₂' 
goal: L₁' = L₂' ↔ ∀ (x : L), x ∈ L₁' ↔ x ∈ L₂'

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

full_name: LieSubalgebra.coe_to_submodule_mk
code: theorem coe_to_submodule_mk (p : Submodule R L) (h) :
    (({ p with lie_mem' := h } : LieSubalgebra R L) : Submodule R L) = p 
goal: { toSubmodule := p, lie_mem' := h }.toSubmodule = p

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

full_name: LieSubalgebra.coe_set_eq
code: @[norm_cast]
theorem coe_set_eq (L₁' L₂' : LieSubalgebra R L) : (L₁' : Set L) = L₂' ↔ L₁' = L₂' 
goal: ↑L₁' = ↑L₂' ↔ L₁' = L₂'

full_name: LieSubalgebra.to_submodule_injective
code: theorem to_submodule_injective : Function.Injective ((↑) : LieSubalgebra R L → Submodule R L) 
goal: Function.Injective LieSubalgebra.toSubmodule

full_name: LieSubalgebra.coe_to_submodule_eq_iff
code: @[simp]
theorem coe_to_submodule_eq_iff (L₁' L₂' : LieSubalgebra R L) :
    (L₁' : Submodule R L) = (L₂' : Submodule R L) ↔ L₁' = L₂' 
goal: L₁'.toSubmodule = L₂'.toSubmodule ↔ L₁' = L₂'

full_name: LieSubalgebra.coe_to_submodule
code: theorem coe_to_submodule : ((L' : Submodule R L) : Set L) = L' 
goal: ↑L'.toSubmodule = ↑L'

full_name: LieSubalgebra.lieRingModule
code: /-- Given a Lie algebra `L` containing a Lie subalgebra `L' ⊆ L`, together with a Lie ring module
`M` of `L`, we may regard `M` as a Lie ring module of `L'` by restriction. -/
instance lieRingModule : LieRingModule L' M 
goal: LieRingModule (↥L') M

full_name: LieSubalgebra.coe_bracket_of_module
code: @[simp]
theorem coe_bracket_of_module (x : L') (m : M) : ⁅x, m⁆ = ⁅(x : L), m⁆ 
goal: ⁅x, m⁆ = ⁅↑x, m⁆

full_name: LieSubalgebra.lieModule
code: /-- Given a Lie algebra `L` containing a Lie subalgebra `L' ⊆ L`, together with a Lie module `M` of
`L`, we may regard `M` as a Lie module of `L'` by restriction. -/
instance lieModule : LieModule R L' M 
goal: LieModule R (↥L') M

full_name: LieModuleHom.restrictLie
code: /-- An `L`-equivariant map of Lie modules `M → N` is `L'`-equivariant for any Lie subalgebra
`L' ⊆ L`. -/
def _root_.LieModuleHom.restrictLie (f : M →ₗ⁅R,L⁆ N) (L' : LieSubalgebra R L) : M →ₗ⁅R,L'⁆ N 
goal: M →ₗ⁅R,↥L'⁆ N

full_name: LieModuleHom.coe_restrictLie
code: @[simp]
theorem _root_.LieModuleHom.coe_restrictLie (f : M →ₗ⁅R,L⁆ N) : ⇑(f.restrictLie L') = f 
goal: ⇑(f.restrictLie L') = ⇑f

full_name: LieSubalgebra.incl
code: /-- The embedding of a Lie subalgebra into the ambient space as a morphism of Lie algebras. -/
def incl : L' →ₗ⁅R⁆ L 
goal: ↥L' →ₗ⁅R⁆ L

full_name: LieSubalgebra.coe_incl
code: @[simp]
theorem coe_incl : ⇑L'.incl = ((↑) : L' → L) 
goal: ⇑L'.incl = Subtype.val

full_name: LieSubalgebra.incl'
code: /-- The embedding of a Lie subalgebra into the ambient space as a morphism of Lie modules. -/
def incl' : L' →ₗ⁅R,L'⁆ L 
goal: ↥L' →ₗ⁅R,↥L'⁆ L

full_name: LieSubalgebra.coe_incl'
code: @[simp]
theorem coe_incl' : ⇑L'.incl' = ((↑) : L' → L) 
goal: ⇑L'.incl' = Subtype.val

full_name: LieHom.range
code: /-- The range of a morphism of Lie algebras is a Lie subalgebra. -/
def range : LieSubalgebra R L₂ 
goal: LieSubalgebra R L₂

full_name: LieHom.range_coe
code: @[simp]
theorem range_coe : (f.range : Set L₂) = Set.range f 
goal: ↑f.range = Set.range ⇑f

full_name: LieHom.mem_range
code: @[simp]
theorem mem_range (x : L₂) : x ∈ f.range ↔ ∃ y : L, f y = x 
goal: x ∈ f.range ↔ ∃ y, f y = x

full_name: LieHom.mem_range_self
code: theorem mem_range_self (x : L) : f x ∈ f.range 
goal: f x ∈ f.range

full_name: LieHom.rangeRestrict
code: /-- We can restrict a morphism to a (surjective) map to its range. -/
def rangeRestrict : L →ₗ⁅R⁆ f.range 
goal: L →ₗ⁅R⁆ ↥f.range

full_name: LieHom.rangeRestrict_apply
code: @[simp]
theorem rangeRestrict_apply (x : L) : f.rangeRestrict x = ⟨f x, f.mem_range_self x⟩ 
goal: f.rangeRestrict x = ⟨f x, ⋯⟩

full_name: LieHom.surjective_rangeRestrict
code: theorem surjective_rangeRestrict : Function.Surjective f.rangeRestrict 
goal: Function.Surjective ⇑f.rangeRestrict

full_name: LieHom.equivRangeOfInjective
code: /-- A Lie algebra is equivalent to its range under an injective Lie algebra morphism. -/
noncomputable def equivRangeOfInjective (h : Function.Injective f) : L ≃ₗ⁅R⁆ f.range 
goal: L ≃ₗ⁅R⁆ ↥f.range

full_name: LieHom.equivRangeOfInjective_apply
code: @[simp]
theorem equivRangeOfInjective_apply (h : Function.Injective f) (x : L) :
    f.equivRangeOfInjective h x = ⟨f x, mem_range_self f x⟩ 
goal: (f.equivRangeOfInjective h) x = ⟨f x, ⋯⟩

full_name: Submodule.exists_lieSubalgebra_coe_eq_iff
code: theorem Submodule.exists_lieSubalgebra_coe_eq_iff (p : Submodule R L) :
    (∃ K : LieSubalgebra R L, ↑K = p) ↔ ∀ x y : L, x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p 
goal: (∃ K, K.toSubmodule = p) ↔ ∀ (x y : L), x ∈ p → y ∈ p → ⁅x, y⁆ ∈ p

full_name: LieSubalgebra.incl_range
code: @[simp]
theorem incl_range : K.incl.range = K 
goal: K.incl.range = K

full_name: LieSubalgebra.map
code: /-- The image of a Lie subalgebra under a Lie algebra morphism is a Lie subalgebra of the
codomain. -/
def map : LieSubalgebra R L₂ 
goal: LieSubalgebra R L₂

full_name: LieSubalgebra.mem_map
code: @[simp]
theorem mem_map (x : L₂) : x ∈ K.map f ↔ ∃ y : L, y ∈ K ∧ f y = x 
goal: x ∈ LieSubalgebra.map f K ↔ ∃ y ∈ K, f y = x

full_name: LieSubalgebra.mem_map_submodule
code: theorem mem_map_submodule (e : L ≃ₗ⁅R⁆ L₂) (x : L₂) :
    x ∈ K.map (e : L →ₗ⁅R⁆ L₂) ↔ x ∈ (K : Submodule R L).map (e : L →ₗ[R] L₂) 
goal: x ∈ LieSubalgebra.map e.toLieHom K ↔ x ∈ Submodule.map (↑e.toLinearEquiv) K.toSubmodule

full_name: LieSubalgebra.comap
code: /-- The preimage of a Lie subalgebra under a Lie algebra morphism is a Lie subalgebra of the
domain. -/
def comap : LieSubalgebra R L 
goal: LieSubalgebra R L

full_name: LieSubalgebra.instPartialOrder
code: instance : PartialOrder (LieSubalgebra R L) 
goal: PartialOrder (LieSubalgebra R L)

full_name: LieSubalgebra.le_def
code: theorem le_def : K ≤ K' ↔ (K : Set L) ⊆ K' 
goal: K ≤ K' ↔ ↑K ⊆ ↑K'

full_name: LieSubalgebra.coe_submodule_le_coe_submodule
code: @[simp]
theorem coe_submodule_le_coe_submodule : (K : Submodule R L) ≤ K' ↔ K ≤ K' 
goal: K.toSubmodule ≤ K'.toSubmodule ↔ K ≤ K'

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

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

full_name: LieSubalgebra.bot_coe_submodule
code: @[simp]
theorem bot_coe_submodule : ((⊥ : LieSubalgebra R L) : Submodule R L) = ⊥ 
goal: ⊥.toSubmodule = ⊥

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

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

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

full_name: LieSubalgebra.top_coe_submodule
code: @[simp]
theorem top_coe_submodule : ((⊤ : LieSubalgebra R L) : Submodule R L) = ⊤ 
goal: ⊤.toSubmodule = ⊤

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

full_name: LieHom.range_eq_map
code: theorem _root_.LieHom.range_eq_map : f.range = map f ⊤ 
goal: f.range = LieSubalgebra.map f ⊤

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

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

full_name: LieSubalgebra.inf_coe
code: @[simp]
theorem inf_coe : (↑(K ⊓ K') : Set L) = (K : Set L) ∩ (K' : Set L) 
goal: ↑(K ⊓ K') = ↑K ∩ ↑K'

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

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

full_name: LieSubalgebra.sInf_glb
code: theorem sInf_glb (S : Set (LieSubalgebra R L)) : IsGLB S (sInf S) 
goal: IsGLB S (sInf S)

full_name: LieSubalgebra.completeLattice
code: /-- The set of Lie subalgebras of a Lie algebra 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`. -/
instance completeLattice : CompleteLattice (LieSubalgebra R L) 
goal: CompleteLattice (LieSubalgebra R L)

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

full_name: LieSubalgebra.instZero
code: instance : Zero (LieSubalgebra R L) 
goal: Zero (LieSubalgebra R L)

full_name: LieSubalgebra.addCommMonoid
code: instance addCommMonoid : AddCommMonoid (LieSubalgebra R L) 
goal: AddCommMonoid (LieSubalgebra R L)

full_name: LieSubalgebra.instCanonicallyOrderedAddCommMonoid
code: instance : CanonicallyOrderedAddCommMonoid (LieSubalgebra R L) 
goal: CanonicallyOrderedAddCommMonoid (LieSubalgebra R L)

full_name: LieSubalgebra.add_eq_sup
code: @[simp]
theorem add_eq_sup : K + K' = K ⊔ K' 
goal: K + K' = K ⊔ K'

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

full_name: LieSubalgebra.mem_inf
code: @[simp]
theorem mem_inf (x : L) : x ∈ K ⊓ K' ↔ x ∈ K ∧ x ∈ K' 
goal: x ∈ K ⊓ K' ↔ x ∈ K ∧ x ∈ K'

full_name: LieSubalgebra.eq_bot_iff
code: theorem eq_bot_iff : K = ⊥ ↔ ∀ x : L, x ∈ K → x = 0 
goal: K = ⊥ ↔ ∀ x ∈ K, x = 0

full_name: LieSubalgebra.subsingleton_of_bot
code: instance subsingleton_of_bot : Subsingleton (LieSubalgebra R (⊥ : LieSubalgebra R L)) 
goal: Subsingleton (LieSubalgebra R ↥⊥)

full_name: LieSubalgebra.subsingleton_bot
code: theorem subsingleton_bot : Subsingleton (⊥ : LieSubalgebra R L) 
goal: Subsingleton ↥⊥

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

full_name: LieSubalgebra.inclusion
code: /-- Given two nested Lie subalgebras `K ⊆ K'`, the inclusion `K ↪ K'` is a morphism of Lie
algebras. -/
def inclusion : K →ₗ⁅R⁆ K' 
goal: ↥K →ₗ⁅R⁆ ↥K'

full_name: LieSubalgebra.coe_inclusion
code: @[simp]
theorem coe_inclusion (x : K) : (inclusion h x : L) = x 
goal: ↑((LieSubalgebra.inclusion h) x) = ↑x

full_name: LieSubalgebra.inclusion_apply
code: theorem inclusion_apply (x : K) : inclusion h x = ⟨x.1, h x.2⟩ 
goal: (LieSubalgebra.inclusion h) x = ⟨↑x, ⋯⟩

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

full_name: LieSubalgebra.ofLe
code: /-- Given two nested Lie subalgebras `K ⊆ K'`, we can view `K` as a Lie subalgebra of `K'`,
regarded as Lie algebra in its own right. -/
def ofLe : LieSubalgebra R K' 
goal: LieSubalgebra R ↥K'

full_name: LieSubalgebra.mem_ofLe
code: @[simp]
theorem mem_ofLe (x : K') : x ∈ ofLe h ↔ (x : L) ∈ K 
goal: x ∈ LieSubalgebra.ofLe h ↔ ↑x ∈ K

full_name: LieSubalgebra.ofLe_eq_comap_incl
code: theorem ofLe_eq_comap_incl : ofLe h = K.comap K'.incl 
goal: LieSubalgebra.ofLe h = LieSubalgebra.comap K'.incl K

full_name: LieSubalgebra.coe_ofLe
code: @[simp]
theorem coe_ofLe : (ofLe h : Submodule R K') = LinearMap.range (Submodule.inclusion h) 
goal: (LieSubalgebra.ofLe h).toSubmodule = LinearMap.range (Submodule.inclusion h)

full_name: LieSubalgebra.equivOfLe
code: /-- Given nested Lie subalgebras `K ⊆ K'`, there is a natural equivalence from `K` to its image in
`K'`.  -/
noncomputable def equivOfLe : K ≃ₗ⁅R⁆ ofLe h 
goal: ↥K ≃ₗ⁅R⁆ ↥(LieSubalgebra.ofLe h)

full_name: LieSubalgebra.equivOfLe_apply
code: @[simp]
theorem equivOfLe_apply (x : K) : equivOfLe h x = ⟨inclusion h x, (inclusion h).mem_range_self x⟩ 
goal: (LieSubalgebra.equivOfLe h) x = ⟨(LieSubalgebra.inclusion h) x, ⋯⟩

full_name: LieSubalgebra.map_le_iff_le_comap
code: theorem map_le_iff_le_comap {K : LieSubalgebra R L} {K' : LieSubalgebra R L₂} :
    map f K ≤ K' ↔ K ≤ comap f K' 
goal: LieSubalgebra.map f K ≤ K' ↔ K ≤ LieSubalgebra.comap f K'

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

full_name: LieSubalgebra.lieSpan
code: /-- The Lie subalgebra of a Lie algebra `L` generated by a subset `s ⊆ L`. -/
def lieSpan : LieSubalgebra R L 
goal: LieSubalgebra R L

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

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

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

full_name: LieSubalgebra.lieSpan_le
code: theorem lieSpan_le {K} : lieSpan R L s ≤ K ↔ s ⊆ K 
goal: LieSubalgebra.lieSpan R L s ≤ K ↔ s ⊆ ↑K

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

full_name: LieSubalgebra.lieSpan_eq
code: theorem lieSpan_eq : lieSpan R L (K : Set L) = K 
goal: LieSubalgebra.lieSpan R L ↑K = K

full_name: LieSubalgebra.coe_lieSpan_submodule_eq_iff
code: theorem coe_lieSpan_submodule_eq_iff {p : Submodule R L} :
    (lieSpan R L (p : Set L) : Submodule R L) = p ↔ ∃ K : LieSubalgebra R L, ↑K = p 
goal: (LieSubalgebra.lieSpan R L ↑p).toSubmodule = p ↔ ∃ K, K.toSubmodule = p

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

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

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

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

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

full_name: LieSubalgebra.lieSpan_induction
code: /-- If a predicate `p` is true on some set `s ⊆ L`, true for `0`, stable by scalar multiplication,
by addition and by Lie bracket, then the predicate is true on the Lie span of `s`. (Since `s` can be
empty, and the Lie span always contains `0`, the assumption that `p 0` holds cannot be removed.) -/
@[elab_as_elim]
theorem lieSpan_induction {p : L → Prop} {x : L} (h : x ∈ lieSpan R L s) (mem : ∀ x ∈ s, p x)
    (zero : p 0) (smul : ∀ (r : R), ∀ {x : L}, p x → p (r • x))
    (add : ∀ x y, p x → p y → p (x + y)) (lie : ∀ x y, p x → p y → p ⁅x, y⁆) : p x 
goal: p x

full_name: LieEquiv.ofInjective
code: /-- An injective Lie algebra morphism is an equivalence onto its range. -/
noncomputable def ofInjective (f : L₁ →ₗ⁅R⁆ L₂) (h : Function.Injective f) : L₁ ≃ₗ⁅R⁆ f.range 
goal: L₁ ≃ₗ⁅R⁆ ↥f.range

full_name: LieEquiv.ofInjective_apply
code: @[simp]
theorem ofInjective_apply (f : L₁ →ₗ⁅R⁆ L₂) (h : Function.Injective f) (x : L₁) :
    ↑(ofInjective f h x) = f x 
goal: ↑((LieEquiv.ofInjective f h) x) = f x

full_name: LieEquiv.ofEq
code: /-- Lie subalgebras that are equal as sets are equivalent as Lie algebras. -/
def ofEq (h : (L₁' : Set L₁) = L₁'') : L₁' ≃ₗ⁅R⁆ L₁'' 
goal: ↥L₁' ≃ₗ⁅R⁆ ↥L₁''

full_name: LieEquiv.ofEq_apply
code: @[simp]
theorem ofEq_apply (L L' : LieSubalgebra R L₁) (h : (L : Set L₁) = L') (x : L) :
    (↑(ofEq L L' h x) : L₁) = x 
goal: ↑((LieEquiv.ofEq L L' h) x) = ↑x

full_name: LieEquiv.lieSubalgebraMap
code: /-- An equivalence of Lie algebras restricts to an equivalence from any Lie subalgebra onto its
image. -/
def lieSubalgebraMap : L₁'' ≃ₗ⁅R⁆ (L₁''.map e : LieSubalgebra R L₂) 
goal: ↥L₁'' ≃ₗ⁅R⁆ ↥(LieSubalgebra.map e.toLieHom L₁'')

full_name: LieEquiv.lieSubalgebraMap_apply
code: @[simp]
theorem lieSubalgebraMap_apply (x : L₁'') : ↑(e.lieSubalgebraMap _ x) = e x 
goal: ↑((LieEquiv.lieSubalgebraMap L₁'' e) x) = e ↑x

full_name: LieEquiv.ofSubalgebras
code: /-- An equivalence of Lie algebras restricts to an equivalence from any Lie subalgebra onto its
image. -/
def ofSubalgebras (h : L₁'.map ↑e = L₂') : L₁' ≃ₗ⁅R⁆ L₂' 
goal: ↥L₁' ≃ₗ⁅R⁆ ↥L₂'

full_name: LieEquiv.ofSubalgebras_apply
code: @[simp]
theorem ofSubalgebras_apply (h : L₁'.map ↑e = L₂') (x : L₁') : ↑(e.ofSubalgebras _ _ h x) = e x 
goal: ↑((LieEquiv.ofSubalgebras L₁' L₂' e h) x) = e ↑x

full_name: LieEquiv.ofSubalgebras_symm_apply
code: @[simp]
theorem ofSubalgebras_symm_apply (h : L₁'.map ↑e = L₂') (x : L₂') :
    ↑((e.ofSubalgebras _ _ h).symm x) = e.symm x 
goal: ↑((LieEquiv.ofSubalgebras L₁' L₂' e h).symm x) = e.symm ↑x