File: Mathlib/Algebra/Lie/Solvable.lean

full_name: LieAlgebra.derivedSeriesOfIdeal
code: /-- A generalisation of the derived series of a Lie algebra, whose zeroth term is a specified ideal.

It can be more convenient to work with this generalisation when considering the derived series of
an ideal since it provides a type-theoretic expression of the fact that the terms of the ideal's
derived series are also ideals of the enclosing algebra.

See also `LieIdeal.derivedSeries_eq_derivedSeriesOfIdeal_comap` and
`LieIdeal.derivedSeries_eq_derivedSeriesOfIdeal_map` below. -/
def derivedSeriesOfIdeal (k : ℕ) : LieIdeal R L → LieIdeal R L 
goal: LieIdeal R L → LieIdeal R L

full_name: LieAlgebra.derivedSeriesOfIdeal_zero
code: @[simp]
theorem derivedSeriesOfIdeal_zero : derivedSeriesOfIdeal R L 0 I = I 
goal: LieAlgebra.derivedSeriesOfIdeal R L 0 I = I

full_name: LieAlgebra.derivedSeriesOfIdeal_succ
code: @[simp]
theorem derivedSeriesOfIdeal_succ (k : ℕ) :
    derivedSeriesOfIdeal R L (k + 1) I =
      ⁅derivedSeriesOfIdeal R L k I, derivedSeriesOfIdeal R L k I⁆ 
goal: LieAlgebra.derivedSeriesOfIdeal R L (k + 1) I =
  ⁅LieAlgebra.derivedSeriesOfIdeal R L k I, LieAlgebra.derivedSeriesOfIdeal R L k I⁆

full_name: LieAlgebra.derivedSeries
code: /-- The derived series of Lie ideals of a Lie algebra. -/
abbrev derivedSeries (k : ℕ) : LieIdeal R L 
goal: LieIdeal R L

full_name: LieAlgebra.derivedSeries_def
code: theorem derivedSeries_def (k : ℕ) : derivedSeries R L k = derivedSeriesOfIdeal R L k ⊤ 
goal: LieAlgebra.derivedSeries R L k = LieAlgebra.derivedSeriesOfIdeal R L k ⊤

full_name: LieAlgebra._aux_Mathlib_Algebra_Lie_Solvable___unexpand_LieAlgebra_derivedSeriesOfIdeal_1
code: local notation "D" => derivedSeriesOfIdeal R L
goal: Lean.PrettyPrinter.Unexpander

full_name: LieAlgebra._aux_Mathlib_Algebra_Lie_Solvable___macroRules_LieAlgebra_termD_1
code: local notation "D" => derivedSeriesOfIdeal R L
goal: Lean.Macro

full_name: LieAlgebra.derivedSeriesOfIdeal_add
code: theorem derivedSeriesOfIdeal_add (k l : ℕ) : D (k + l) I = D k (D l I) 
goal: LieAlgebra.derivedSeriesOfIdeal R L (k + l) I =
  LieAlgebra.derivedSeriesOfIdeal R L k (LieAlgebra.derivedSeriesOfIdeal R L l I)

full_name: LieAlgebra.derivedSeriesOfIdeal_le
code: @[mono]
theorem derivedSeriesOfIdeal_le {I J : LieIdeal R L} {k l : ℕ} (h₁ : I ≤ J) (h₂ : l ≤ k) :
    D k I ≤ D l J 
goal: LieAlgebra.derivedSeriesOfIdeal R L k I ≤ LieAlgebra.derivedSeriesOfIdeal R L l J

full_name: LieAlgebra.derivedSeriesOfIdeal_succ_le
code: theorem derivedSeriesOfIdeal_succ_le (k : ℕ) : D (k + 1) I ≤ D k I 
goal: LieAlgebra.derivedSeriesOfIdeal R L (k + 1) I ≤ LieAlgebra.derivedSeriesOfIdeal R L k I

full_name: LieAlgebra.derivedSeriesOfIdeal_le_self
code: theorem derivedSeriesOfIdeal_le_self (k : ℕ) : D k I ≤ I 
goal: LieAlgebra.derivedSeriesOfIdeal R L k I ≤ I

full_name: LieAlgebra.derivedSeriesOfIdeal_mono
code: theorem derivedSeriesOfIdeal_mono {I J : LieIdeal R L} (h : I ≤ J) (k : ℕ) : D k I ≤ D k J 
goal: LieAlgebra.derivedSeriesOfIdeal R L k I ≤ LieAlgebra.derivedSeriesOfIdeal R L k J

full_name: LieAlgebra.derivedSeriesOfIdeal_antitone
code: theorem derivedSeriesOfIdeal_antitone {k l : ℕ} (h : l ≤ k) : D k I ≤ D l I 
goal: LieAlgebra.derivedSeriesOfIdeal R L k I ≤ LieAlgebra.derivedSeriesOfIdeal R L l I

full_name: LieAlgebra.derivedSeriesOfIdeal_add_le_add
code: theorem derivedSeriesOfIdeal_add_le_add (J : LieIdeal R L) (k l : ℕ) :
    D (k + l) (I + J) ≤ D k I + D l J 
goal: LieAlgebra.derivedSeriesOfIdeal R L (k + l) (I + J) ≤
  LieAlgebra.derivedSeriesOfIdeal R L k I + LieAlgebra.derivedSeriesOfIdeal R L l J

full_name: LieAlgebra.derivedSeries_of_bot_eq_bot
code: theorem derivedSeries_of_bot_eq_bot (k : ℕ) : derivedSeriesOfIdeal R L k ⊥ = ⊥ 
goal: LieAlgebra.derivedSeriesOfIdeal R L k ⊥ = ⊥

full_name: LieAlgebra.abelian_iff_derived_one_eq_bot
code: theorem abelian_iff_derived_one_eq_bot : IsLieAbelian I ↔ derivedSeriesOfIdeal R L 1 I = ⊥ 
goal: IsLieAbelian ↥↑I ↔ LieAlgebra.derivedSeriesOfIdeal R L 1 I = ⊥

full_name: LieAlgebra.abelian_iff_derived_succ_eq_bot
code: theorem abelian_iff_derived_succ_eq_bot (I : LieIdeal R L) (k : ℕ) :
    IsLieAbelian (derivedSeriesOfIdeal R L k I) ↔ derivedSeriesOfIdeal R L (k + 1) I = ⊥ 
goal: IsLieAbelian ↥↑(LieAlgebra.derivedSeriesOfIdeal R L k I) ↔ LieAlgebra.derivedSeriesOfIdeal R L (k + 1) I = ⊥

full_name: LieIdeal.derivedSeries_eq_derivedSeriesOfIdeal_comap
code: theorem derivedSeries_eq_derivedSeriesOfIdeal_comap (k : ℕ) :
    derivedSeries R I k = (derivedSeriesOfIdeal R L k I).comap I.incl 
goal: LieAlgebra.derivedSeries R (↥↑I) k = LieIdeal.comap I.incl (LieAlgebra.derivedSeriesOfIdeal R L k I)

full_name: LieIdeal.derivedSeries_eq_derivedSeriesOfIdeal_map
code: theorem derivedSeries_eq_derivedSeriesOfIdeal_map (k : ℕ) :
    (derivedSeries R I k).map I.incl = derivedSeriesOfIdeal R L k I 
goal: LieIdeal.map I.incl (LieAlgebra.derivedSeries R (↥↑I) k) = LieAlgebra.derivedSeriesOfIdeal R L k I

full_name: LieIdeal.derivedSeries_eq_bot_iff
code: theorem derivedSeries_eq_bot_iff (k : ℕ) :
    derivedSeries R I k = ⊥ ↔ derivedSeriesOfIdeal R L k I = ⊥ 
goal: LieAlgebra.derivedSeries R (↥↑I) k = ⊥ ↔ LieAlgebra.derivedSeriesOfIdeal R L k I = ⊥

full_name: LieIdeal.derivedSeries_add_eq_bot
code: theorem derivedSeries_add_eq_bot {k l : ℕ} {I J : LieIdeal R L} (hI : derivedSeries R I k = ⊥)
    (hJ : derivedSeries R J l = ⊥) : derivedSeries R (I + J) (k + l) = ⊥ 
goal: LieAlgebra.derivedSeries R (↥↑(I + J)) (k + l) = ⊥

full_name: LieIdeal.derivedSeries_map_le
code: theorem derivedSeries_map_le (k : ℕ) : (derivedSeries R L' k).map f ≤ derivedSeries R L k 
goal: LieIdeal.map f (LieAlgebra.derivedSeries R L' k) ≤ LieAlgebra.derivedSeries R L k

full_name: LieIdeal.derivedSeries_map_eq
code: theorem derivedSeries_map_eq (k : ℕ) (h : Function.Surjective f) :
    (derivedSeries R L' k).map f = derivedSeries R L k 
goal: LieIdeal.map f (LieAlgebra.derivedSeries R L' k) = LieAlgebra.derivedSeries R L k

full_name: LieIdeal.derivedSeries_succ_eq_top_iff
code: theorem derivedSeries_succ_eq_top_iff (n : ℕ) :
    derivedSeries R L (n + 1) = ⊤ ↔ derivedSeries R L 1 = ⊤ 
goal: LieAlgebra.derivedSeries R L (n + 1) = ⊤ ↔ LieAlgebra.derivedSeries R L 1 = ⊤

full_name: LieIdeal.derivedSeries_eq_top
code: theorem derivedSeries_eq_top (n : ℕ) (h : derivedSeries R L 1 = ⊤) :
    derivedSeries R L n = ⊤ 
goal: LieAlgebra.derivedSeries R L n = ⊤

full_name: LieAlgebra.IsSolvable.solvable
code: /-- A Lie algebra is solvable if its derived series reaches 0 (in a finite number of steps). -/
class IsSolvable : Prop where
  solvable : ∃ k, derivedSeries R L k = ⊥
goal: ∃ k, LieAlgebra.derivedSeries R L k = ⊥

full_name: LieAlgebra.IsSolvable
code: /-- A Lie algebra is solvable if its derived series reaches 0 (in a finite number of steps). -/
class IsSolvable : Prop where
  solvable : ∃ k, derivedSeries R L k = ⊥
goal: Prop

full_name: LieAlgebra.isSolvableBot
code: instance isSolvableBot : IsSolvable R (↥(⊥ : LieIdeal R L)) 
goal: LieAlgebra.IsSolvable R ↥⊥

full_name: LieAlgebra.isSolvableAdd
code: instance isSolvableAdd {I J : LieIdeal R L} [hI : IsSolvable R I] [hJ : IsSolvable R J] :
    IsSolvable R (↥(I + J)) 
goal: LieAlgebra.IsSolvable R ↥(I + J)

full_name: LieAlgebra.derivedSeries_lt_top_of_solvable
code: theorem derivedSeries_lt_top_of_solvable [IsSolvable R L] [Nontrivial L] :
    derivedSeries R L 1 < ⊤ 
goal: LieAlgebra.derivedSeries R L 1 < ⊤

full_name: Function.Injective.lieAlgebra_isSolvable
code: theorem Injective.lieAlgebra_isSolvable [h₁ : IsSolvable R L] (h₂ : Injective f) :
    IsSolvable R L' 
goal: LieAlgebra.IsSolvable R L'

full_name: Function.Surjective.lieAlgebra_isSolvable
code: theorem Surjective.lieAlgebra_isSolvable [h₁ : IsSolvable R L'] (h₂ : Surjective f) :
    IsSolvable R L 
goal: LieAlgebra.IsSolvable R L

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

full_name: LieAlgebra.solvable_iff_equiv_solvable
code: theorem solvable_iff_equiv_solvable (e : L' ≃ₗ⁅R⁆ L) : IsSolvable R L' ↔ IsSolvable R L 
goal: LieAlgebra.IsSolvable R L' ↔ LieAlgebra.IsSolvable R L

full_name: LieAlgebra.le_solvable_ideal_solvable
code: theorem le_solvable_ideal_solvable {I J : LieIdeal R L} (h₁ : I ≤ J) (_ : IsSolvable R J) :
    IsSolvable R I 
goal: LieAlgebra.IsSolvable R ↥↑J → LieAlgebra.IsSolvable R ↥↑I

full_name: LieAlgebra.ofAbelianIsSolvable
code: instance (priority := 100) ofAbelianIsSolvable [IsLieAbelian L] : IsSolvable R L 
goal: LieAlgebra.IsSolvable R L

full_name: LieAlgebra.radical
code: /-- The (solvable) radical of Lie algebra is the `sSup` of all solvable ideals. -/
def radical 
goal: LieIdeal R L

full_name: LieAlgebra.radicalIsSolvable
code: /-- The radical of a Noetherian Lie algebra is solvable. -/
instance radicalIsSolvable [IsNoetherian R L] : IsSolvable R (radical R L) 
goal: LieAlgebra.IsSolvable R ↥↑(LieAlgebra.radical R L)

full_name: LieAlgebra.LieIdeal.solvable_iff_le_radical
code: /-- The `→` direction of this lemma is actually true without the `IsNoetherian` assumption. -/
theorem LieIdeal.solvable_iff_le_radical [IsNoetherian R L] (I : LieIdeal R L) :
    IsSolvable R I ↔ I ≤ radical R L 
goal: LieAlgebra.IsSolvable R ↥↑I ↔ I ≤ LieAlgebra.radical R L

full_name: LieAlgebra.center_le_radical
code: theorem center_le_radical : center R L ≤ radical R L 
goal: LieAlgebra.center R L ≤ LieAlgebra.radical R L

full_name: LieAlgebra.instIsSolvableSubtypeMemLieSubalgebraTop
code: instance [IsSolvable R L] : IsSolvable R (⊤ : LieSubalgebra R L) 
goal: LieAlgebra.IsSolvable R ↥⊤

full_name: LieAlgebra.radical_eq_top_of_isSolvable
code: @[simp] lemma radical_eq_top_of_isSolvable [IsSolvable R L] :
    radical R L = ⊤ 
goal: LieAlgebra.radical R L = ⊤

full_name: LieAlgebra.derivedLengthOfIdeal
code: /-- Given a solvable Lie ideal `I` with derived series `I = D₀ ≥ D₁ ≥ ⋯ ≥ Dₖ = ⊥`, this is the
natural number `k` (the number of inclusions).

For a non-solvable ideal, the value is 0. -/
noncomputable def derivedLengthOfIdeal (I : LieIdeal R L) : ℕ 
goal: ℕ

full_name: LieAlgebra.derivedLength
code: /-- The derived length of a Lie algebra is the derived length of its 'top' Lie ideal.

See also `LieAlgebra.derivedLength_eq_derivedLengthOfIdeal`. -/
noncomputable abbrev derivedLength : ℕ 
goal: ℕ

full_name: LieAlgebra.derivedSeries_of_derivedLength_succ
code: theorem derivedSeries_of_derivedLength_succ (I : LieIdeal R L) (k : ℕ) :
    derivedLengthOfIdeal R L I = k + 1 ↔
      IsLieAbelian (derivedSeriesOfIdeal R L k I) ∧ derivedSeriesOfIdeal R L k I ≠ ⊥ 
goal: LieAlgebra.derivedLengthOfIdeal R L I = k + 1 ↔
  IsLieAbelian ↥↑(LieAlgebra.derivedSeriesOfIdeal R L k I) ∧ LieAlgebra.derivedSeriesOfIdeal R L k I ≠ ⊥

full_name: LieAlgebra.derivedLength_eq_derivedLengthOfIdeal
code: theorem derivedLength_eq_derivedLengthOfIdeal (I : LieIdeal R L) :
    derivedLength R I = derivedLengthOfIdeal R L I 
goal: LieAlgebra.derivedLength R ↥↑I = LieAlgebra.derivedLengthOfIdeal R L I

full_name: LieAlgebra.derivedAbelianOfIdeal
code: /-- Given a solvable Lie ideal `I` with derived series `I = D₀ ≥ D₁ ≥ ⋯ ≥ Dₖ = ⊥`, this is the
`k-1`th term in the derived series (and is therefore an Abelian ideal contained in `I`).

For a non-solvable ideal, this is the zero ideal, `⊥`. -/
noncomputable def derivedAbelianOfIdeal (I : LieIdeal R L) : LieIdeal R L 
goal: LieIdeal R L

full_name: LieAlgebra.abelian_derivedAbelianOfIdeal
code: theorem abelian_derivedAbelianOfIdeal (I : LieIdeal R L) :
    IsLieAbelian (derivedAbelianOfIdeal I) 
goal: IsLieAbelian ↥↑(LieAlgebra.derivedAbelianOfIdeal I)

full_name: LieAlgebra.derivedLength_zero
code: theorem derivedLength_zero (I : LieIdeal R L) [hI : IsSolvable R I] :
    derivedLengthOfIdeal R L I = 0 ↔ I = ⊥ 
goal: LieAlgebra.derivedLengthOfIdeal R L I = 0 ↔ I = ⊥

full_name: LieAlgebra.abelian_of_solvable_ideal_eq_bot_iff
code: theorem abelian_of_solvable_ideal_eq_bot_iff (I : LieIdeal R L) [h : IsSolvable R I] :
    derivedAbelianOfIdeal I = ⊥ ↔ I = ⊥ 
goal: LieAlgebra.derivedAbelianOfIdeal I = ⊥ ↔ I = ⊥