File: Mathlib/Algebra/Lie/Weights/Basic.lean

full_name: LieModule.«_aux_Mathlib_Algebra_Lie_Weights_Basic___macroRules_LieModule_term𝕎(_,_,_)_1»
code: /-- Until we define `LieModule.weightSpaceOf`, it is useful to have some notation as follows: -/
local notation3 "𝕎("M", " χ", " x")" => (toEnd R L M x).maxGenEigenspace χ
goal: Lean.Macro

full_name: LieModule.weight_vector_multiplication
code: /-- See also `bourbaki1975b` Chapter VII §1.1, Proposition 2 (ii). -/
protected theorem weight_vector_multiplication (M₁ M₂ M₃ : Type*)
    [AddCommGroup M₁] [Module R M₁] [LieRingModule L M₁] [LieModule R L M₁] [AddCommGroup M₂]
    [Module R M₂] [LieRingModule L M₂] [LieModule R L M₂] [AddCommGroup M₃] [Module R M₃]
    [LieRingModule L M₃] [LieModule R L M₃] (g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃) (χ₁ χ₂ : R) (x : L) :
    LinearMap.range ((g : M₁ ⊗[R] M₂ →ₗ[R] M₃).comp (mapIncl 𝕎(M₁, χ₁, x) 𝕎(M₂, χ₂, x))) ≤
      𝕎(M₃, χ₁ + χ₂, x) 
goal: LinearMap.range
    (↑g ∘ₗ
      TensorProduct.mapIncl (((LieModule.toEnd R L M₁) x).maxGenEigenspace χ₁)
        (((LieModule.toEnd R L M₂) x).maxGenEigenspace χ₂)) ≤
  ((LieModule.toEnd R L M₃) x).maxGenEigenspace (χ₁ + χ₂)

full_name: LieModule.lie_mem_maxGenEigenspace_toEnd
code: lemma lie_mem_maxGenEigenspace_toEnd
    {χ₁ χ₂ : R} {x y : L} {m : M} (hy : y ∈ 𝕎(L, χ₁, x)) (hm : m ∈ 𝕎(M, χ₂, x)) :
    ⁅y, m⁆ ∈ 𝕎(M, χ₁ + χ₂, x) 
goal: ⁅y, m⁆ ∈ ((LieModule.toEnd R L M) x).maxGenEigenspace (χ₁ + χ₂)

full_name: LieModule.weightSpaceOf
code: /-- If `M` is a representation of a nilpotent Lie algebra `L`, `χ` is a scalar, and `x : L`, then
`weightSpaceOf M χ x` is the maximal generalized `χ`-eigenspace of the action of `x` on `M`.

It is a Lie submodule because `L` is nilpotent. -/
def weightSpaceOf (χ : R) (x : L) : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieModule.mem_weightSpaceOf
code: theorem mem_weightSpaceOf (χ : R) (x : L) (m : M) :
    m ∈ weightSpaceOf M χ x ↔ ∃ k : ℕ, ((toEnd R L M x - χ • ↑1) ^ k) m = 0 
goal: m ∈ LieModule.weightSpaceOf M χ x ↔ ∃ k, (((LieModule.toEnd R L M) x - χ • 1) ^ k) m = 0

full_name: LieModule.coe_weightSpaceOf_zero
code: theorem coe_weightSpaceOf_zero (x : L) :
    ↑(weightSpaceOf M (0 : R) x) = ⨆ k, LinearMap.ker (toEnd R L M x ^ k) 
goal: ↑(LieModule.weightSpaceOf M 0 x) = ⨆ k, LinearMap.ker ((LieModule.toEnd R L M) x ^ k)

full_name: LieModule.weightSpace
code: /-- If `M` is a representation of a nilpotent Lie algebra `L` and `χ : L → R` is a family of
scalars, then `weightSpace M χ` is the intersection of the maximal generalized `χ x`-eigenspaces of
the action of `x` on `M` as `x` ranges over `L`.

It is a Lie submodule because `L` is nilpotent. -/
def weightSpace (χ : L → R) : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieModule.mem_weightSpace
code: theorem mem_weightSpace (χ : L → R) (m : M) :
    m ∈ weightSpace M χ ↔ ∀ x, ∃ k : ℕ, ((toEnd R L M x - χ x • ↑1) ^ k) m = 0 
goal: m ∈ LieModule.weightSpace M χ ↔ ∀ (x : L), ∃ k, (((LieModule.toEnd R L M) x - χ x • 1) ^ k) m = 0

full_name: LieModule.weightSpace_le_weightSpaceOf
code: lemma weightSpace_le_weightSpaceOf (x : L) (χ : L → R) :
    weightSpace M χ ≤ weightSpaceOf M (χ x) x 
goal: LieModule.weightSpace M χ ≤ LieModule.weightSpaceOf M (χ x) x

full_name: LieModule.Weight.toFun
code: /-- A weight of a Lie module is a map `L → R` such that the corresponding weight space is
non-trivial. -/
structure Weight where
  /-- The family of eigenvalues corresponding to a weight. -/
  toFun : L → R
  weightSpace_ne_bot' : weightSpace M toFun ≠ ⊥
goal: L → R

full_name: LieModule.Weight.weightSpace_ne_bot'
code: /-- A weight of a Lie module is a map `L → R` such that the corresponding weight space is
non-trivial. -/
structure Weight where
  /-- The family of eigenvalues corresponding to a weight. -/
  toFun : L → R
  weightSpace_ne_bot' : weightSpace M toFun ≠ ⊥
goal: LieModule.weightSpace M self.toFun ≠ ⊥

full_name: LieModule.Weight
code: /-- A weight of a Lie module is a map `L → R` such that the corresponding weight space is
non-trivial. -/
structure Weight where
  /-- The family of eigenvalues corresponding to a weight. -/
  toFun : L → R
  weightSpace_ne_bot' : weightSpace M toFun ≠ ⊥
goal: Type (max u_2 u_3)

full_name: LieModule.Weight.instFunLike
code: instance instFunLike : FunLike (Weight R L M) L R 
goal: FunLike (LieModule.Weight R L M) L R

full_name: LieModule.Weight.coe_weight_mk
code: @[simp] lemma coe_weight_mk (χ : L → R) (h) :
    (↑(⟨χ, h⟩ : Weight R L M) : L → R) = χ 
goal: ⇑{ toFun := χ, weightSpace_ne_bot' := h } = χ

full_name: LieModule.Weight.weightSpace_ne_bot
code: lemma weightSpace_ne_bot (χ : Weight R L M) : weightSpace M χ ≠ ⊥ 
goal: LieModule.weightSpace M ⇑χ ≠ ⊥

full_name: LieModule.Weight.ext
code: @[ext] lemma ext {χ₁ χ₂ : Weight R L M} (h : ∀ x, χ₁ x = χ₂ x) : χ₁ = χ₂ 
goal: χ₁ = χ₂

full_name: LieModule.Weight.ext_iff
code: protected lemma ext_iff {χ₁ χ₂ : Weight R L M} : χ₁ = χ₂ ↔ (χ₁ : L → R) = χ₂ 
goal: χ₁ = χ₂ ↔ ⇑χ₁ = ⇑χ₂

full_name: LieModule.Weight.exists_ne_zero
code: lemma exists_ne_zero (χ : Weight R L M) :
    ∃ x ∈ weightSpace M χ, x ≠ 0 
goal: ∃ x ∈ LieModule.weightSpace M ⇑χ, x ≠ 0

full_name: LieModule.Weight.instIsEmptyOfSubsingleton
code: instance [Subsingleton M] : IsEmpty (Weight R L M) 
goal: IsEmpty (LieModule.Weight R L M)

full_name: LieModule.Weight.instZeroOfNontrivialSubtypeMemSubmoduleWeightSpaceOfNatForall
code: instance [Nontrivial (weightSpace M (0 : L → R))] : Zero (Weight R L M) 
goal: Zero (LieModule.Weight R L M)

full_name: LieModule.Weight.coe_zero
code: @[simp]
lemma coe_zero [Nontrivial (weightSpace M (0 : L → R))] : ((0 : Weight R L M) : L → R) = 0 
goal: ⇑0 = 0

full_name: LieModule.Weight.zero_apply
code: lemma zero_apply [Nontrivial (weightSpace M (0 : L → R))] (x) : (0 : Weight R L M) x = 0 
goal: 0 x = 0

full_name: LieModule.Weight.IsZero
code: /-- The proposition that a weight of a Lie module is zero.

We make this definition because we cannot define a `Zero (Weight R L M)` instance since the weight
space of the zero function can be trivial. -/
def IsZero (χ : Weight R L M) 
goal: Prop

full_name: LieModule.Weight.IsZero.eq
code: @[simp] lemma IsZero.eq {χ : Weight R L M} (hχ : χ.IsZero) : (χ : L → R) = 0 
goal: ⇑χ = 0

full_name: LieModule.Weight.coe_eq_zero_iff
code: @[simp] lemma coe_eq_zero_iff (χ : Weight R L M) : (χ : L → R) = 0 ↔ χ.IsZero 
goal: ⇑χ = 0 ↔ χ.IsZero

full_name: LieModule.Weight.isZero_iff_eq_zero
code: lemma isZero_iff_eq_zero [Nontrivial (weightSpace M (0 : L → R))] {χ : Weight R L M} :
    χ.IsZero ↔ χ = 0 
goal: χ.IsZero ↔ χ = 0

full_name: LieModule.Weight.isZero_zero
code: lemma isZero_zero [Nontrivial (weightSpace M (0 : L → R))] : IsZero (0 : Weight R L M) 
goal: LieModule.Weight.IsZero 0

full_name: LieModule.Weight.IsNonZero
code: /-- The proposition that a weight of a Lie module is non-zero. -/
abbrev IsNonZero (χ : Weight R L M) 
goal: Prop

full_name: LieModule.Weight.isNonZero_iff_ne_zero
code: lemma isNonZero_iff_ne_zero [Nontrivial (weightSpace M (0 : L → R))] {χ : Weight R L M} :
    χ.IsNonZero ↔ χ ≠ 0 
goal: χ.IsNonZero ↔ χ ≠ 0

full_name: LieModule.Weight.equivSetOf
code: /-- The set of weights is equivalent to a subtype. -/
def equivSetOf : Weight R L M ≃ {χ : L → R | weightSpace M χ ≠ ⊥} 
goal: LieModule.Weight R L M ≃ ↑{χ | LieModule.weightSpace M χ ≠ ⊥}

full_name: LieModule.Weight.weightSpaceOf_ne_bot
code: lemma weightSpaceOf_ne_bot (χ : Weight R L M) (x : L) :
    weightSpaceOf M (χ x) x ≠ ⊥ 
goal: LieModule.weightSpaceOf M (χ x) x ≠ ⊥

full_name: LieModule.Weight.hasEigenvalueAt
code: lemma hasEigenvalueAt (χ : Weight R L M) (x : L) :
    (toEnd R L M x).HasEigenvalue (χ x) 
goal: ((LieModule.toEnd R L M) x).HasEigenvalue (χ x)

full_name: LieModule.Weight.apply_eq_zero_of_isNilpotent
code: lemma apply_eq_zero_of_isNilpotent [NoZeroSMulDivisors R M] [IsReduced R]
    (x : L) (h : _root_.IsNilpotent (toEnd R L M x)) (χ : Weight R L M) :
    χ x = 0 
goal: χ x = 0

full_name: LieModule.zero_weightSpace_eq_top_of_nilpotent'
code: /-- See also the more useful form `LieModule.zero_weightSpace_eq_top_of_nilpotent`. -/
@[simp]
theorem zero_weightSpace_eq_top_of_nilpotent' [IsNilpotent R L M] :
    weightSpace M (0 : L → R) = ⊤ 
goal: LieModule.weightSpace M 0 = ⊤

full_name: LieModule.coe_weightSpace_of_top
code: theorem coe_weightSpace_of_top (χ : L → R) :
    (weightSpace M (χ ∘ (⊤ : LieSubalgebra R L).incl) : Submodule R M) = weightSpace M χ 
goal: ↑(LieModule.weightSpace M (χ ∘ ⇑⊤.incl)) = ↑(LieModule.weightSpace M χ)

full_name: LieModule.zero_weightSpace_eq_top_of_nilpotent
code: @[simp]
theorem zero_weightSpace_eq_top_of_nilpotent [IsNilpotent R L M] :
    weightSpace M (0 : (⊤ : LieSubalgebra R L) → R) = ⊤ 
goal: LieModule.weightSpace M 0 = ⊤

full_name: LieModule.exists_weightSpace_le_ker_of_isNoetherian
code: theorem exists_weightSpace_le_ker_of_isNoetherian [IsNoetherian R M] (χ : L → R) (x : L) :
    ∃ k : ℕ,
      weightSpace M χ ≤ LinearMap.ker ((toEnd R L M x - algebraMap R _ (χ x)) ^ k) 
goal: ∃ k,
  ↑(LieModule.weightSpace M χ) ≤ LinearMap.ker (((LieModule.toEnd R L M) x - (algebraMap R (Module.End R M)) (χ x)) ^ k)

full_name: LieModule.exists_weightSpace_zero_le_ker_of_isNoetherian
code: theorem exists_weightSpace_zero_le_ker_of_isNoetherian
    [IsNoetherian R M] (x : L) :
    ∃ k : ℕ, weightSpace M (0 : L → R) ≤ LinearMap.ker (toEnd R L M x ^ k) 
goal: ∃ k, ↑(LieModule.weightSpace M 0) ≤ LinearMap.ker ((LieModule.toEnd R L M) x ^ k)

full_name: LieModule.isNilpotent_toEnd_sub_algebraMap
code: lemma isNilpotent_toEnd_sub_algebraMap [IsNoetherian R M] (χ : L → R) (x : L) :
    _root_.IsNilpotent <| toEnd R L (weightSpace M χ) x - algebraMap R _ (χ x) 
goal: IsNilpotent
  ((LieModule.toEnd R L ↥↑(LieModule.weightSpace M χ)) x -
    (algebraMap R (Module.End R ↥↑(LieModule.weightSpace M χ))) (χ x))

full_name: LieModule.isNilpotent_toEnd_weightSpace_zero
code: /-- A (nilpotent) Lie algebra acts nilpotently on the zero weight space of a Noetherian Lie
module. -/
theorem isNilpotent_toEnd_weightSpace_zero [IsNoetherian R M] (x : L) :
    _root_.IsNilpotent <| toEnd R L (weightSpace M (0 : L → R)) x 
goal: IsNilpotent ((LieModule.toEnd R L ↥↑(LieModule.weightSpace M 0)) x)

full_name: LieModule.instIsNilpotentSubtypeMemSubmoduleWeightSpaceOfNatForallOfIsNoetherian
code: /-- By Engel's theorem, the zero weight space of a Noetherian Lie module is nilpotent. -/
instance [IsNoetherian R M] :
    IsNilpotent R L (weightSpace M (0 : L → R)) 
goal: LieModule.IsNilpotent R L ↥↑(LieModule.weightSpace M 0)

full_name: LieModule.weightSpace_zero_normalizer_eq_self
code: @[simp]
lemma weightSpace_zero_normalizer_eq_self :
    (weightSpace M (0 : L → R)).normalizer = weightSpace M 0 
goal: (LieModule.weightSpace M 0).normalizer = LieModule.weightSpace M 0

full_name: LieModule.iSup_ucs_le_weightSpace_zero
code: lemma iSup_ucs_le_weightSpace_zero :
    ⨆ k, (⊥ : LieSubmodule R L M).ucs k ≤ weightSpace M (0 : L → R) 
goal: ⨆ k, LieSubmodule.ucs k ⊥ ≤ LieModule.weightSpace M 0

full_name: LieModule.iSup_ucs_eq_weightSpace_zero
code: /-- See also `LieModule.iInf_lowerCentralSeries_eq_posFittingComp`. -/
lemma iSup_ucs_eq_weightSpace_zero [IsNoetherian R M] :
    ⨆ k, (⊥ : LieSubmodule R L M).ucs k = weightSpace M (0 : L → R) 
goal: ⨆ k, LieSubmodule.ucs k ⊥ = LieModule.weightSpace M 0

full_name: LieModule.posFittingCompOf
code: /-- If `M` is a representation of a nilpotent Lie algebra `L`, and `x : L`, then
`posFittingCompOf R M x` is the infimum of the decreasing system
`range φₓ ⊇ range φₓ² ⊇ range φₓ³ ⊇ ⋯` where `φₓ : End R M := toEnd R L M x`. We call this
the "positive Fitting component" because with appropriate assumptions (e.g., `R` is a field and
`M` is finite-dimensional) `φₓ` induces the so-called Fitting decomposition: `M = M₀ ⊕ M₁` where
`M₀ = weightSpaceOf M 0 x` and `M₁ = posFittingCompOf R M x`.

It is a Lie submodule because `L` is nilpotent. -/
def posFittingCompOf (x : L) : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieModule.mem_posFittingCompOf
code: lemma mem_posFittingCompOf (x : L) (m : M) :
    m ∈ posFittingCompOf R M x ↔ ∀ (k : ℕ), ∃ n, (toEnd R L M x ^ k) n = m 
goal: m ∈ LieModule.posFittingCompOf R M x ↔ ∀ (k : ℕ), ∃ n, ((LieModule.toEnd R L M) x ^ k) n = m

full_name: LieModule.posFittingCompOf_le_lowerCentralSeries
code: @[simp] lemma posFittingCompOf_le_lowerCentralSeries (x : L) (k : ℕ) :
    posFittingCompOf R M x ≤ lowerCentralSeries R L M k 
goal: LieModule.posFittingCompOf R M x ≤ LieModule.lowerCentralSeries R L M k

full_name: LieModule.posFittingCompOf_eq_bot_of_isNilpotent
code: @[simp] lemma posFittingCompOf_eq_bot_of_isNilpotent
    [IsNilpotent R L M] (x : L) :
    posFittingCompOf R M x = ⊥ 
goal: LieModule.posFittingCompOf R M x = ⊥

full_name: LieModule.posFittingComp
code: /-- If `M` is a representation of a nilpotent Lie algebra `L` with coefficients in `R`, then
`posFittingComp R L M` is the span of the positive Fitting components of the action of `x` on `M`,
as `x` ranges over `L`.

It is a Lie submodule because `L` is nilpotent. -/
def posFittingComp : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieModule.mem_posFittingComp
code: lemma mem_posFittingComp (m : M) :
    m ∈ posFittingComp R L M ↔ m ∈ ⨆ (x : L), posFittingCompOf R M x 
goal: m ∈ LieModule.posFittingComp R L M ↔ m ∈ ⨆ x, LieModule.posFittingCompOf R M x

full_name: LieModule.posFittingCompOf_le_posFittingComp
code: lemma posFittingCompOf_le_posFittingComp (x : L) :
    posFittingCompOf R M x ≤ posFittingComp R L M 
goal: LieModule.posFittingCompOf R M x ≤ LieModule.posFittingComp R L M

full_name: LieModule.posFittingComp_le_iInf_lowerCentralSeries
code: lemma posFittingComp_le_iInf_lowerCentralSeries :
    posFittingComp R L M ≤ ⨅ k, lowerCentralSeries R L M k 
goal: LieModule.posFittingComp R L M ≤ ⨅ k, LieModule.lowerCentralSeries R L M k

full_name: LieModule.iInf_lowerCentralSeries_eq_posFittingComp
code: /-- See also `LieModule.iSup_ucs_eq_weightSpace_zero`. -/
@[simp] lemma iInf_lowerCentralSeries_eq_posFittingComp
    [IsNoetherian R M] [IsArtinian R M] :
    ⨅ k, lowerCentralSeries R L M k = posFittingComp R L M 
goal: ⨅ k, LieModule.lowerCentralSeries R L M k = LieModule.posFittingComp R L M

full_name: LieModule.posFittingComp_eq_bot_of_isNilpotent
code: @[simp] lemma posFittingComp_eq_bot_of_isNilpotent
    [IsNilpotent R L M] :
    posFittingComp R L M = ⊥ 
goal: LieModule.posFittingComp R L M = ⊥

full_name: LieModule.map_posFittingComp_le
code: lemma map_posFittingComp_le :
    (posFittingComp R L M).map f ≤ posFittingComp R L M₂ 
goal: LieSubmodule.map f (LieModule.posFittingComp R L M) ≤ LieModule.posFittingComp R L M₂

full_name: LieModule.map_weightSpace_le
code: lemma map_weightSpace_le :
    (weightSpace M χ).map f ≤ weightSpace M₂ χ 
goal: LieSubmodule.map f (LieModule.weightSpace M χ) ≤ LieModule.weightSpace M₂ χ

full_name: LieModule.comap_weightSpace_eq_of_injective
code: lemma comap_weightSpace_eq_of_injective (hf : Injective f) :
    (weightSpace M₂ χ).comap f = weightSpace M χ 
goal: LieSubmodule.comap f (LieModule.weightSpace M₂ χ) = LieModule.weightSpace M χ

full_name: LieModule.map_weightSpace_eq_of_injective
code: lemma map_weightSpace_eq_of_injective (hf : Injective f) :
    (weightSpace M χ).map f = weightSpace M₂ χ ⊓ f.range 
goal: LieSubmodule.map f (LieModule.weightSpace M χ) = LieModule.weightSpace M₂ χ ⊓ f.range

full_name: LieModule.map_weightSpace_eq
code: lemma map_weightSpace_eq (e : M ≃ₗ⁅R,L⁆ M₂) :
    (weightSpace M χ).map e = weightSpace M₂ χ 
goal: LieSubmodule.map e.toLieModuleHom (LieModule.weightSpace M χ) = LieModule.weightSpace M₂ χ

full_name: LieModule.map_posFittingComp_eq
code: lemma map_posFittingComp_eq (e : M ≃ₗ⁅R,L⁆ M₂) :
    (posFittingComp R L M).map e = posFittingComp R L M₂ 
goal: LieSubmodule.map e.toLieModuleHom (LieModule.posFittingComp R L M) = LieModule.posFittingComp R L M₂

full_name: LieModule.posFittingComp_map_incl_sup_of_codisjoint
code: lemma posFittingComp_map_incl_sup_of_codisjoint [IsNoetherian R M] [IsArtinian R M]
    {N₁ N₂ : LieSubmodule R L M} (h : Codisjoint N₁ N₂) :
    (posFittingComp R L N₁).map N₁.incl ⊔ (posFittingComp R L N₂).map N₂.incl =
    posFittingComp R L M 
goal: LieSubmodule.map N₁.incl (LieModule.posFittingComp R L ↥↑N₁) ⊔
    LieSubmodule.map N₂.incl (LieModule.posFittingComp R L ↥↑N₂) =
  LieModule.posFittingComp R L M

full_name: LieModule.weightSpace_weightSpaceOf_map_incl
code: lemma weightSpace_weightSpaceOf_map_incl (x : L) (χ : L → R) :
    (weightSpace (weightSpaceOf M (χ x) x) χ).map (weightSpaceOf M (χ x) x).incl =
    weightSpace M χ 
goal: LieSubmodule.map (LieModule.weightSpaceOf M (χ x) x).incl
    (LieModule.weightSpace (↥↑(LieModule.weightSpaceOf M (χ x) x)) χ) =
  LieModule.weightSpace M χ

full_name: LieModule.isCompl_weightSpaceOf_zero_posFittingCompOf
code: lemma isCompl_weightSpaceOf_zero_posFittingCompOf (x : L) :
    IsCompl (weightSpaceOf M 0 x) (posFittingCompOf R M x) 
goal: IsCompl (LieModule.weightSpaceOf M 0 x) (LieModule.posFittingCompOf R M x)

full_name: _private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.isCompl_weightSpace_zero_posFittingComp_aux
code: /-- This lemma exists only to simplify the proof of
`LieModule.isCompl_weightSpace_zero_posFittingComp`. -/
private lemma isCompl_weightSpace_zero_posFittingComp_aux
    (h : ∀ N < (⊤ : LieSubmodule R L M), IsCompl (weightSpace N 0) (posFittingComp R L N)) :
    IsCompl (weightSpace M 0) (posFittingComp R L M) 
goal: IsCompl (LieModule.weightSpace M 0) (LieModule.posFittingComp R L M)

full_name: LieModule.isCompl_weightSpace_zero_posFittingComp
code: /-- This is the Fitting decomposition of the Lie module `M`. -/
lemma isCompl_weightSpace_zero_posFittingComp :
    IsCompl (weightSpace M 0) (posFittingComp R L M) 
goal: IsCompl (LieModule.weightSpace M 0) (LieModule.posFittingComp R L M)

full_name: LieModule.disjoint_weightSpaceOf
code: lemma disjoint_weightSpaceOf [NoZeroSMulDivisors R M] {x : L} {φ₁ φ₂ : R} (h : φ₁ ≠ φ₂) :
    Disjoint (weightSpaceOf M φ₁ x) (weightSpaceOf M φ₂ x) 
goal: Disjoint (LieModule.weightSpaceOf M φ₁ x) (LieModule.weightSpaceOf M φ₂ x)

full_name: LieModule.disjoint_weightSpace
code: lemma disjoint_weightSpace [NoZeroSMulDivisors R M] {χ₁ χ₂ : L → R} (h : χ₁ ≠ χ₂) :
    Disjoint (weightSpace M χ₁) (weightSpace M χ₂) 
goal: Disjoint (LieModule.weightSpace M χ₁) (LieModule.weightSpace M χ₂)

full_name: LieModule.injOn_weightSpace
code: lemma injOn_weightSpace [NoZeroSMulDivisors R M] :
    InjOn (fun (χ : L → R) ↦ weightSpace M χ) {χ | weightSpace M χ ≠ ⊥} 
goal: Set.InjOn (fun χ => LieModule.weightSpace M χ) {χ | LieModule.weightSpace M χ ≠ ⊥}

full_name: LieModule.independent_weightSpace
code: /-- Lie module weight spaces are independent.

See also `LieModule.independent_weightSpace'`. -/
lemma independent_weightSpace [NoZeroSMulDivisors R M] :
    CompleteLattice.Independent fun (χ : L → R) ↦ weightSpace M χ 
goal: CompleteLattice.Independent fun χ => LieModule.weightSpace M χ

full_name: LieModule.independent_weightSpace'
code: lemma independent_weightSpace' [NoZeroSMulDivisors R M] :
    CompleteLattice.Independent fun χ : Weight R L M ↦ weightSpace M χ 
goal: CompleteLattice.Independent fun χ => LieModule.weightSpace M ⇑χ

full_name: LieModule.independent_weightSpaceOf
code: lemma independent_weightSpaceOf [NoZeroSMulDivisors R M] (x : L) :
    CompleteLattice.Independent fun (χ : R) ↦ weightSpaceOf M χ x 
goal: CompleteLattice.Independent fun χ => LieModule.weightSpaceOf M χ x

full_name: LieModule.finite_weightSpaceOf_ne_bot
code: lemma finite_weightSpaceOf_ne_bot [NoZeroSMulDivisors R M] [IsNoetherian R M] (x : L) :
    {χ : R | weightSpaceOf M χ x ≠ ⊥}.Finite 
goal: {χ | LieModule.weightSpaceOf M χ x ≠ ⊥}.Finite

full_name: LieModule.finite_weightSpace_ne_bot
code: lemma finite_weightSpace_ne_bot [NoZeroSMulDivisors R M] [IsNoetherian R M] :
    {χ : L → R | weightSpace M χ ≠ ⊥}.Finite 
goal: {χ | LieModule.weightSpace M χ ≠ ⊥}.Finite

full_name: LieModule.Weight.instFinite
code: instance Weight.instFinite [NoZeroSMulDivisors R M] [IsNoetherian R M] :
    Finite (Weight R L M) 
goal: Finite (LieModule.Weight R L M)

full_name: LieModule.Weight.instFintype
code: noncomputable instance Weight.instFintype [NoZeroSMulDivisors R M] [IsNoetherian R M] :
    Fintype (Weight R L M) 
goal: Fintype (LieModule.Weight R L M)

full_name: LieModule.IsTriangularizable
code: /-- A Lie module `M` of a Lie algebra `L` is triangularizable if the endomorhpism of `M` defined by
any `x : L` is triangularizable. -/
class IsTriangularizable : Prop :=
  iSup_eq_top : ∀ x, ⨆ φ, ⨆ k, (toEnd R L M x).genEigenspace φ k = ⊤
goal: Prop

full_name: LieModule.IsTriangularizable.iSup_eq_top
code: /-- A Lie module `M` of a Lie algebra `L` is triangularizable if the endomorhpism of `M` defined by
any `x : L` is triangularizable. -/
class IsTriangularizable : Prop :=
  iSup_eq_top : ∀ x, ⨆ φ, ⨆ k, (toEnd R L M x).genEigenspace φ k = ⊤
goal: ⨆ φ, ⨆ k, (((LieModule.toEnd R L M) x).genEigenspace φ) k = ⊤

full_name: LieModule.instIsTriangularizableSubtypeMemLieSubalgebra
code: instance (L' : LieSubalgebra R L) [IsTriangularizable R L M] : IsTriangularizable R L' M 
goal: LieModule.IsTriangularizable R (↥L') M

full_name: LieModule.instIsTriangularizableSubtypeMemSubmodule
code: instance (I : LieIdeal R L) [IsTriangularizable R L M] : IsTriangularizable R I M 
goal: LieModule.IsTriangularizable R (↥↑I) M

full_name: LieModule.instIsTriangularizableSubtypeEndMemLieSubalgebraRangeToEnd
code: instance [IsTriangularizable R L M] : IsTriangularizable R (LieModule.toEnd R L M).range M 
goal: LieModule.IsTriangularizable R (↥(LieModule.toEnd R L M).range) M

full_name: LieModule.iSup_weightSpaceOf_eq_top
code: @[simp]
lemma iSup_weightSpaceOf_eq_top [IsTriangularizable R L M] (x : L) :
    ⨆ (φ : R), weightSpaceOf M φ x = ⊤ 
goal: ⨆ φ, LieModule.weightSpaceOf M φ x = ⊤

full_name: LieModule.trace_toEnd_weightSpace
code: @[simp]
lemma trace_toEnd_weightSpace [IsDomain R] [IsPrincipalIdealRing R]
    [Module.Free R M] [Module.Finite R M] (χ : L → R) (x : L) :
    trace R _ (toEnd R L (weightSpace M χ) x) = finrank R (weightSpace M χ) • χ x 
goal: (LinearMap.trace R ↥↑(LieModule.weightSpace M χ)) ((LieModule.toEnd R L ↥↑(LieModule.weightSpace M χ)) x) =
  FiniteDimensional.finrank R ↥↑(LieModule.weightSpace M χ) • χ x

full_name: LieModule.instIsTriangularizableOfIsAlgClosed
code: instance instIsTriangularizableOfIsAlgClosed [IsAlgClosed K] : IsTriangularizable K L M 
goal: LieModule.IsTriangularizable K L M

full_name: LieModule.instIsTriangularizableSubtypeMemSubmodule_1
code: instance (N : LieSubmodule K L M) [IsTriangularizable K L M] : IsTriangularizable K L N 
goal: LieModule.IsTriangularizable K L ↥↑N

full_name: LieModule.iSup_weightSpace_eq_top
code: /-- For a triangularizable Lie module in finite dimensions, the weight spaces span the entire space.

See also `LieModule.iSup_weightSpace_eq_top'`. -/
lemma iSup_weightSpace_eq_top [IsTriangularizable K L M] :
    ⨆ χ : L → K, weightSpace M χ = ⊤ 
goal: ⨆ χ, LieModule.weightSpace M χ = ⊤

full_name: LieModule.iSup_weightSpace_eq_top'
code: lemma iSup_weightSpace_eq_top' [IsTriangularizable K L M] :
    ⨆ χ : Weight K L M, weightSpace M χ = ⊤ 
goal: ⨆ χ, LieModule.weightSpace M ⇑χ = ⊤