File: Mathlib/Algebra/Lie/Abelian.lean

full_name: LieModule.IsTrivial.trivial
code: /-- A Lie (ring) module is trivial iff all brackets vanish. -/
class LieModule.IsTrivial (L : Type v) (M : Type w) [Bracket L M] [Zero M] : Prop where
  trivial : ∀ (x : L) (m : M), ⁅x, m⁆ = 0
goal: ⁅x, m⁆ = 0

full_name: LieModule.IsTrivial
code: /-- A Lie (ring) module is trivial iff all brackets vanish. -/
class LieModule.IsTrivial (L : Type v) (M : Type w) [Bracket L M] [Zero M] : Prop where
  trivial : ∀ (x : L) (m : M), ⁅x, m⁆ = 0
goal: Prop

full_name: trivial_lie_zero
code: @[simp]
theorem trivial_lie_zero (L : Type v) (M : Type w) [Bracket L M] [Zero M] [LieModule.IsTrivial L M]
    (x : L) (m : M) : ⁅x, m⁆ = 0 
goal: ⁅x, m⁆ = 0

full_name: LieModule.instIsTrivialOfSubsingleton
code: instance LieModule.instIsTrivialOfSubsingleton {L M : Type*}
    [LieRing L] [AddCommGroup M] [LieRingModule L M] [Subsingleton L] : LieModule.IsTrivial L M 
goal: LieModule.IsTrivial L M

full_name: LieModule.instIsTrivialOfSubsingleton'
code: instance LieModule.instIsTrivialOfSubsingleton' {L M : Type*}
    [LieRing L] [AddCommGroup M] [LieRingModule L M] [Subsingleton M] : LieModule.IsTrivial L M 
goal: LieModule.IsTrivial L M

full_name: IsLieAbelian
code: /-- A Lie algebra is Abelian iff it is trivial as a Lie module over itself. -/
abbrev IsLieAbelian (L : Type v) [Bracket L L] [Zero L] : Prop 
goal: Prop

full_name: LieIdeal.isLieAbelian_of_trivial
code: instance LieIdeal.isLieAbelian_of_trivial (R : Type u) (L : Type v) [CommRing R] [LieRing L]
    [LieAlgebra R L] (I : LieIdeal R L) [h : LieModule.IsTrivial L I] : IsLieAbelian I 
goal: IsLieAbelian ↥↑I

full_name: Function.Injective.isLieAbelian
code: theorem Function.Injective.isLieAbelian {R : Type u} {L₁ : Type v} {L₂ : Type w} [CommRing R]
    [LieRing L₁] [LieRing L₂] [LieAlgebra R L₁] [LieAlgebra R L₂] {f : L₁ →ₗ⁅R⁆ L₂}
    (h₁ : Function.Injective f) (_ : IsLieAbelian L₂) : IsLieAbelian L₁ 
goal: IsLieAbelian L₂ → IsLieAbelian L₁

full_name: Function.Surjective.isLieAbelian
code: theorem Function.Surjective.isLieAbelian {R : Type u} {L₁ : Type v} {L₂ : Type w} [CommRing R]
    [LieRing L₁] [LieRing L₂] [LieAlgebra R L₁] [LieAlgebra R L₂] {f : L₁ →ₗ⁅R⁆ L₂}
    (h₁ : Function.Surjective f) (h₂ : IsLieAbelian L₁) : IsLieAbelian L₂ 
goal: IsLieAbelian L₂

full_name: lie_abelian_iff_equiv_lie_abelian
code: theorem lie_abelian_iff_equiv_lie_abelian {R : Type u} {L₁ : Type v} {L₂ : Type w} [CommRing R]
    [LieRing L₁] [LieRing L₂] [LieAlgebra R L₁] [LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂) :
    IsLieAbelian L₁ ↔ IsLieAbelian L₂ 
goal: IsLieAbelian L₁ ↔ IsLieAbelian L₂

full_name: commutative_ring_iff_abelian_lie_ring
code: theorem commutative_ring_iff_abelian_lie_ring {A : Type v} [Ring A] :
    Std.Commutative (α := A) (· * ·) ↔ IsLieAbelian A 
goal: (Std.Commutative fun x x_1 => x * x_1) ↔ IsLieAbelian A

full_name: LieModule.ker
code: /-- The kernel of the action of a Lie algebra `L` on a Lie module `M` as a Lie ideal in `L`. -/
protected def ker : LieIdeal R L 
goal: LieIdeal R L

full_name: LieModule.mem_ker
code: @[simp]
protected theorem mem_ker (x : L) : x ∈ LieModule.ker R L M ↔ ∀ m : M, ⁅x, m⁆ = 0 
goal: x ∈ LieModule.ker R L M ↔ ∀ (m : M), ⁅x, m⁆ = 0

full_name: LieModule.maxTrivSubmodule
code: /-- The largest submodule of a Lie module `M` on which the Lie algebra `L` acts trivially. -/
def maxTrivSubmodule : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieModule.mem_maxTrivSubmodule
code: @[simp]
theorem mem_maxTrivSubmodule (m : M) : m ∈ maxTrivSubmodule R L M ↔ ∀ x : L, ⁅x, m⁆ = 0 
goal: m ∈ LieModule.maxTrivSubmodule R L M ↔ ∀ (x : L), ⁅x, m⁆ = 0

full_name: LieModule.instIsTrivialSubtypeMemSubmoduleMaxTrivSubmodule
code: instance : IsTrivial L (maxTrivSubmodule R L M) 
goal: LieModule.IsTrivial L ↥↑(LieModule.maxTrivSubmodule R L M)

full_name: LieModule.ideal_oper_maxTrivSubmodule_eq_bot
code: @[simp]
theorem ideal_oper_maxTrivSubmodule_eq_bot (I : LieIdeal R L) :
    ⁅I, maxTrivSubmodule R L M⁆ = ⊥ 
goal: ⁅I, LieModule.maxTrivSubmodule R L M⁆ = ⊥

full_name: LieModule.le_max_triv_iff_bracket_eq_bot
code: theorem le_max_triv_iff_bracket_eq_bot {N : LieSubmodule R L M} :
    N ≤ maxTrivSubmodule R L M ↔ ⁅(⊤ : LieIdeal R L), N⁆ = ⊥ 
goal: N ≤ LieModule.maxTrivSubmodule R L M ↔ ⁅⊤, N⁆ = ⊥

full_name: LieModule.trivial_iff_le_maximal_trivial
code: theorem trivial_iff_le_maximal_trivial (N : LieSubmodule R L M) :
    IsTrivial L N ↔ N ≤ maxTrivSubmodule R L M 
goal: LieModule.IsTrivial L ↥↑N ↔ N ≤ LieModule.maxTrivSubmodule R L M

full_name: LieModule.isTrivial_iff_max_triv_eq_top
code: theorem isTrivial_iff_max_triv_eq_top : IsTrivial L M ↔ maxTrivSubmodule R L M = ⊤ 
goal: LieModule.IsTrivial L M ↔ LieModule.maxTrivSubmodule R L M = ⊤

full_name: LieModule.maxTrivHom
code: /-- `maxTrivSubmodule` is functorial. -/
def maxTrivHom (f : M →ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M →ₗ⁅R,L⁆ maxTrivSubmodule R L N 
goal: ↥↑(LieModule.maxTrivSubmodule R L M) →ₗ⁅R,L⁆ ↥↑(LieModule.maxTrivSubmodule R L N)

full_name: LieModule.coe_maxTrivHom_apply
code: @[norm_cast, simp]
theorem coe_maxTrivHom_apply (f : M →ₗ⁅R,L⁆ N) (m : maxTrivSubmodule R L M) :
    (maxTrivHom f m : N) = f m 
goal: ↑((LieModule.maxTrivHom f) m) = f ↑m

full_name: LieModule.maxTrivEquiv
code: /-- The maximal trivial submodules of Lie-equivalent Lie modules are Lie-equivalent. -/
def maxTrivEquiv (e : M ≃ₗ⁅R,L⁆ N) : maxTrivSubmodule R L M ≃ₗ⁅R,L⁆ maxTrivSubmodule R L N 
goal: ↥↑(LieModule.maxTrivSubmodule R L M) ≃ₗ⁅R,L⁆ ↥↑(LieModule.maxTrivSubmodule R L N)

full_name: LieModule.coe_maxTrivEquiv_apply
code: @[norm_cast, simp]
theorem coe_maxTrivEquiv_apply (e : M ≃ₗ⁅R,L⁆ N) (m : maxTrivSubmodule R L M) :
    (maxTrivEquiv e m : N) = e ↑m 
goal: ↑((LieModule.maxTrivEquiv e) m) = e ↑m

full_name: LieModule.maxTrivEquiv_of_refl_eq_refl
code: @[simp]
theorem maxTrivEquiv_of_refl_eq_refl :
    maxTrivEquiv (LieModuleEquiv.refl : M ≃ₗ⁅R,L⁆ M) = LieModuleEquiv.refl 
goal: LieModule.maxTrivEquiv LieModuleEquiv.refl = LieModuleEquiv.refl

full_name: LieModule.maxTrivEquiv_of_equiv_symm_eq_symm
code: @[simp]
theorem maxTrivEquiv_of_equiv_symm_eq_symm (e : M ≃ₗ⁅R,L⁆ N) :
    (maxTrivEquiv e).symm = maxTrivEquiv e.symm 
goal: (LieModule.maxTrivEquiv e).symm = LieModule.maxTrivEquiv e.symm

full_name: LieModule.maxTrivLinearMapEquivLieModuleHom
code: /-- A linear map between two Lie modules is a morphism of Lie modules iff the Lie algebra action
on it is trivial. -/
def maxTrivLinearMapEquivLieModuleHom : maxTrivSubmodule R L (M →ₗ[R] N) ≃ₗ[R] M →ₗ⁅R,L⁆ N 
goal: ↥↑(LieModule.maxTrivSubmodule R L (M →ₗ[R] N)) ≃ₗ[R] M →ₗ⁅R,L⁆ N

full_name: LieModule.coe_maxTrivLinearMapEquivLieModuleHom
code: @[simp]
theorem coe_maxTrivLinearMapEquivLieModuleHom (f : maxTrivSubmodule R L (M →ₗ[R] N)) :
    (maxTrivLinearMapEquivLieModuleHom f : M → N) = f 
goal: ⇑(LieModule.maxTrivLinearMapEquivLieModuleHom f) = ⇑↑f

full_name: LieModule.coe_maxTrivLinearMapEquivLieModuleHom_symm
code: @[simp]
theorem coe_maxTrivLinearMapEquivLieModuleHom_symm (f : M →ₗ⁅R,L⁆ N) :
    (maxTrivLinearMapEquivLieModuleHom.symm f : M → N) = f 
goal: ⇑↑(LieModule.maxTrivLinearMapEquivLieModuleHom.symm f) = ⇑f

full_name: LieModule.coe_linearMap_maxTrivLinearMapEquivLieModuleHom
code: @[simp]
theorem coe_linearMap_maxTrivLinearMapEquivLieModuleHom (f : maxTrivSubmodule R L (M →ₗ[R] N)) :
    (maxTrivLinearMapEquivLieModuleHom f : M →ₗ[R] N) = (f : M →ₗ[R] N) 
goal: ↑(LieModule.maxTrivLinearMapEquivLieModuleHom f) = ↑f

full_name: LieModule.coe_linearMap_maxTrivLinearMapEquivLieModuleHom_symm
code: @[simp]
theorem coe_linearMap_maxTrivLinearMapEquivLieModuleHom_symm (f : M →ₗ⁅R,L⁆ N) :
    (maxTrivLinearMapEquivLieModuleHom.symm f : M →ₗ[R] N) = (f : M →ₗ[R] N) 
goal: ↑(LieModule.maxTrivLinearMapEquivLieModuleHom.symm f) = ↑f

full_name: LieAlgebra.center
code: /-- The center of a Lie algebra is the set of elements that commute with everything. It can
be viewed as the maximal trivial submodule of the Lie algebra as a Lie module over itself via the
adjoint representation. -/
abbrev center : LieIdeal R L 
goal: LieIdeal R L

full_name: LieAlgebra.instIsLieAbelianSubtypeMemSubmoduleCenter
code: instance : IsLieAbelian (center R L) 
goal: IsLieAbelian ↥↑(LieAlgebra.center R L)

full_name: LieAlgebra.ad_ker_eq_self_module_ker
code: @[simp]
theorem ad_ker_eq_self_module_ker : (ad R L).ker = LieModule.ker R L L 
goal: (LieAlgebra.ad R L).ker = LieModule.ker R L L

full_name: LieAlgebra.self_module_ker_eq_center
code: @[simp]
theorem self_module_ker_eq_center : LieModule.ker R L L = center R L 
goal: LieModule.ker R L L = LieAlgebra.center R L

full_name: LieAlgebra.abelian_of_le_center
code: theorem abelian_of_le_center (I : LieIdeal R L) (h : I ≤ center R L) : IsLieAbelian I 
goal: IsLieAbelian ↥↑I

full_name: LieAlgebra.isLieAbelian_iff_center_eq_top
code: theorem isLieAbelian_iff_center_eq_top : IsLieAbelian L ↔ center R L = ⊤ 
goal: IsLieAbelian L ↔ LieAlgebra.center R L = ⊤

full_name: LieModule.commute_toEnd_of_mem_center_left
code: lemma commute_toEnd_of_mem_center_left :
    Commute (toEnd R L M x) (toEnd R L M y) 
goal: Commute ((LieModule.toEnd R L M) x) ((LieModule.toEnd R L M) y)

full_name: LieModule.commute_toEnd_of_mem_center_right
code: lemma commute_toEnd_of_mem_center_right :
    Commute (toEnd R L M y) (toEnd R L M x) 
goal: Commute ((LieModule.toEnd R L M) y) ((LieModule.toEnd R L M) x)

full_name: LieSubmodule.trivial_lie_oper_zero
code: @[simp]
theorem LieSubmodule.trivial_lie_oper_zero [LieModule.IsTrivial L M] : ⁅I, N⁆ = ⊥ 
goal: ⁅I, N⁆ = ⊥

full_name: LieSubmodule.lie_abelian_iff_lie_self_eq_bot
code: theorem LieSubmodule.lie_abelian_iff_lie_self_eq_bot : IsLieAbelian I ↔ ⁅I, I⁆ = ⊥ 
goal: IsLieAbelian ↥↑I ↔ ⁅I, I⁆ = ⊥

full_name: lie_eq_self_of_isAtom_of_ne_bot
code: lemma lie_eq_self_of_isAtom_of_ne_bot (hN : IsAtom N) (h : ⁅I, N⁆ ≠ ⊥) : ⁅I, N⁆ = N 
goal: ⁅I, N⁆ = N

full_name: lie_eq_self_of_isAtom_of_nonabelian
code: lemma lie_eq_self_of_isAtom_of_nonabelian {R L : Type*} [CommRing R] [LieRing L] [LieAlgebra R L]
    (I : LieIdeal R L) (hI : IsAtom I) (h : ¬IsLieAbelian I) :
    ⁅I, I⁆ = I 
goal: ⁅I, I⁆ = I