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

full_name: LieAlgebra.IsKilling.ker_restrict_eq_bot_of_isCartanSubalgebra
code: /-- If the Killing form of a Lie algebra is non-singular, it remains non-singular when restricted
to a Cartan subalgebra. -/
lemma ker_restrict_eq_bot_of_isCartanSubalgebra
    [IsNoetherian R L] [IsArtinian R L] (H : LieSubalgebra R L) [H.IsCartanSubalgebra] :
    LinearMap.ker ((killingForm R L).restrict H) = ⊥ 
goal: LinearMap.ker ((killingForm R L).restrict H.toSubmodule) = ⊥

full_name: LieAlgebra.IsKilling.restrict_killingForm
code: lemma restrict_killingForm (H : LieSubalgebra R L) :
    (killingForm R L).restrict H = LieModule.traceForm R H L 
goal: (killingForm R L).restrict H.toSubmodule = LieModule.traceForm R (↥H) L

full_name: LieAlgebra.IsKilling.ker_traceForm_eq_bot_of_isCartanSubalgebra
code: @[simp] lemma ker_traceForm_eq_bot_of_isCartanSubalgebra
    [IsNoetherian R L] [IsArtinian R L] (H : LieSubalgebra R L) [H.IsCartanSubalgebra] :
    LinearMap.ker (LieModule.traceForm R H L) = ⊥ 
goal: LinearMap.ker (LieModule.traceForm R (↥H) L) = ⊥

full_name: LieAlgebra.IsKilling.traceForm_cartan_nondegenerate
code: lemma traceForm_cartan_nondegenerate
    [IsNoetherian R L] [IsArtinian R L] (H : LieSubalgebra R L) [H.IsCartanSubalgebra] :
    (LieModule.traceForm R H L).Nondegenerate 
goal: (LieModule.traceForm R (↥H) L).Nondegenerate

full_name: LieAlgebra.IsKilling.instIsLieAbelianOfIsCartanSubalgebra
code: instance instIsLieAbelianOfIsCartanSubalgebra
    [IsDomain R] [IsPrincipalIdealRing R] [IsArtinian R L]
    (H : LieSubalgebra R L) [H.IsCartanSubalgebra] :
    IsLieAbelian H 
goal: IsLieAbelian ↥H

full_name: LieAlgebra.killingForm_apply_eq_zero_of_mem_rootSpace_of_add_ne_zero
code: /-- For any `α` and `β`, the corresponding root spaces are orthogonal with respect to the Killing
form, provided `α + β ≠ 0`. -/
lemma killingForm_apply_eq_zero_of_mem_rootSpace_of_add_ne_zero {α β : H → K} {x y : L}
    (hx : x ∈ rootSpace H α) (hy : y ∈ rootSpace H β) (hαβ : α + β ≠ 0) :
    killingForm K L x y = 0 
goal: ((killingForm K L) x) y = 0

full_name: LieAlgebra.mem_ker_killingForm_of_mem_rootSpace_of_forall_rootSpace_neg
code: /-- Elements of the `α` root space which are Killing-orthogonal to the `-α` root space are
Killing-orthogonal to all of `L`. -/
lemma mem_ker_killingForm_of_mem_rootSpace_of_forall_rootSpace_neg
    {α : H → K} {x : L} (hx : x ∈ rootSpace H α)
    (hx' : ∀ y ∈ rootSpace H (-α), killingForm K L x y = 0) :
    x ∈ LinearMap.ker (killingForm K L) 
goal: x ∈ LinearMap.ker (killingForm K L)

full_name: LieAlgebra.IsKilling.eq_zero_of_isNilpotent_ad_of_mem_isCartanSubalgebra
code: /-- If a Lie algebra `L` has non-degenerate Killing form, the only element of a Cartan subalgebra
whose adjoint action on `L` is nilpotent, is the zero element.

Over a perfect field a much stronger result is true, see
`LieAlgebra.IsKilling.isSemisimple_ad_of_mem_isCartanSubalgebra`. -/
lemma eq_zero_of_isNilpotent_ad_of_mem_isCartanSubalgebra {x : L} (hx : x ∈ H)
    (hx' : _root_.IsNilpotent (ad K L x)) : x = 0 
goal: x = 0

full_name: LieAlgebra.IsKilling.cartanEquivDual
code: /-- The restriction of the Killing form to a Cartan subalgebra, as a linear equivalence to the
dual. -/
@[simps! apply_apply]
noncomputable def cartanEquivDual :
    H ≃ₗ[K] Module.Dual K H 
goal: ↥H ≃ₗ[K] Module.Dual K ↥H

full_name: LieAlgebra.IsKilling.cartanEquivDual_apply_apply
code: /-- The restriction of the Killing form to a Cartan subalgebra, as a linear equivalence to the
dual. -/
@[simps! apply_apply]
noncomputable def cartanEquivDual :
    H ≃ₗ[K] Module.Dual K H 
goal: ∀ (a m : ↥H),
  ((LieAlgebra.IsKilling.cartanEquivDual H) a) m =
    (LinearMap.trace K L) ((LieModule.toEnd K (↥H) L) a * (LieModule.toEnd K (↥H) L) m)

full_name: LieAlgebra.IsKilling.lie_eq_killingForm_smul_of_mem_rootSpace_of_mem_rootSpace_neg_aux
code: lemma lie_eq_killingForm_smul_of_mem_rootSpace_of_mem_rootSpace_neg_aux
    {α : Weight K H L} {e f : L} (heα : e ∈ rootSpace H α) (hfα : f ∈ rootSpace H (-α))
    (aux : ∀ (h : H), ⁅h, e⁆ = α h • e) :
    ⁅e, f⁆ = killingForm K L e f • (cartanEquivDual H).symm α 
goal: ⁅e, f⁆ =
  ((killingForm K L) e) f • ↑((LieAlgebra.IsKilling.cartanEquivDual H).symm (LieModule.Weight.toLinear K (↥H) L α))

full_name: LieAlgebra.IsKilling.cartanEquivDual_symm_apply_mem_corootSpace
code: /-- This is Proposition 4.18 from [carter2005] except that we use
`LieModule.exists_forall_lie_eq_smul` instead of Lie's theorem (and so avoid
assuming `K` has characteristic zero). -/
lemma cartanEquivDual_symm_apply_mem_corootSpace (α : Weight K H L) :
    (cartanEquivDual H).symm α ∈ corootSpace α 
goal: (LieAlgebra.IsKilling.cartanEquivDual H).symm (LieModule.Weight.toLinear K (↥H) L α) ∈ LieAlgebra.corootSpace ⇑α

full_name: LieAlgebra.IsKilling.span_weight_eq_top
code: /-- Given a splitting Cartan subalgebra `H` of a finite-dimensional Lie algebra with non-singular
Killing form, the corresponding roots span the dual space of `H`. -/
@[simp]
lemma span_weight_eq_top :
    span K (range (Weight.toLinear K H L)) = ⊤ 
goal: Submodule.span K (Set.range (LieModule.Weight.toLinear K (↥H) L)) = ⊤

full_name: LieAlgebra.IsKilling.span_weight_isNonZero_eq_top
code: @[simp]
lemma span_weight_isNonZero_eq_top :
    span K ({α : Weight K H L | α.IsNonZero}.image (Weight.toLinear K H L)) = ⊤ 
goal: Submodule.span K (LieModule.Weight.toLinear K (↥H) L '' {α | α.IsNonZero}) = ⊤

full_name: LieAlgebra.IsKilling.iInf_ker_weight_eq_bot
code: @[simp]
lemma iInf_ker_weight_eq_bot :
    ⨅ α : Weight K H L, α.ker = ⊥ 
goal: ⨅ α, LieModule.Weight.ker = ⊥

full_name: LieAlgebra.IsKilling.corootSpace_zero_eq_bot
code: @[simp]
lemma corootSpace_zero_eq_bot :
    corootSpace (0 : H → K) = ⊥ 
goal: LieAlgebra.corootSpace 0 = ⊥

full_name: LieAlgebra.IsKilling.isSemisimple_ad_of_mem_isCartanSubalgebra
code: lemma isSemisimple_ad_of_mem_isCartanSubalgebra {x : L} (hx : x ∈ H) :
    (ad K L x).IsSemisimple 
goal: ((LieAlgebra.ad K L) x).IsSemisimple

full_name: LieAlgebra.IsKilling.lie_eq_smul_of_mem_rootSpace
code: lemma lie_eq_smul_of_mem_rootSpace {α : H → K} {x : L} (hx : x ∈ rootSpace H α) (h : H) :
    ⁅h, x⁆ = α h • x 
goal: ⁅h, x⁆ = α h • x

full_name: LieAlgebra.IsKilling.lie_eq_killingForm_smul_of_mem_rootSpace_of_mem_rootSpace_neg
code: lemma lie_eq_killingForm_smul_of_mem_rootSpace_of_mem_rootSpace_neg
    {α : Weight K H L} {e f : L} (heα : e ∈ rootSpace H α) (hfα : f ∈ rootSpace H (-α)) :
    ⁅e, f⁆ = killingForm K L e f • (cartanEquivDual H).symm α 
goal: ⁅e, f⁆ =
  ((killingForm K L) e) f • ↑((LieAlgebra.IsKilling.cartanEquivDual H).symm (LieModule.Weight.toLinear K (↥H) L α))

full_name: LieAlgebra.IsKilling.coe_corootSpace_eq_span_singleton'
code: lemma coe_corootSpace_eq_span_singleton' (α : Weight K H L) :
    (corootSpace α).toSubmodule = K ∙ (cartanEquivDual H).symm α 
goal: ↑(LieAlgebra.corootSpace ⇑α) =
  Submodule.span K {(LieAlgebra.IsKilling.cartanEquivDual H).symm (LieModule.Weight.toLinear K (↥H) L α)}

full_name: LieAlgebra.IsKilling.eq_zero_of_apply_eq_zero_of_mem_corootSpace
code: /-- The contrapositive of this result is very useful, taking `x` to be the element of `H`
corresponding to a root `α` under the identification between `H` and `H^*` provided by the Killing
form. -/
lemma eq_zero_of_apply_eq_zero_of_mem_corootSpace
    (x : H) (α : H → K) (hαx : α x = 0) (hx : x ∈ corootSpace α) :
    x = 0 
goal: x = 0

full_name: LieAlgebra.IsKilling.disjoint_ker_weight_corootSpace
code: lemma disjoint_ker_weight_corootSpace (α : Weight K H L) :
    Disjoint α.ker (corootSpace α) 
goal: Disjoint LieModule.Weight.ker (lieIdealSubalgebra K (↥H) (LieAlgebra.corootSpace ⇑α)).toSubmodule

full_name: LieAlgebra.IsKilling.coroot
code: /-- The coroot corresponding to a root. -/
noncomputable def coroot (α : Weight K H L) : H 
goal: ↥H

full_name: LieAlgebra.IsKilling.root_apply_cartanEquivDual_symm_ne_zero
code: lemma root_apply_cartanEquivDual_symm_ne_zero {α : Weight K H L} (hα : α.IsNonZero) :
    α ((cartanEquivDual H).symm α) ≠ 0 
goal: α ((LieAlgebra.IsKilling.cartanEquivDual H).symm (LieModule.Weight.toLinear K (↥H) L α)) ≠ 0

full_name: LieAlgebra.IsKilling.root_apply_coroot
code: lemma root_apply_coroot {α : Weight K H L} (hα : α.IsNonZero) :
    α (coroot α) = 2 
goal: α (LieAlgebra.IsKilling.coroot α) = 2

full_name: LieAlgebra.IsKilling.traceForm_coroot
code: lemma traceForm_coroot (α : Weight K H L) (x : H) :
    traceForm K H L (coroot α) x = 2 • (α <| (cartanEquivDual H).symm α)⁻¹ • α x 
goal: ((LieModule.traceForm K (↥H) L) (LieAlgebra.IsKilling.coroot α)) x =
  2 • (α ((LieAlgebra.IsKilling.cartanEquivDual H).symm (LieModule.Weight.toLinear K (↥H) L α)))⁻¹ • α x

full_name: LieAlgebra.IsKilling.coroot_eq_zero_iff
code: @[simp] lemma coroot_eq_zero_iff {α : Weight K H L} :
    coroot α = 0 ↔ α.IsZero 
goal: LieAlgebra.IsKilling.coroot α = 0 ↔ α.IsZero

full_name: LieAlgebra.IsKilling.coroot_zero
code: @[simp]
lemma coroot_zero [Nontrivial L] : coroot (0 : Weight K H L) = 0 
goal: LieAlgebra.IsKilling.coroot 0 = 0

full_name: LieAlgebra.IsKilling.coe_corootSpace_eq_span_singleton
code: lemma coe_corootSpace_eq_span_singleton (α : Weight K H L) :
    (corootSpace α).toSubmodule = K ∙ coroot α 
goal: ↑(LieAlgebra.corootSpace ⇑α) = Submodule.span K {LieAlgebra.IsKilling.coroot α}

full_name: LieAlgebra.IsKilling.corootSpace_eq_bot_iff
code: @[simp]
lemma corootSpace_eq_bot_iff {α : Weight K H L} :
    corootSpace α = ⊥ ↔ α.IsZero 
goal: LieAlgebra.corootSpace ⇑α = ⊥ ↔ α.IsZero

full_name: LieAlgebra.IsKilling.isCompl_ker_weight_span_coroot
code: lemma isCompl_ker_weight_span_coroot (α : Weight K H L) :
    IsCompl α.ker (K ∙ coroot α) 
goal: IsCompl LieModule.Weight.ker (Submodule.span K {LieAlgebra.IsKilling.coroot α})

full_name: LieAlgebra.IsKilling.traceForm_eq_zero_of_mem_ker_of_mem_span_coroot
code: lemma traceForm_eq_zero_of_mem_ker_of_mem_span_coroot {α : Weight K H L} {x y : H}
    (hx : x ∈ α.ker) (hy : y ∈ K ∙ coroot α) :
    traceForm K H L x y = 0 
goal: ((LieModule.traceForm K (↥H) L) x) y = 0

full_name: LieAlgebra.IsKilling.orthogonal_span_coroot_eq_ker
code: @[simp] lemma orthogonal_span_coroot_eq_ker (α : Weight K H L) :
    (traceForm K H L).orthogonal (K ∙ coroot α) = α.ker 
goal: (LieModule.traceForm K (↥H) L).orthogonal (Submodule.span K {LieAlgebra.IsKilling.coroot α}) = LieModule.Weight.ker

full_name: LieAlgebra.IsKilling.coroot_eq_iff
code: @[simp] lemma coroot_eq_iff (α β : Weight K H L) :
    coroot α = coroot β ↔ α = β 
goal: LieAlgebra.IsKilling.coroot α = LieAlgebra.IsKilling.coroot β ↔ α = β

full_name: LieAlgebra.IsKilling.exists_isSl2Triple_of_weight_isNonZero
code: lemma exists_isSl2Triple_of_weight_isNonZero {α : Weight K H L} (hα : α.IsNonZero) :
    ∃ h e f : L, IsSl2Triple h e f ∧ e ∈ rootSpace H α ∧ f ∈ rootSpace H (- α) 
goal: ∃ h e f, IsSl2Triple h e f ∧ e ∈ LieAlgebra.rootSpace H ⇑α ∧ f ∈ LieAlgebra.rootSpace H (-⇑α)

full_name: IsSl2Triple.h_eq_coroot
code: lemma _root_.IsSl2Triple.h_eq_coroot {α : Weight K H L} (hα : α.IsNonZero)
    {h e f : L} (ht : IsSl2Triple h e f) (heα : e ∈ rootSpace H α) (hfα : f ∈ rootSpace H (- α)) :
    h = coroot α 
goal: h = ↑(LieAlgebra.IsKilling.coroot α)

full_name: LieAlgebra.IsKilling.finrank_rootSpace_eq_one
code: lemma finrank_rootSpace_eq_one (α : Weight K H L) (hα : α.IsNonZero) :
    finrank K (rootSpace H α) = 1 
goal: FiniteDimensional.finrank K ↥↑(LieAlgebra.rootSpace H ⇑α) = 1

full_name: LieModule.Weight.instInvolutiveNegSubtypeMemLieSubalgebra
code: instance : InvolutiveNeg (Weight K H L) 
goal: InvolutiveNeg (LieModule.Weight K (↥H) L)

full_name: LieModule.Weight.coe_neg
code: @[simp] lemma coe_neg : ((-α : Weight K H L) : H → K) = -α 
goal: ⇑(-α) = -⇑α

full_name: LieModule.Weight.IsZero.neg
code: lemma IsZero.neg (h : α.IsZero) : (-α).IsZero 
goal: (-α).IsZero

full_name: LieModule.Weight.isZero_neg
code: @[simp] lemma isZero_neg : (-α).IsZero ↔ α.IsZero 
goal: (-α).IsZero ↔ α.IsZero

full_name: LieModule.Weight.IsNonZero.neg
code: lemma IsNonZero.neg (h : α.IsNonZero) : (-α).IsNonZero 
goal: (-α).IsNonZero

full_name: LieModule.Weight.isNonZero_neg
code: @[simp] lemma isNonZero_neg {α : Weight K H L} : (-α).IsNonZero ↔ α.IsNonZero 
goal: (-α).IsNonZero ↔ α.IsNonZero

full_name: LieModule.Weight.toLinear_neg
code: @[simp] lemma toLinear_neg {α : Weight K H L} : (-α).toLinear = -α.toLinear 
goal: LieModule.Weight.toLinear K (↥H) L (-α) = -LieModule.Weight.toLinear K (↥H) L α

full_name: LieAlgebra.IsKilling.coroot_neg
code: @[simp]
lemma _root_.LieAlgebra.IsKilling.coroot_neg (α : Weight K H L) : coroot (-α) = -coroot α 
goal: LieAlgebra.IsKilling.coroot (-α) = -LieAlgebra.IsKilling.coroot α