File: Mathlib/Algebra/Lie/Nilpotent.lean

full_name: LieSubmodule.lcs
code: /-- A generalisation of the lower central series. The zeroth term is a specified Lie submodule of
a Lie module. In the case when we specify the top ideal `⊤` of the Lie algebra, regarded as a Lie
module over itself, we get the usual lower central series of a Lie algebra.

It can be more convenient to work with this generalisation when considering the lower central series
of a Lie submodule, regarded as a Lie module in its own right, since it provides a type-theoretic
expression of the fact that the terms of the Lie submodule's lower central series are also Lie
submodules of the enclosing Lie module.

See also `LieSubmodule.lowerCentralSeries_eq_lcs_comap` and
`LieSubmodule.lowerCentralSeries_map_eq_lcs` below, as well as `LieSubmodule.ucs`. -/
def lcs : LieSubmodule R L M → LieSubmodule R L M 
goal: LieSubmodule R L M → LieSubmodule R L M

full_name: LieSubmodule.lcs_zero
code: @[simp]
theorem lcs_zero (N : LieSubmodule R L M) : N.lcs 0 = N 
goal: LieSubmodule.lcs 0 N = N

full_name: LieSubmodule.lcs_succ
code: @[simp]
theorem lcs_succ : N.lcs (k + 1) = ⁅(⊤ : LieIdeal R L), N.lcs k⁆ 
goal: LieSubmodule.lcs (k + 1) N = ⁅⊤, LieSubmodule.lcs k N⁆

full_name: LieSubmodule.lcs_sup
code: @[simp]
lemma lcs_sup {N₁ N₂ : LieSubmodule R L M} {k : ℕ} :
    (N₁ ⊔ N₂).lcs k = N₁.lcs k ⊔ N₂.lcs k 
goal: LieSubmodule.lcs k (N₁ ⊔ N₂) = LieSubmodule.lcs k N₁ ⊔ LieSubmodule.lcs k N₂

full_name: LieModule.lowerCentralSeries
code: /-- The lower central series of Lie submodules of a Lie module. -/
def lowerCentralSeries : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieModule.lowerCentralSeries_zero
code: @[simp]
theorem lowerCentralSeries_zero : lowerCentralSeries R L M 0 = ⊤ 
goal: LieModule.lowerCentralSeries R L M 0 = ⊤

full_name: LieModule.lowerCentralSeries_succ
code: @[simp]
theorem lowerCentralSeries_succ :
    lowerCentralSeries R L M (k + 1) = ⁅(⊤ : LieIdeal R L), lowerCentralSeries R L M k⁆ 
goal: LieModule.lowerCentralSeries R L M (k + 1) = ⁅⊤, LieModule.lowerCentralSeries R L M k⁆

full_name: LieSubmodule.lcs_le_self
code: theorem lcs_le_self : N.lcs k ≤ N 
goal: LieSubmodule.lcs k N ≤ N

full_name: LieSubmodule.lowerCentralSeries_eq_lcs_comap
code: theorem lowerCentralSeries_eq_lcs_comap : lowerCentralSeries R L N k = (N.lcs k).comap N.incl 
goal: LieModule.lowerCentralSeries R L (↥↑N) k = LieSubmodule.comap N.incl (LieSubmodule.lcs k N)

full_name: LieSubmodule.lowerCentralSeries_map_eq_lcs
code: theorem lowerCentralSeries_map_eq_lcs : (lowerCentralSeries R L N k).map N.incl = N.lcs k 
goal: LieSubmodule.map N.incl (LieModule.lowerCentralSeries R L (↥↑N) k) = LieSubmodule.lcs k N

full_name: LieModule.antitone_lowerCentralSeries
code: theorem antitone_lowerCentralSeries : Antitone <| lowerCentralSeries R L M 
goal: Antitone (LieModule.lowerCentralSeries R L M)

full_name: LieModule.eventually_iInf_lowerCentralSeries_eq
code: theorem eventually_iInf_lowerCentralSeries_eq [IsArtinian R M] :
    ∀ᶠ l in Filter.atTop, ⨅ k, lowerCentralSeries R L M k = lowerCentralSeries R L M l 
goal: ∀ᶠ (l : ℕ) in Filter.atTop, ⨅ k, LieModule.lowerCentralSeries R L M k = LieModule.lowerCentralSeries R L M l

full_name: LieModule.trivial_iff_lower_central_eq_bot
code: theorem trivial_iff_lower_central_eq_bot : IsTrivial L M ↔ lowerCentralSeries R L M 1 = ⊥ 
goal: LieModule.IsTrivial L M ↔ LieModule.lowerCentralSeries R L M 1 = ⊥

full_name: LieModule.iterate_toEnd_mem_lowerCentralSeries
code: theorem iterate_toEnd_mem_lowerCentralSeries (x : L) (m : M) (k : ℕ) :
    (toEnd R L M x)^[k] m ∈ lowerCentralSeries R L M k 
goal: (⇑((LieModule.toEnd R L M) x))^[k] m ∈ LieModule.lowerCentralSeries R L M k

full_name: LieModule.iterate_toEnd_mem_lowerCentralSeries₂
code: theorem iterate_toEnd_mem_lowerCentralSeries₂ (x y : L) (m : M) (k : ℕ) :
    (toEnd R L M x ∘ₗ toEnd R L M y)^[k] m ∈
      lowerCentralSeries R L M (2 * k) 
goal: (⇑((LieModule.toEnd R L M) x ∘ₗ (LieModule.toEnd R L M) y))^[k] m ∈ LieModule.lowerCentralSeries R L M (2 * k)

full_name: LieModule.map_lowerCentralSeries_le
code: theorem map_lowerCentralSeries_le (f : M →ₗ⁅R,L⁆ M₂) :
    (lowerCentralSeries R L M k).map f ≤ lowerCentralSeries R L M₂ k 
goal: LieSubmodule.map f (LieModule.lowerCentralSeries R L M k) ≤ LieModule.lowerCentralSeries R L M₂ k

full_name: LieModule.map_lowerCentralSeries_eq
code: lemma map_lowerCentralSeries_eq {f : M →ₗ⁅R,L⁆ M₂} (hf : Function.Surjective f) :
    (lowerCentralSeries R L M k).map f = lowerCentralSeries R L M₂ k 
goal: LieSubmodule.map f (LieModule.lowerCentralSeries R L M k) = LieModule.lowerCentralSeries R L M₂ k

full_name: LieModule.derivedSeries_le_lowerCentralSeries
code: theorem derivedSeries_le_lowerCentralSeries (k : ℕ) :
    derivedSeries R L k ≤ lowerCentralSeries R L L k 
goal: LieAlgebra.derivedSeries R L k ≤ LieModule.lowerCentralSeries R L L k

full_name: LieModule.IsNilpotent
code: /-- A Lie module is nilpotent if its lower central series reaches 0 (in a finite number of
steps). -/
class IsNilpotent : Prop where
  nilpotent : ∃ k, lowerCentralSeries R L M k = ⊥
goal: Prop

full_name: LieModule.IsNilpotent.nilpotent
code: /-- A Lie module is nilpotent if its lower central series reaches 0 (in a finite number of
steps). -/
class IsNilpotent : Prop where
  nilpotent : ∃ k, lowerCentralSeries R L M k = ⊥
goal: ∃ k, LieModule.lowerCentralSeries R L M k = ⊥

full_name: LieModule.exists_lowerCentralSeries_eq_bot_of_isNilpotent
code: theorem exists_lowerCentralSeries_eq_bot_of_isNilpotent [IsNilpotent R L M] :
    ∃ k, lowerCentralSeries R L M k = ⊥ 
goal: ∃ k, LieModule.lowerCentralSeries R L M k = ⊥

full_name: LieModule.iInf_lowerCentralSeries_eq_bot_of_isNilpotent
code: @[simp] lemma iInf_lowerCentralSeries_eq_bot_of_isNilpotent [IsNilpotent R L M] :
    ⨅ k, lowerCentralSeries R L M k = ⊥ 
goal: ⨅ k, LieModule.lowerCentralSeries R L M k = ⊥

full_name: LieModule.isNilpotent_iff
code: /-- See also `LieModule.isNilpotent_iff_exists_ucs_eq_top`. -/
theorem isNilpotent_iff : IsNilpotent R L M ↔ ∃ k, lowerCentralSeries R L M k = ⊥ 
goal: LieModule.IsNilpotent R L M ↔ ∃ k, LieModule.lowerCentralSeries R L M k = ⊥

full_name: LieSubmodule.isNilpotent_iff_exists_lcs_eq_bot
code: theorem _root_.LieSubmodule.isNilpotent_iff_exists_lcs_eq_bot (N : LieSubmodule R L M) :
    LieModule.IsNilpotent R L N ↔ ∃ k, N.lcs k = ⊥ 
goal: LieModule.IsNilpotent R L ↥↑N ↔ ∃ k, LieSubmodule.lcs k N = ⊥

full_name: LieModule.trivialIsNilpotent
code: instance (priority := 100) trivialIsNilpotent [IsTrivial L M] : IsNilpotent R L M 
goal: LieModule.IsNilpotent R L M

full_name: LieModule.exists_forall_pow_toEnd_eq_zero
code: theorem exists_forall_pow_toEnd_eq_zero [hM : IsNilpotent R L M] :
    ∃ k : ℕ, ∀ x : L, toEnd R L M x ^ k = 0 
goal: ∃ k, ∀ (x : L), (LieModule.toEnd R L M) x ^ k = 0

full_name: LieModule.isNilpotent_toEnd_of_isNilpotent
code: theorem isNilpotent_toEnd_of_isNilpotent [IsNilpotent R L M] (x : L) :
    _root_.IsNilpotent (toEnd R L M x) 
goal: IsNilpotent ((LieModule.toEnd R L M) x)

full_name: LieModule.isNilpotent_toEnd_of_isNilpotent₂
code: theorem isNilpotent_toEnd_of_isNilpotent₂ [IsNilpotent R L M] (x y : L) :
    _root_.IsNilpotent (toEnd R L M x ∘ₗ toEnd R L M y) 
goal: IsNilpotent ((LieModule.toEnd R L M) x ∘ₗ (LieModule.toEnd R L M) y)

full_name: LieModule.maxGenEigenSpace_toEnd_eq_top
code: @[simp] lemma maxGenEigenSpace_toEnd_eq_top [IsNilpotent R L M] (x : L) :
    ((toEnd R L M x).maxGenEigenspace 0) = ⊤ 
goal: ((LieModule.toEnd R L M) x).maxGenEigenspace 0 = ⊤

full_name: LieModule.nilpotentOfNilpotentQuotient
code: /-- If the quotient of a Lie module `M` by a Lie submodule on which the Lie algebra acts trivially
is nilpotent then `M` is nilpotent.

This is essentially the Lie module equivalent of the fact that a central
extension of nilpotent Lie algebras is nilpotent. See `LieAlgebra.nilpotent_of_nilpotent_quotient`
below for the corresponding result for Lie algebras. -/
theorem nilpotentOfNilpotentQuotient {N : LieSubmodule R L M} (h₁ : N ≤ maxTrivSubmodule R L M)
    (h₂ : IsNilpotent R L (M ⧸ N)) : IsNilpotent R L M 
goal: LieModule.IsNilpotent R L M

full_name: LieModule.isNilpotent_quotient_iff
code: theorem isNilpotent_quotient_iff :
    IsNilpotent R L (M ⧸ N) ↔ ∃ k, lowerCentralSeries R L M k ≤ N 
goal: LieModule.IsNilpotent R L (M ⧸ N) ↔ ∃ k, LieModule.lowerCentralSeries R L M k ≤ N

full_name: LieModule.iInf_lcs_le_of_isNilpotent_quot
code: theorem iInf_lcs_le_of_isNilpotent_quot (h : IsNilpotent R L (M ⧸ N)) :
    ⨅ k, lowerCentralSeries R L M k ≤ N 
goal: ⨅ k, LieModule.lowerCentralSeries R L M k ≤ N

full_name: LieModule.nilpotencyLength
code: /-- Given a nilpotent Lie module `M` with lower central series `M = C₀ ≥ C₁ ≥ ⋯ ≥ Cₖ = ⊥`, this is
the natural number `k` (the number of inclusions).

For a non-nilpotent module, we use the junk value 0. -/
noncomputable def nilpotencyLength : ℕ 
goal: ℕ

full_name: LieModule.nilpotencyLength_eq_zero_iff
code: @[simp]
theorem nilpotencyLength_eq_zero_iff [IsNilpotent R L M] :
    nilpotencyLength R L M = 0 ↔ Subsingleton M 
goal: LieModule.nilpotencyLength R L M = 0 ↔ Subsingleton M

full_name: LieModule.nilpotencyLength_eq_succ_iff
code: theorem nilpotencyLength_eq_succ_iff (k : ℕ) :
    nilpotencyLength R L M = k + 1 ↔
      lowerCentralSeries R L M (k + 1) = ⊥ ∧ lowerCentralSeries R L M k ≠ ⊥ 
goal: LieModule.nilpotencyLength R L M = k + 1 ↔
  LieModule.lowerCentralSeries R L M (k + 1) = ⊥ ∧ LieModule.lowerCentralSeries R L M k ≠ ⊥

full_name: LieModule.nilpotencyLength_eq_one_iff
code: @[simp]
theorem nilpotencyLength_eq_one_iff [Nontrivial M] :
    nilpotencyLength R L M = 1 ↔ IsTrivial L M 
goal: LieModule.nilpotencyLength R L M = 1 ↔ LieModule.IsTrivial L M

full_name: LieModule.isTrivial_of_nilpotencyLength_le_one
code: theorem isTrivial_of_nilpotencyLength_le_one [IsNilpotent R L M] (h : nilpotencyLength R L M ≤ 1) :
    IsTrivial L M 
goal: LieModule.IsTrivial L M

full_name: LieModule.lowerCentralSeriesLast
code: /-- Given a non-trivial nilpotent Lie module `M` with lower central series
`M = C₀ ≥ C₁ ≥ ⋯ ≥ Cₖ = ⊥`, this is the `k-1`th term in the lower central series (the last
non-trivial term).

For a trivial or non-nilpotent module, this is the bottom submodule, `⊥`. -/
noncomputable def lowerCentralSeriesLast : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieModule.lowerCentralSeriesLast_le_max_triv
code: theorem lowerCentralSeriesLast_le_max_triv :
    lowerCentralSeriesLast R L M ≤ maxTrivSubmodule R L M 
goal: LieModule.lowerCentralSeriesLast R L M ≤ LieModule.maxTrivSubmodule R L M

full_name: LieModule.nontrivial_lowerCentralSeriesLast
code: theorem nontrivial_lowerCentralSeriesLast [Nontrivial M] [IsNilpotent R L M] :
    Nontrivial (lowerCentralSeriesLast R L M) 
goal: Nontrivial ↥↑(LieModule.lowerCentralSeriesLast R L M)

full_name: LieModule.lowerCentralSeriesLast_le_of_not_isTrivial
code: theorem lowerCentralSeriesLast_le_of_not_isTrivial [IsNilpotent R L M] (h : ¬ IsTrivial L M) :
    lowerCentralSeriesLast R L M ≤ lowerCentralSeries R L M 1 
goal: LieModule.lowerCentralSeriesLast R L M ≤ LieModule.lowerCentralSeries R L M 1

full_name: LieModule.disjoint_lowerCentralSeries_maxTrivSubmodule_iff
code: /-- For a nilpotent Lie module `M` of a Lie algebra `L`, the first term in the lower central series
of `M` contains a non-zero element on which `L` acts trivially unless the entire action is trivial.

Taking `M = L`, this provides a useful characterisation of Abelian-ness for nilpotent Lie
algebras. -/
lemma disjoint_lowerCentralSeries_maxTrivSubmodule_iff [IsNilpotent R L M] :
    Disjoint (lowerCentralSeries R L M 1) (maxTrivSubmodule R L M) ↔ IsTrivial L M 
goal: Disjoint (LieModule.lowerCentralSeries R L M 1) (LieModule.maxTrivSubmodule R L M) ↔ LieModule.IsTrivial L M

full_name: LieModule.nontrivial_max_triv_of_isNilpotent
code: theorem nontrivial_max_triv_of_isNilpotent [Nontrivial M] [IsNilpotent R L M] :
    Nontrivial (maxTrivSubmodule R L M) 
goal: Nontrivial ↥↑(LieModule.maxTrivSubmodule R L M)

full_name: LieModule.coe_lcs_range_toEnd_eq
code: @[simp]
theorem coe_lcs_range_toEnd_eq (k : ℕ) :
    (lowerCentralSeries R (toEnd R L M).range M k : Submodule R M) =
      lowerCentralSeries R L M k 
goal: ↑(LieModule.lowerCentralSeries R (↥(LieModule.toEnd R L M).range) M k) = ↑(LieModule.lowerCentralSeries R L M k)

full_name: LieModule.isNilpotent_range_toEnd_iff
code: @[simp]
theorem isNilpotent_range_toEnd_iff :
    IsNilpotent R (toEnd R L M).range M ↔ IsNilpotent R L M 
goal: LieModule.IsNilpotent R (↥(LieModule.toEnd R L M).range) M ↔ LieModule.IsNilpotent R L M

full_name: LieSubmodule.ucs
code: /-- The upper (aka ascending) central series.

See also `LieSubmodule.lcs`. -/
def ucs (k : ℕ) : LieSubmodule R L M → LieSubmodule R L M 
goal: LieSubmodule R L M → LieSubmodule R L M

full_name: LieSubmodule.ucs_zero
code: @[simp]
theorem ucs_zero : N.ucs 0 = N 
goal: LieSubmodule.ucs 0 N = N

full_name: LieSubmodule.ucs_succ
code: @[simp]
theorem ucs_succ (k : ℕ) : N.ucs (k + 1) = (N.ucs k).normalizer 
goal: LieSubmodule.ucs (k + 1) N = (LieSubmodule.ucs k N).normalizer

full_name: LieSubmodule.ucs_add
code: theorem ucs_add (k l : ℕ) : N.ucs (k + l) = (N.ucs l).ucs k 
goal: LieSubmodule.ucs (k + l) N = LieSubmodule.ucs k (LieSubmodule.ucs l N)

full_name: LieSubmodule.ucs_mono
code: @[gcongr, mono]
theorem ucs_mono (k : ℕ) (h : N₁ ≤ N₂) : N₁.ucs k ≤ N₂.ucs k 
goal: LieSubmodule.ucs k N₁ ≤ LieSubmodule.ucs k N₂

full_name: LieSubmodule.ucs_eq_self_of_normalizer_eq_self
code: theorem ucs_eq_self_of_normalizer_eq_self (h : N₁.normalizer = N₁) (k : ℕ) : N₁.ucs k = N₁ 
goal: LieSubmodule.ucs k N₁ = N₁

full_name: LieSubmodule.ucs_le_of_normalizer_eq_self
code: /-- If a Lie module `M` contains a self-normalizing Lie submodule `N`, then all terms of the upper
central series of `M` are contained in `N`.

An important instance of this situation arises from a Cartan subalgebra `H ⊆ L` with the roles of
`L`, `M`, `N` played by `H`, `L`, `H`, respectively. -/
theorem ucs_le_of_normalizer_eq_self (h : N₁.normalizer = N₁) (k : ℕ) :
    (⊥ : LieSubmodule R L M).ucs k ≤ N₁ 
goal: LieSubmodule.ucs k ⊥ ≤ N₁

full_name: LieSubmodule.lcs_add_le_iff
code: theorem lcs_add_le_iff (l k : ℕ) : N₁.lcs (l + k) ≤ N₂ ↔ N₁.lcs l ≤ N₂.ucs k 
goal: LieSubmodule.lcs (l + k) N₁ ≤ N₂ ↔ LieSubmodule.lcs l N₁ ≤ LieSubmodule.ucs k N₂

full_name: LieSubmodule.lcs_le_iff
code: theorem lcs_le_iff (k : ℕ) : N₁.lcs k ≤ N₂ ↔ N₁ ≤ N₂.ucs k 
goal: LieSubmodule.lcs k N₁ ≤ N₂ ↔ N₁ ≤ LieSubmodule.ucs k N₂

full_name: LieSubmodule.gc_lcs_ucs
code: theorem gc_lcs_ucs (k : ℕ) :
    GaloisConnection (fun N : LieSubmodule R L M => N.lcs k) fun N : LieSubmodule R L M =>
      N.ucs k 
goal: GaloisConnection (fun N => LieSubmodule.lcs k N) fun N => LieSubmodule.ucs k N

full_name: LieSubmodule.ucs_eq_top_iff
code: theorem ucs_eq_top_iff (k : ℕ) : N.ucs k = ⊤ ↔ LieModule.lowerCentralSeries R L M k ≤ N 
goal: LieSubmodule.ucs k N = ⊤ ↔ LieModule.lowerCentralSeries R L M k ≤ N

full_name: LieModule.isNilpotent_iff_exists_ucs_eq_top
code: theorem _root_.LieModule.isNilpotent_iff_exists_ucs_eq_top :
    LieModule.IsNilpotent R L M ↔ ∃ k, (⊥ : LieSubmodule R L M).ucs k = ⊤ 
goal: LieModule.IsNilpotent R L M ↔ ∃ k, LieSubmodule.ucs k ⊥ = ⊤

full_name: LieSubmodule.ucs_comap_incl
code: theorem ucs_comap_incl (k : ℕ) :
    ((⊥ : LieSubmodule R L M).ucs k).comap N.incl = (⊥ : LieSubmodule R L N).ucs k 
goal: LieSubmodule.comap N.incl (LieSubmodule.ucs k ⊥) = LieSubmodule.ucs k ⊥

full_name: LieSubmodule.isNilpotent_iff_exists_self_le_ucs
code: theorem isNilpotent_iff_exists_self_le_ucs :
    LieModule.IsNilpotent R L N ↔ ∃ k, N ≤ (⊥ : LieSubmodule R L M).ucs k 
goal: LieModule.IsNilpotent R L ↥↑N ↔ ∃ k, N ≤ LieSubmodule.ucs k ⊥

full_name: LieSubmodule.ucs_bot_one
code: theorem ucs_bot_one : (⊥ : LieSubmodule R L M).ucs 1 = LieModule.maxTrivSubmodule R L M 
goal: LieSubmodule.ucs 1 ⊥ = LieModule.maxTrivSubmodule R L M

full_name: Function.Surjective.lieModule_lcs_map_eq
code: theorem Function.Surjective.lieModule_lcs_map_eq (k : ℕ) :
    (lowerCentralSeries R L M k : Submodule R M).map g = lowerCentralSeries R L₂ M₂ k 
goal: Submodule.map g ↑(LieModule.lowerCentralSeries R L M k) = ↑(LieModule.lowerCentralSeries R L₂ M₂ k)

full_name: Function.Surjective.lieModuleIsNilpotent
code: theorem Function.Surjective.lieModuleIsNilpotent [IsNilpotent R L M] : IsNilpotent R L₂ M₂ 
goal: LieModule.IsNilpotent R L₂ M₂

full_name: Equiv.lieModule_isNilpotent_iff
code: theorem Equiv.lieModule_isNilpotent_iff (f : L ≃ₗ⁅R⁆ L₂) (g : M ≃ₗ[R] M₂)
    (hfg : ∀ x m, ⁅f x, g m⁆ = g ⁅x, m⁆) : IsNilpotent R L M ↔ IsNilpotent R L₂ M₂ 
goal: LieModule.IsNilpotent R L M ↔ LieModule.IsNilpotent R L₂ M₂

full_name: LieModule.isNilpotent_of_top_iff
code: @[simp]
theorem LieModule.isNilpotent_of_top_iff :
    IsNilpotent R (⊤ : LieSubalgebra R L) M ↔ IsNilpotent R L M 
goal: LieModule.IsNilpotent R (↥⊤) M ↔ LieModule.IsNilpotent R L M

full_name: LieModule.isNilpotent_of_top_iff'
code: @[simp] lemma LieModule.isNilpotent_of_top_iff' :
    IsNilpotent R L {x // x ∈ (⊤ : LieSubmodule R L M)} ↔ IsNilpotent R L M 
goal: LieModule.IsNilpotent R L ↥⊤ ↔ LieModule.IsNilpotent R L M

full_name: LieAlgebra.isSolvable_of_isNilpotent
code: instance (priority := 100) LieAlgebra.isSolvable_of_isNilpotent (R : Type u) (L : Type v)
    [CommRing R] [LieRing L] [LieAlgebra R L] [hL : LieModule.IsNilpotent R L L] :
    LieAlgebra.IsSolvable R L 
goal: LieAlgebra.IsSolvable R L

full_name: LieAlgebra.IsNilpotent
code: /-- We say a Lie algebra is nilpotent when it is nilpotent as a Lie module over itself via the
adjoint representation. -/
abbrev LieAlgebra.IsNilpotent (R : Type u) (L : Type v) [CommRing R] [LieRing L] [LieAlgebra R L] :
    Prop 
goal: Prop

full_name: LieAlgebra.nilpotent_ad_of_nilpotent_algebra
code: theorem LieAlgebra.nilpotent_ad_of_nilpotent_algebra [IsNilpotent R L] :
    ∃ k : ℕ, ∀ x : L, ad R L x ^ k = 0 
goal: ∃ k, ∀ (x : L), (LieAlgebra.ad R L) x ^ k = 0

full_name: coe_lowerCentralSeries_ideal_quot_eq
code: /-- Given an ideal `I` of a Lie algebra `L`, the lower central series of `L ⧸ I` is the same
whether we regard `L ⧸ I` as an `L` module or an `L ⧸ I` module.

TODO: This result obviously generalises but the generalisation requires the missing definition of
morphisms between Lie modules over different Lie algebras. -/
-- Porting note: added `LieSubmodule.toSubmodule` in the statement
theorem coe_lowerCentralSeries_ideal_quot_eq {I : LieIdeal R L} (k : ℕ) :
    LieSubmodule.toSubmodule (lowerCentralSeries R L (L ⧸ I) k) =
      LieSubmodule.toSubmodule (lowerCentralSeries R (L ⧸ I) (L ⧸ I) k) 
goal: ↑(LieModule.lowerCentralSeries R L (L ⧸ I) k) = ↑(LieModule.lowerCentralSeries R (L ⧸ I) (L ⧸ I) k)

full_name: LieModule.coe_lowerCentralSeries_ideal_le
code: /-- Note that the below inequality can be strict. For example the ideal of strictly-upper-triangular
2x2 matrices inside the Lie algebra of upper-triangular 2x2 matrices with `k = 1`. -/
-- Porting note: added `LieSubmodule.toSubmodule` in the statement
theorem LieModule.coe_lowerCentralSeries_ideal_le {I : LieIdeal R L} (k : ℕ) :
    LieSubmodule.toSubmodule (lowerCentralSeries R I I k) ≤ lowerCentralSeries R L I k 
goal: ↑(LieModule.lowerCentralSeries R (↥↑I) (↥↑I) k) ≤ ↑(LieModule.lowerCentralSeries R L (↥↑I) k)

full_name: LieAlgebra.nilpotent_of_nilpotent_quotient
code: /-- A central extension of nilpotent Lie algebras is nilpotent. -/
theorem LieAlgebra.nilpotent_of_nilpotent_quotient {I : LieIdeal R L} (h₁ : I ≤ center R L)
    (h₂ : IsNilpotent R (L ⧸ I)) : IsNilpotent R L 
goal: LieAlgebra.IsNilpotent R L

full_name: LieAlgebra.non_trivial_center_of_isNilpotent
code: theorem LieAlgebra.non_trivial_center_of_isNilpotent [Nontrivial L] [IsNilpotent R L] :
    Nontrivial <| center R L 
goal: Nontrivial ↥↑(LieAlgebra.center R L)

full_name: LieIdeal.map_lowerCentralSeries_le
code: theorem LieIdeal.map_lowerCentralSeries_le (k : ℕ) {f : L →ₗ⁅R⁆ L'} :
    LieIdeal.map f (lowerCentralSeries R L L k) ≤ lowerCentralSeries R L' L' k 
goal: LieIdeal.map f (LieModule.lowerCentralSeries R L L k) ≤ LieModule.lowerCentralSeries R L' L' k

full_name: LieIdeal.lowerCentralSeries_map_eq
code: theorem LieIdeal.lowerCentralSeries_map_eq (k : ℕ) {f : L →ₗ⁅R⁆ L'} (h : Function.Surjective f) :
    LieIdeal.map f (lowerCentralSeries R L L k) = lowerCentralSeries R L' L' k 
goal: LieIdeal.map f (LieModule.lowerCentralSeries R L L k) = LieModule.lowerCentralSeries R L' L' k

full_name: Function.Injective.lieAlgebra_isNilpotent
code: theorem Function.Injective.lieAlgebra_isNilpotent [h₁ : IsNilpotent R L'] {f : L →ₗ⁅R⁆ L'}
    (h₂ : Function.Injective f) : IsNilpotent R L 
goal: LieAlgebra.IsNilpotent R L

full_name: Function.Surjective.lieAlgebra_isNilpotent
code: theorem Function.Surjective.lieAlgebra_isNilpotent [h₁ : IsNilpotent R L] {f : L →ₗ⁅R⁆ L'}
    (h₂ : Function.Surjective f) : IsNilpotent R L' 
goal: LieAlgebra.IsNilpotent R L'

full_name: LieEquiv.nilpotent_iff_equiv_nilpotent
code: theorem LieEquiv.nilpotent_iff_equiv_nilpotent (e : L ≃ₗ⁅R⁆ L') :
    IsNilpotent R L ↔ IsNilpotent R L' 
goal: LieAlgebra.IsNilpotent R L ↔ LieAlgebra.IsNilpotent R L'

full_name: LieHom.isNilpotent_range
code: theorem LieHom.isNilpotent_range [IsNilpotent R L] (f : L →ₗ⁅R⁆ L') : IsNilpotent R f.range 
goal: LieAlgebra.IsNilpotent R ↥f.range

full_name: LieAlgebra.isNilpotent_range_ad_iff
code: /-- Note that this result is not quite a special case of
`LieModule.isNilpotent_range_toEnd_iff` which concerns nilpotency of the
`(ad R L).range`-module `L`, whereas this result concerns nilpotency of the `(ad R L).range`-module
`(ad R L).range`. -/
@[simp]
theorem LieAlgebra.isNilpotent_range_ad_iff : IsNilpotent R (ad R L).range ↔ IsNilpotent R L 
goal: LieAlgebra.IsNilpotent R ↥(LieAlgebra.ad R L).range ↔ LieAlgebra.IsNilpotent R L

full_name: instIsNilpotentSubtypeMemLieSubalgebraTop
code: instance [h : LieAlgebra.IsNilpotent R L] : LieAlgebra.IsNilpotent R (⊤ : LieSubalgebra R L) 
goal: LieAlgebra.IsNilpotent R ↥⊤

full_name: LieIdeal.lcs
code: /-- Given a Lie module `M` over a Lie algebra `L` together with an ideal `I` of `L`, this is the
lower central series of `M` as an `I`-module. The advantage of using this definition instead of
`LieModule.lowerCentralSeries R I M` is that its terms are Lie submodules of `M` as an
`L`-module, rather than just as an `I`-module.

See also `LieIdeal.coe_lcs_eq`. -/
def lcs : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieIdeal.lcs_zero
code: @[simp]
theorem lcs_zero : I.lcs M 0 = ⊤ 
goal: I.lcs M 0 = ⊤

full_name: LieIdeal.lcs_succ
code: @[simp]
theorem lcs_succ : I.lcs M (k + 1) = ⁅I, I.lcs M k⁆ 
goal: I.lcs M (k + 1) = ⁅I, I.lcs M k⁆

full_name: LieIdeal.lcs_top
code: theorem lcs_top : (⊤ : LieIdeal R L).lcs M k = lowerCentralSeries R L M k 
goal: ⊤.lcs M k = LieModule.lowerCentralSeries R L M k

full_name: LieIdeal.coe_lcs_eq
code: theorem coe_lcs_eq : LieSubmodule.toSubmodule (I.lcs M k) = lowerCentralSeries R I M k 
goal: ↑(I.lcs M k) = ↑(LieModule.lowerCentralSeries R (↥↑I) M k)

full_name: LieAlgebra.ad_nilpotent_of_nilpotent
code: theorem _root_.LieAlgebra.ad_nilpotent_of_nilpotent {a : A} (h : IsNilpotent a) :
    IsNilpotent (LieAlgebra.ad R A a) 
goal: IsNilpotent ((LieAlgebra.ad R A) a)

full_name: LieSubalgebra.isNilpotent_ad_of_isNilpotent_ad
code: theorem _root_.LieSubalgebra.isNilpotent_ad_of_isNilpotent_ad {L : Type v} [LieRing L]
    [LieAlgebra R L] (K : LieSubalgebra R L) {x : K} (h : IsNilpotent (LieAlgebra.ad R L ↑x)) :
    IsNilpotent (LieAlgebra.ad R K x) 
goal: IsNilpotent ((LieAlgebra.ad R ↥K) x)

full_name: LieAlgebra.isNilpotent_ad_of_isNilpotent
code: theorem _root_.LieAlgebra.isNilpotent_ad_of_isNilpotent {L : LieSubalgebra R A} {x : L}
    (h : IsNilpotent (x : A)) : IsNilpotent (LieAlgebra.ad R L x) 
goal: IsNilpotent ((LieAlgebra.ad R ↥L) x)

full_name: LieSubmodule.lowerCentralSeries_tensor_eq_baseChange
code: @[simp]
lemma LieSubmodule.lowerCentralSeries_tensor_eq_baseChange (k : ℕ) :
    lowerCentralSeries A (A ⊗[R] L) (A ⊗[R] M) k =
    (lowerCentralSeries R L M k).baseChange A 
goal: LieModule.lowerCentralSeries A (TensorProduct R A L) (TensorProduct R A M) k =
  LieSubmodule.baseChange A (LieModule.lowerCentralSeries R L M k)

full_name: LieModule.instIsNilpotentTensor
code: instance LieModule.instIsNilpotentTensor [IsNilpotent R L M] :
    IsNilpotent A (A ⊗[R] L) (A ⊗[R] M) 
goal: LieModule.IsNilpotent A (TensorProduct R A L) (TensorProduct R A M)