File: Mathlib/Algebra/Lie/TraceForm.lean

full_name: _aux_Mathlib_Algebra_Lie_TraceForm___unexpand_LieModule_toEnd_1
code: local notation "φ" => LieModule.toEnd R L M
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_Algebra_Lie_TraceForm___macroRules_termφ_1
code: local notation "φ" => LieModule.toEnd R L M
goal: Lean.Macro

full_name: LieModule.traceForm
code: /-- A finite, free representation of a Lie algebra `L` induces a bilinear form on `L` called
the trace Form. See also `killingForm`. -/
noncomputable def traceForm : LinearMap.BilinForm R L 
goal: LinearMap.BilinForm R L

full_name: LieModule.traceForm_apply_apply
code: lemma traceForm_apply_apply (x y : L) :
    traceForm R L M x y = trace R _ (φ x ∘ₗ φ y) 
goal: ((LieModule.traceForm R L M) x) y = (LinearMap.trace R M) (φ x ∘ₗ φ y)

full_name: LieModule.traceForm_comm
code: lemma traceForm_comm (x y : L) : traceForm R L M x y = traceForm R L M y x 
goal: ((LieModule.traceForm R L M) x) y = ((LieModule.traceForm R L M) y) x

full_name: LieModule.traceForm_isSymm
code: lemma traceForm_isSymm : LinearMap.IsSymm (traceForm R L M) 
goal: LinearMap.IsSymm (LieModule.traceForm R L M)

full_name: LieModule.traceForm_flip
code: @[simp] lemma traceForm_flip : LinearMap.flip (traceForm R L M) = traceForm R L M 
goal: LinearMap.flip (LieModule.traceForm R L M) = LieModule.traceForm R L M

full_name: LieModule.traceForm_apply_lie_apply
code: /-- The trace form of a Lie module is compatible with the action of the Lie algebra.

See also `LieModule.traceForm_apply_lie_apply'`. -/
lemma traceForm_apply_lie_apply (x y z : L) :
    traceForm R L M ⁅x, y⁆ z = traceForm R L M x ⁅y, z⁆ 
goal: ((LieModule.traceForm R L M) ⁅x, y⁆) z = ((LieModule.traceForm R L M) x) ⁅y, z⁆

full_name: LieModule.traceForm_apply_lie_apply'
code: /-- Given a representation `M` of a Lie algebra `L`, the action of any `x : L` is skew-adjoint wrt
the trace form. -/
lemma traceForm_apply_lie_apply' (x y z : L) :
    traceForm R L M ⁅x, y⁆ z = - traceForm R L M y ⁅x, z⁆ 
goal: ((LieModule.traceForm R L M) ⁅x, y⁆) z = -((LieModule.traceForm R L M) y) ⁅x, z⁆

full_name: LieModule.traceForm_lieInvariant
code: lemma traceForm_lieInvariant : (traceForm R L M).lieInvariant L 
goal: LinearMap.BilinForm.lieInvariant L (LieModule.traceForm R L M)

full_name: LieModule.lie_traceForm_eq_zero
code: /-- This lemma justifies the terminology "invariant" for trace forms. -/
@[simp] lemma lie_traceForm_eq_zero (x : L) : ⁅x, traceForm R L M⁆ = 0 
goal: ⁅x, LieModule.traceForm R L M⁆ = 0

full_name: LieModule.traceForm_eq_zero_of_isNilpotent
code: @[simp] lemma traceForm_eq_zero_of_isNilpotent [IsReduced R] [IsNilpotent R L M] :
    traceForm R L M = 0 
goal: LieModule.traceForm R L M = 0

full_name: LieModule.traceForm_weightSpace_eq
code: @[simp]
lemma traceForm_weightSpace_eq [IsDomain R] [IsPrincipalIdealRing R]
    [LieAlgebra.IsNilpotent R L] [IsNoetherian R M] [LinearWeights R L M] (χ : L → R) (x y : L) :
    traceForm R L (weightSpace M χ) x y = finrank R (weightSpace M χ) • (χ x * χ y) 
goal: ((LieModule.traceForm R L ↥↑(LieModule.weightSpace M χ)) x) y =
  FiniteDimensional.finrank R ↥↑(LieModule.weightSpace M χ) • (χ x * χ y)

full_name: LieModule.traceForm_eq_zero_if_mem_lcs_of_mem_ucs
code: /-- The upper and lower central series of `L` are orthogonal wrt the trace form of any Lie module
`M`. -/
lemma traceForm_eq_zero_if_mem_lcs_of_mem_ucs {x y : L} (k : ℕ)
    (hx : x ∈ (⊤ : LieIdeal R L).lcs L k) (hy : y ∈ (⊥ : LieIdeal R L).ucs k) :
    traceForm R L M x y = 0 
goal: ((LieModule.traceForm R L M) x) y = 0

full_name: LieModule.traceForm_apply_eq_zero_of_mem_lcs_of_mem_center
code: lemma traceForm_apply_eq_zero_of_mem_lcs_of_mem_center {x y : L}
    (hx : x ∈ lowerCentralSeries R L L 1) (hy : y ∈ LieAlgebra.center R L) :
    traceForm R L M x y = 0 
goal: ((LieModule.traceForm R L M) x) y = 0

full_name: LieModule.traceForm_eq_zero_of_isTrivial
code: @[simp] lemma traceForm_eq_zero_of_isTrivial [IsTrivial L M] :
    traceForm R L M = 0 
goal: LieModule.traceForm R L M = 0

full_name: LieModule.eq_zero_of_mem_weightSpace_mem_posFitting
code: /-- Given a bilinear form `B` on a representation `M` of a nilpotent Lie algebra `L`, if `B` is
invariant (in the sense that the action of `L` is skew-adjoint wrt `B`) then components of the
Fitting decomposition of `M` are orthogonal wrt `B`. -/
lemma eq_zero_of_mem_weightSpace_mem_posFitting [LieAlgebra.IsNilpotent R L]
    {B : LinearMap.BilinForm R M} (hB : ∀ (x : L) (m n : M), B ⁅x, m⁆ n = - B m ⁅x, n⁆)
    {m₀ m₁ : M} (hm₀ : m₀ ∈ weightSpace M (0 : L → R)) (hm₁ : m₁ ∈ posFittingComp R L M) :
    B m₀ m₁ = 0 
goal: (B m₀) m₁ = 0

full_name: LieModule.trace_toEnd_eq_zero_of_mem_lcs
code: lemma trace_toEnd_eq_zero_of_mem_lcs
    {k : ℕ} {x : L} (hk : 1 ≤ k) (hx : x ∈ lowerCentralSeries R L L k) :
    trace R _ (toEnd R L M x) = 0 
goal: (LinearMap.trace R M) (φ x) = 0

full_name: LieModule.traceForm_lieSubalgebra_mk_left
code: @[simp]
lemma traceForm_lieSubalgebra_mk_left (L' : LieSubalgebra R L) {x : L} (hx : x ∈ L') (y : L') :
    traceForm R L' M ⟨x, hx⟩ y = traceForm R L M x y 
goal: ((LieModule.traceForm R (↥L') M) ⟨x, hx⟩) y = ((LieModule.traceForm R L M) x) ↑y

full_name: LieModule.traceForm_lieSubalgebra_mk_right
code: @[simp]
lemma traceForm_lieSubalgebra_mk_right (L' : LieSubalgebra R L) {x : L'} {y : L} (hy : y ∈ L') :
    traceForm R L' M x ⟨y, hy⟩ = traceForm R L M x y 
goal: ((LieModule.traceForm R (↥L') M) x) ⟨y, hy⟩ = ((LieModule.traceForm R L M) ↑x) y

full_name: LieModule.traceForm_eq_sum_weightSpaceOf
code: lemma traceForm_eq_sum_weightSpaceOf [IsTriangularizable R L M] (z : L) :
    traceForm R L M =
    ∑ χ ∈ (finite_weightSpaceOf_ne_bot R L M z).toFinset, traceForm R L (weightSpaceOf M χ z) 
goal: LieModule.traceForm R L M = ∑ χ ∈ ⋯.toFinset, LieModule.traceForm R L ↥↑(LieModule.weightSpaceOf M χ z)

full_name: LieModule.lowerCentralSeries_one_inf_center_le_ker_traceForm
code: lemma lowerCentralSeries_one_inf_center_le_ker_traceForm :
    lowerCentralSeries R L L 1 ⊓ LieAlgebra.center R L ≤ LinearMap.ker (traceForm R L M) 
goal: (lieIdealSubalgebra R L (LieModule.lowerCentralSeries R L L 1 ⊓ LieAlgebra.center R L)).toSubmodule ≤
  LinearMap.ker (LieModule.traceForm R L M)

full_name: LieModule.isLieAbelian_of_ker_traceForm_eq_bot
code: /-- A nilpotent Lie algebra with a representation whose trace form is non-singular is Abelian. -/
lemma isLieAbelian_of_ker_traceForm_eq_bot (h : LinearMap.ker (traceForm R L M) = ⊥) :
    IsLieAbelian L 
goal: IsLieAbelian L

full_name: LieSubmodule.trace_eq_trace_restrict_of_le_idealizer
code: lemma trace_eq_trace_restrict_of_le_idealizer
    (hy' : ∀ m ∈ N, (φ x ∘ₗ φ y) m ∈ N := fun m _ ↦ N.lie_mem (N.mem_idealizer.mp (h hy) m)) :
    trace R M (φ x ∘ₗ φ y) = trace R N ((φ x ∘ₗ φ y).restrict hy') 
goal: (LinearMap.trace R M) (φ x ∘ₗ φ y) = (LinearMap.trace R ↥↑N) ((φ x ∘ₗ φ y).restrict hy')

full_name: LieSubmodule.traceForm_eq_of_le_idealizer
code: lemma traceForm_eq_of_le_idealizer :
    traceForm R I N = (traceForm R L M).restrict I 
goal: LieModule.traceForm R ↥↑I ↥↑N = (LieModule.traceForm R L M).restrict (lieIdealSubalgebra R L I).toSubmodule

full_name: LieSubmodule.traceForm_eq_zero_of_isTrivial
code: /-- Note that this result is slightly stronger than it might look at first glance: we only assume
that `N` is trivial over `I` rather than all of `L`. This means that it applies in the important
case of an Abelian ideal (which has `M = L` and `N = I`). -/
lemma traceForm_eq_zero_of_isTrivial [LieModule.IsTrivial I N] :
    trace R M (φ x ∘ₗ φ y) = 0 
goal: (LinearMap.trace R M) (φ x ∘ₗ φ y) = 0

full_name: killingForm
code: /-- A finite, free (as an `R`-module) Lie algebra `L` carries a bilinear form on `L`.

This is a specialisation of `LieModule.traceForm` to the adjoint representation of `L`. -/
noncomputable abbrev killingForm : LinearMap.BilinForm R L 
goal: LinearMap.BilinForm R L

full_name: killingForm_apply_apply
code: lemma killingForm_apply_apply (x y : L) : killingForm R L x y = trace R L (ad R L x ∘ₗ ad R L y) 
goal: ((killingForm R L) x) y = (LinearMap.trace R L) ((LieAlgebra.ad R L) x ∘ₗ (LieAlgebra.ad R L) y)

full_name: killingForm_eq_zero_of_mem_zeroRoot_mem_posFitting
code: lemma killingForm_eq_zero_of_mem_zeroRoot_mem_posFitting
    (H : LieSubalgebra R L) [LieAlgebra.IsNilpotent R H]
    {x₀ x₁ : L}
    (hx₀ : x₀ ∈ LieAlgebra.zeroRootSubalgebra R L H)
    (hx₁ : x₁ ∈ LieModule.posFittingComp R H L) :
    killingForm R L x₀ x₁ = 0 
goal: ((killingForm R L) x₀) x₁ = 0

full_name: LieIdeal.killingCompl
code: /-- The orthogonal complement of an ideal with respect to the killing form is an ideal. -/
noncomputable def killingCompl : LieIdeal R L 
goal: LieIdeal R L

full_name: LieIdeal.toSubmodule_killingCompl
code: @[simp] lemma toSubmodule_killingCompl :
    LieSubmodule.toSubmodule I.killingCompl = (killingForm R L).orthogonal I.toSubmodule 
goal: ↑(LieIdeal.killingCompl R L I) = (killingForm R L).orthogonal ↑I

full_name: LieIdeal.mem_killingCompl
code: @[simp] lemma mem_killingCompl {x : L} :
    x ∈ I.killingCompl ↔ ∀ y ∈ I, killingForm R L y x = 0 
goal: x ∈ LieIdeal.killingCompl R L I ↔ ∀ y ∈ I, ((killingForm R L) y) x = 0

full_name: LieIdeal.coe_killingCompl_top
code: lemma coe_killingCompl_top :
    killingCompl R L ⊤ = LinearMap.ker (killingForm R L) 
goal: (lieIdealSubalgebra R L (LieIdeal.killingCompl R L ⊤)).toSubmodule = LinearMap.ker (killingForm R L)

full_name: LieIdeal.killingForm_eq
code: lemma killingForm_eq :
    killingForm R I = (killingForm R L).restrict I 
goal: killingForm R ↥↑I = (killingForm R L).restrict (lieIdealSubalgebra R L I).toSubmodule

full_name: LieIdeal.restrict_killingForm
code: lemma restrict_killingForm :
    (killingForm R L).restrict I = LieModule.traceForm R I L 
goal: (killingForm R L).restrict (lieIdealSubalgebra R L I).toSubmodule = LieModule.traceForm R (↥↑I) L

full_name: LieIdeal.le_killingCompl_top_of_isLieAbelian
code: @[simp] lemma le_killingCompl_top_of_isLieAbelian [IsLieAbelian I] :
    I ≤ LieIdeal.killingCompl R L ⊤ 
goal: I ≤ LieIdeal.killingCompl R L ⊤

full_name: LieModule.traceForm_eq_sum_finrank_nsmul_mul
code: lemma traceForm_eq_sum_finrank_nsmul_mul (x y : L) :
    traceForm K L M x y = ∑ χ : Weight K L M, finrank K (weightSpace M χ) • (χ x * χ y) 
goal: ((LieModule.traceForm K L M) x) y =
  ∑ χ : LieModule.Weight K L M, FiniteDimensional.finrank K ↥↑(LieModule.weightSpace M ⇑χ) • (χ x * χ y)

full_name: LieModule.traceForm_eq_sum_finrank_nsmul
code: lemma traceForm_eq_sum_finrank_nsmul :
    traceForm K L M = ∑ χ : Weight K L M, finrank K (weightSpace M χ) •
      (χ : L →ₗ[K] K).smulRight (χ : L →ₗ[K] K) 
goal: LieModule.traceForm K L M =
  ∑ χ : LieModule.Weight K L M,
    FiniteDimensional.finrank K ↥↑(LieModule.weightSpace M ⇑χ) •
      (LieModule.Weight.toLinear K L M χ).smulRight (LieModule.Weight.toLinear K L M χ)

full_name: LieModule.range_traceForm_le_span_weight
code: lemma range_traceForm_le_span_weight :
    LinearMap.range (traceForm K L M) ≤ span K (range (Weight.toLinear K L M)) 
goal: LinearMap.range (LieModule.traceForm K L M) ≤ Submodule.span K (Set.range (LieModule.Weight.toLinear K L M))