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

full_name: LieModule.LinearWeights.map_lie
code: /-- A typeclass encoding the fact that a given Lie module has linear weights, vanishing on the
derived ideal. -/
class LinearWeights [LieAlgebra.IsNilpotent R L] : Prop :=
  map_add : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y, χ (x + y) = χ x + χ y
  map_smul : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ (t : R) x, χ (t • x) = t • χ x
  map_lie : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y : L, χ ⁅x, y⁆ = 0
goal: LieModule.weightSpace M χ ≠ ⊥ → ∀ (x y : L), χ ⁅x, y⁆ = 0

full_name: LieModule.LinearWeights.map_add
code: /-- A typeclass encoding the fact that a given Lie module has linear weights, vanishing on the
derived ideal. -/
class LinearWeights [LieAlgebra.IsNilpotent R L] : Prop :=
  map_add : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y, χ (x + y) = χ x + χ y
  map_smul : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ (t : R) x, χ (t • x) = t • χ x
  map_lie : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y : L, χ ⁅x, y⁆ = 0
goal: LieModule.weightSpace M χ ≠ ⊥ → ∀ (x y : L), χ (x + y) = χ x + χ y

full_name: LieModule.LinearWeights.map_smul
code: /-- A typeclass encoding the fact that a given Lie module has linear weights, vanishing on the
derived ideal. -/
class LinearWeights [LieAlgebra.IsNilpotent R L] : Prop :=
  map_add : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y, χ (x + y) = χ x + χ y
  map_smul : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ (t : R) x, χ (t • x) = t • χ x
  map_lie : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y : L, χ ⁅x, y⁆ = 0
goal: LieModule.weightSpace M χ ≠ ⊥ → ∀ (t : R) (x : L), χ (t • x) = t • χ x

full_name: LieModule.LinearWeights
code: /-- A typeclass encoding the fact that a given Lie module has linear weights, vanishing on the
derived ideal. -/
class LinearWeights [LieAlgebra.IsNilpotent R L] : Prop :=
  map_add : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y, χ (x + y) = χ x + χ y
  map_smul : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ (t : R) x, χ (t • x) = t • χ x
  map_lie : ∀ χ : L → R, weightSpace M χ ≠ ⊥ → ∀ x y : L, χ ⁅x, y⁆ = 0
goal: Prop

full_name: LieModule.Weight.toLinear_apply
code: /-- A weight of a Lie module, bundled as a linear map. -/
@[simps]
def toLinear : L →ₗ[R] R 
goal: (LieModule.Weight.toLinear R L M χ) a = χ a

full_name: LieModule.Weight.toLinear
code: /-- A weight of a Lie module, bundled as a linear map. -/
@[simps]
def toLinear : L →ₗ[R] R 
goal: L →ₗ[R] R

full_name: LieModule.Weight.instCoeLinearMap
code: instance instCoeLinearMap : CoeOut (Weight R L M) (L →ₗ[R] R) 
goal: CoeOut (LieModule.Weight R L M) (L →ₗ[R] R)

full_name: LieModule.Weight.instLinearMapClass
code: instance instLinearMapClass : LinearMapClass (Weight R L M) R L R 
goal: LinearMapClass (LieModule.Weight R L M) R L R

full_name: LieModule.Weight.apply_lie
code: @[simp]
lemma apply_lie (x y : L) :
    χ ⁅x, y⁆ = 0 
goal: χ ⁅x, y⁆ = 0

full_name: LieModule.Weight.coe_coe
code: @[simp] lemma coe_coe : (↑(χ : L →ₗ[R] R) : L → R) = (χ : L → R) 
goal: ⇑(LieModule.Weight.toLinear R L M χ) = ⇑χ

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

full_name: LieModule.Weight.coe_toLinear_ne_zero_iff
code: lemma coe_toLinear_ne_zero_iff : (χ : L →ₗ[R] R) ≠ 0 ↔ χ.IsNonZero 
goal: LieModule.Weight.toLinear R L M χ ≠ 0 ↔ χ.IsNonZero

full_name: LieModule.Weight.ker
code: /-- The kernel of a weight of a Lie module with linear weights. -/
abbrev ker 
goal: Submodule R L

full_name: LieModule.instLinearWeightsOfIsLieAbelian
code: /-- For an Abelian Lie algebra, the weights of any Lie module are linear. -/
instance instLinearWeightsOfIsLieAbelian [IsLieAbelian L] [NoZeroSMulDivisors R M] :
    LinearWeights R L M 
goal: LieModule.LinearWeights R L M

full_name: LieModule.trace_comp_toEnd_weightSpace_eq
code: lemma trace_comp_toEnd_weightSpace_eq (χ : L → R) :
    LinearMap.trace R _ ∘ₗ (toEnd R L (weightSpace M χ)).toLinearMap =
    finrank R (weightSpace M χ) • χ 
goal: ⇑(LinearMap.trace R ↥↑(LieModule.weightSpace M χ) ∘ₗ ↑(LieModule.toEnd R L ↥↑(LieModule.weightSpace M χ))) =
  FiniteDimensional.finrank R ↥↑(LieModule.weightSpace M χ) • χ

full_name: LieModule.zero_lt_finrank_weightSpace
code: lemma zero_lt_finrank_weightSpace {χ : L → R} (hχ : weightSpace M χ ≠ ⊥) :
    0 < finrank R (weightSpace M χ) 
goal: 0 < FiniteDimensional.finrank R ↥↑(LieModule.weightSpace M χ)

full_name: LieModule.instLinearWeightsOfCharZero
code: /-- In characteristic zero, the weights of any finite-dimensional Lie module are linear and vanish
on the derived ideal. -/
instance instLinearWeightsOfCharZero [CharZero R] :
    LinearWeights R L M 
goal: LieModule.LinearWeights R L M

full_name: LieModule.shiftedWeightSpace
code: /-- A type synonym for the `χ`-weight space but with the action of `x : L` on `m : weightSpace M χ`,
shifted to act as `⁅x, m⁆ - χ x • m`. -/
def shiftedWeightSpace 
goal: LieSubmodule R L M

full_name: _private.Mathlib.Algebra.Lie.Weights.Linear.0.LieModule.shiftedWeightSpace.aux
code: private lemma aux [h : Nontrivial (shiftedWeightSpace R L M χ)] : weightSpace M χ ≠ ⊥ 
goal: LieModule.weightSpace M χ ≠ ⊥

full_name: LieModule.shiftedWeightSpace.instLieRingModuleSubtypeMemSubmodule
code: instance : LieRingModule L (shiftedWeightSpace R L M χ) 
goal: LieRingModule L ↥↑(LieModule.shiftedWeightSpace R L M χ)

full_name: LieModule.shiftedWeightSpace.coe_lie_shiftedWeightSpace_apply
code: @[simp] lemma coe_lie_shiftedWeightSpace_apply (x : L) (m : shiftedWeightSpace R L M χ) :
    ⁅x, m⁆ = ⁅x, (m : M)⁆ - χ x • m 
goal: ↑⁅x, m⁆ = ⁅x, ↑m⁆ - χ x • ↑m

full_name: LieModule.shiftedWeightSpace.instSubtypeMemSubmodule
code: instance : LieModule R L (shiftedWeightSpace R L M χ) 
goal: LieModule R L ↥↑(LieModule.shiftedWeightSpace R L M χ)

full_name: LieModule.shiftedWeightSpace.shift_apply
code: /-- Forgetting the action of `L`, the spaces `weightSpace M χ` and `shiftedWeightSpace R L M χ` are
equivalent. -/
@[simps!] def shift : weightSpace M χ ≃ₗ[R] shiftedWeightSpace R L M χ 
goal: (LieModule.shiftedWeightSpace.shift R L M χ) a = a

full_name: LieModule.shiftedWeightSpace.shift_symm_apply
code: /-- Forgetting the action of `L`, the spaces `weightSpace M χ` and `shiftedWeightSpace R L M χ` are
equivalent. -/
@[simps!] def shift : weightSpace M χ ≃ₗ[R] shiftedWeightSpace R L M χ 
goal: ∀ (a : ↥↑(LieModule.weightSpace M χ)), (LieModule.shiftedWeightSpace.shift R L M χ).symm a = a

full_name: LieModule.shiftedWeightSpace.shift
code: /-- Forgetting the action of `L`, the spaces `weightSpace M χ` and `shiftedWeightSpace R L M χ` are
equivalent. -/
@[simps!] def shift : weightSpace M χ ≃ₗ[R] shiftedWeightSpace R L M χ 
goal: ↥↑(LieModule.weightSpace M χ) ≃ₗ[R] ↥↑(LieModule.shiftedWeightSpace R L M χ)

full_name: LieModule.shiftedWeightSpace.toEnd_eq
code: lemma toEnd_eq (x : L) :
    toEnd R L (shiftedWeightSpace R L M χ) x =
    (shift R L M χ).conj (toEnd R L (weightSpace M χ) x - χ x • LinearMap.id) 
goal: (LieModule.toEnd R L ↥↑(LieModule.shiftedWeightSpace R L M χ)) x =
  (LieModule.shiftedWeightSpace.shift R L M χ).conj
    ((LieModule.toEnd R L ↥↑(LieModule.weightSpace M χ)) x - χ x • LinearMap.id)

full_name: LieModule.shiftedWeightSpace.instIsNilpotentSubtypeMemSubmoduleOfIsNoetherian
code: /-- By Engel's theorem, if `M` is Noetherian, the shifted action `⁅x, m⁆ - χ x • m` makes the
`χ`-weight space into a nilpotent Lie module. -/
instance [IsNoetherian R M] : IsNilpotent R L (shiftedWeightSpace R L M χ) 
goal: LieModule.IsNilpotent R L ↥↑(LieModule.shiftedWeightSpace R L M χ)

full_name: LieModule.exists_forall_lie_eq_smul
code: /-- Given a Lie module `M` of a Lie algebra `L` with coefficients in `R`, if a function `χ : L → R`
has a simultaneous generalized eigenvector for the action of `L` then it has a simultaneous true
eigenvector, provided `M` is Noetherian and has linear weights. -/
lemma exists_forall_lie_eq_smul [IsNoetherian R M] (χ : Weight R L M) :
    ∃ m : M, m ≠ 0 ∧ ∀ x : L, ⁅x, m⁆ = χ x • m 
goal: ∃ m, m ≠ 0 ∧ ∀ (x : L), ⁅x, m⁆ = χ x • m