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

full_name: LieDerivation
code: /-- A Lie derivation `D` from the Lie `R`-algebra `L` to the `L`-module `M` is an `R`-linear map
that satisfies the Leibniz rule `D [a, b] = [a, D b] - [b, D a]`. -/
structure LieDerivation (R L M : Type*) [CommRing R] [LieRing L] [LieAlgebra R L]
    [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M]
    extends L →ₗ[R] M where
  protected leibniz' (a b : L) : toLinearMap ⁅a, b⁆ = ⁅a, toLinearMap b⁆ - ⁅b, toLinearMap a⁆
goal: Type (max u_2 u_3)

full_name: LieDerivation.leibniz'
code: /-- A Lie derivation `D` from the Lie `R`-algebra `L` to the `L`-module `M` is an `R`-linear map
that satisfies the Leibniz rule `D [a, b] = [a, D b] - [b, D a]`. -/
structure LieDerivation (R L M : Type*) [CommRing R] [LieRing L] [LieAlgebra R L]
    [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L M]
    extends L →ₗ[R] M where
  protected leibniz' (a b : L) : toLinearMap ⁅a, b⁆ = ⁅a, toLinearMap b⁆ - ⁅b, toLinearMap a⁆
goal: ↑self ⁅a, b⁆ = ⁅a, ↑self b⁆ - ⁅b, ↑self a⁆

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

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

full_name: LieDerivation.toFun_eq_coe
code: theorem toFun_eq_coe : D.toFun = ⇑D 
goal: (↑D).toFun = ⇑D

full_name: LieDerivation.Simps.apply
code: /-- See Note [custom simps projection] -/
def Simps.apply (D : LieDerivation R L M) : L → M 
goal: L → M

full_name: LieDerivation.instCoeToLinearMap
code: instance instCoeToLinearMap : Coe (LieDerivation R L M) (L →ₗ[R] M) 
goal: Coe (LieDerivation R L M) (L →ₗ[R] M)

full_name: LieDerivation.mk_coe
code: @[simp]
theorem mk_coe (f : L →ₗ[R] M) (h₁) : ((⟨f, h₁⟩ : LieDerivation R L M) : L → M) = f 
goal: ⇑{ toLinearMap := f, leibniz' := h₁ } = ⇑f

full_name: LieDerivation.coeFn_coe
code: @[simp, norm_cast]
theorem coeFn_coe (f : LieDerivation R L M) : ⇑(f : L →ₗ[R] M) = f 
goal: ⇑↑f = ⇑f

full_name: LieDerivation.coe_injective
code: theorem coe_injective : @Function.Injective (LieDerivation R L M) (L → M) DFunLike.coe 
goal: Function.Injective DFunLike.coe

full_name: LieDerivation.ext
code: @[ext]
theorem ext (H : ∀ a, D1 a = D2 a) : D1 = D2 
goal: D1 = D2

full_name: LieDerivation.congr_fun
code: theorem congr_fun (h : D1 = D2) (a : L) : D1 a = D2 a 
goal: D1 a = D2 a

full_name: LieDerivation.apply_lie_eq_sub
code: @[simp]
lemma apply_lie_eq_sub (D : LieDerivation R L M) (a b : L) :
    D ⁅a, b⁆ = ⁅a, D b⁆ - ⁅b, D a⁆ 
goal: D ⁅a, b⁆ = ⁅a, D b⁆ - ⁅b, D a⁆

full_name: LieDerivation.apply_lie_eq_add
code: /-- For a Lie derivation from a Lie algebra to itself, the usual Leibniz rule holds. -/
lemma apply_lie_eq_add (D : LieDerivation R L L) (a b : L) :
    D ⁅a, b⁆ = ⁅a, D b⁆ + ⁅D a, b⁆ 
goal: D ⁅a, b⁆ = ⁅a, D b⁆ + ⁅D a, b⁆

full_name: LieDerivation.eqOn_lieSpan
code: /-- Two Lie derivations equal on a set are equal on its Lie span. -/
theorem eqOn_lieSpan {s : Set L} (h : Set.EqOn D1 D2 s) :
    Set.EqOn D1 D2 (LieSubalgebra.lieSpan R L s) 
goal: Set.EqOn ⇑D1 ⇑D2 ↑(LieSubalgebra.lieSpan R L s)

full_name: LieDerivation.ext_of_lieSpan_eq_top
code: /-- If the Lie span of a set is the whole Lie algebra, then two Lie derivations equal on this set
are equal on the whole Lie algebra. -/
theorem ext_of_lieSpan_eq_top (s : Set L) (hs : LieSubalgebra.lieSpan R L s = ⊤)
    (h : Set.EqOn D1 D2 s) : D1 = D2 
goal: D1 = D2

full_name: LieDerivation.instZero
code: instance instZero : Zero (LieDerivation R L M) 
goal: Zero (LieDerivation R L M)

full_name: LieDerivation.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : LieDerivation R L M) = 0 
goal: ⇑0 = 0

full_name: LieDerivation.coe_zero_linearMap
code: @[simp]
theorem coe_zero_linearMap : ↑(0 : LieDerivation R L M) = (0 : L →ₗ[R] M) 
goal: ↑0 = 0

full_name: LieDerivation.zero_apply
code: theorem zero_apply (a : L) : (0 : LieDerivation R L M) a = 0 
goal: 0 a = 0

full_name: LieDerivation.instInhabited
code: instance : Inhabited (LieDerivation R L M) 
goal: Inhabited (LieDerivation R L M)

full_name: LieDerivation.instAdd
code: instance instAdd : Add (LieDerivation R L M) 
goal: Add (LieDerivation R L M)

full_name: LieDerivation.coe_add
code: @[simp]
theorem coe_add (D1 D2 : LieDerivation R L M) : ⇑(D1 + D2) = D1 + D2 
goal: ⇑(D1 + D2) = ⇑D1 + ⇑D2

full_name: LieDerivation.coe_add_linearMap
code: @[simp]
theorem coe_add_linearMap (D1 D2 : LieDerivation R L M) : ↑(D1 + D2) = (D1 + D2 : L →ₗ[R] M) 
goal: ↑(D1 + D2) = ↑D1 + ↑D2

full_name: LieDerivation.add_apply
code: theorem add_apply : (D1 + D2) a = D1 a + D2 a 
goal: (D1 + D2) a = D1 a + D2 a

full_name: LieDerivation.map_neg
code: protected theorem map_neg : D (-a) = -D a 
goal: D (-a) = -D a

full_name: LieDerivation.map_sub
code: protected theorem map_sub : D (a - b) = D a - D b 
goal: D (a - b) = D a - D b

full_name: LieDerivation.instNeg
code: instance instNeg : Neg (LieDerivation R L M) 
goal: Neg (LieDerivation R L M)

full_name: LieDerivation.coe_neg
code: @[simp]
theorem coe_neg (D : LieDerivation R L M) : ⇑(-D) = -D 
goal: ⇑(-D) = -⇑D

full_name: LieDerivation.coe_neg_linearMap
code: @[simp]
theorem coe_neg_linearMap (D : LieDerivation R L M) : ↑(-D) = (-D : L →ₗ[R] M) 
goal: ↑(-D) = -↑D

full_name: LieDerivation.neg_apply
code: theorem neg_apply : (-D) a = -D a 
goal: (-D) a = -D a

full_name: LieDerivation.instSub
code: instance instSub : Sub (LieDerivation R L M) 
goal: Sub (LieDerivation R L M)

full_name: LieDerivation.coe_sub
code: @[simp]
theorem coe_sub (D1 D2 : LieDerivation R L M) : ⇑(D1 - D2) = D1 - D2 
goal: ⇑(D1 - D2) = ⇑D1 - ⇑D2

full_name: LieDerivation.coe_sub_linearMap
code: @[simp]
theorem coe_sub_linearMap (D1 D2 : LieDerivation R L M) : ↑(D1 - D2) = (D1 - D2 : L →ₗ[R] M) 
goal: ↑(D1 - D2) = ↑D1 - ↑D2

full_name: LieDerivation.sub_apply
code: theorem sub_apply {D1 D2 : LieDerivation R L M} : (D1 - D2) a = D1 a - D2 a 
goal: (D1 - D2) a = D1 a - D2 a

full_name: LieDerivation.SMulBracketCommClass.smul_bracket_comm
code: /-- A typeclass mixin saying that scalar multiplication and Lie bracket are left commutative. -/
class SMulBracketCommClass (S L α : Type*) [SMul S α] [LieRing L] [AddCommGroup α]
    [LieRingModule L α] : Prop where
  /-- `•` and `⁅⬝, ⬝⁆`  are left commutative -/
  smul_bracket_comm : ∀ (s : S) (l : L) (a : α), s • ⁅l, a⁆ = ⁅l, s • a⁆
goal: s • ⁅l, a⁆ = ⁅l, s • a⁆

full_name: LieDerivation.SMulBracketCommClass
code: /-- A typeclass mixin saying that scalar multiplication and Lie bracket are left commutative. -/
class SMulBracketCommClass (S L α : Type*) [SMul S α] [LieRing L] [AddCommGroup α]
    [LieRingModule L α] : Prop where
  /-- `•` and `⁅⬝, ⬝⁆`  are left commutative -/
  smul_bracket_comm : ∀ (s : S) (l : L) (a : α), s • ⁅l, a⁆ = ⁅l, s • a⁆
goal: Prop

full_name: LieDerivation.instSMul
code: instance instSMul : SMul S (LieDerivation R L M) 
goal: SMul S (LieDerivation R L M)

full_name: LieDerivation.coe_smul
code: @[simp]
theorem coe_smul (r : S) (D : LieDerivation R L M) : ⇑(r • D) = r • ⇑D 
goal: ⇑(r • D) = r • ⇑D

full_name: LieDerivation.coe_smul_linearMap
code: @[simp]
theorem coe_smul_linearMap (r : S) (D : LieDerivation R L M) : ↑(r • D) = r • (D : L →ₗ[R] M) 
goal: ↑(r • D) = r • ↑D

full_name: LieDerivation.smul_apply
code: theorem smul_apply (r : S) (D : LieDerivation R L M) : (r • D) a = r • D a 
goal: (r • D) a = r • D a

full_name: LieDerivation.instSMulBase
code: instance instSMulBase : SMulBracketCommClass R L M 
goal: LieDerivation.SMulBracketCommClass R L M

full_name: LieDerivation.instSMulNat
code: instance instSMulNat : SMulBracketCommClass ℕ L M 
goal: LieDerivation.SMulBracketCommClass ℕ L M

full_name: LieDerivation.instSMulInt
code: instance instSMulInt : SMulBracketCommClass ℤ L M 
goal: LieDerivation.SMulBracketCommClass ℤ L M

full_name: LieDerivation.instAddCommGroup
code: instance instAddCommGroup : AddCommGroup (LieDerivation R L M) 
goal: AddCommGroup (LieDerivation R L M)

full_name: LieDerivation.coeFnAddMonoidHom
code: /-- `coe_fn` as an `AddMonoidHom`. -/
def coeFnAddMonoidHom : LieDerivation R L M →+ L → M 
goal: LieDerivation R L M →+ L → M

full_name: LieDerivation.instDistribMulAction
code: instance : DistribMulAction S (LieDerivation R L M) 
goal: DistribMulAction S (LieDerivation R L M)

full_name: LieDerivation.instIsScalarTower
code: instance [SMul S T] [IsScalarTower S T M] : IsScalarTower S T (LieDerivation R L M) 
goal: IsScalarTower S T (LieDerivation R L M)

full_name: LieDerivation.instSMulCommClass
code: instance [SMulCommClass S T M] : SMulCommClass S T (LieDerivation R L M) 
goal: SMulCommClass S T (LieDerivation R L M)

full_name: LieDerivation.instModule
code: instance instModule {S : Type*} [Semiring S] [Module S M] [SMulCommClass R S M]
    [SMulBracketCommClass S L M] : Module S (LieDerivation R L M) 
goal: Module S (LieDerivation R L M)

full_name: LieDerivation.instBracket
code: /-- The commutator of two Lie derivations on a Lie algebra is a Lie derivation. -/
instance instBracket : Bracket (LieDerivation R L L) (LieDerivation R L L) 
goal: Bracket (LieDerivation R L L) (LieDerivation R L L)

full_name: LieDerivation.commutator_coe_linear_map
code: @[simp]
lemma commutator_coe_linear_map : ↑⁅D1, D2⁆ = ⁅(D1 : Module.End R L), (D2 : Module.End R L)⁆ 
goal: ↑⁅D1, D2⁆ = ⁅↑D1, ↑D2⁆

full_name: LieDerivation.commutator_apply
code: lemma commutator_apply (a : L) : ⁅D1, D2⁆ a = D1 (D2 a) - D2 (D1 a) 
goal: ⁅D1, D2⁆ a = D1 (D2 a) - D2 (D1 a)

full_name: LieDerivation.instLieRing
code: instance : LieRing (LieDerivation R L L) 
goal: LieRing (LieDerivation R L L)

full_name: LieDerivation.instLieAlgebra
code: /-- The set of Lie derivations from a Lie algebra `L` to itself is a Lie algebra. -/
instance instLieAlgebra : LieAlgebra R (LieDerivation R L L) 
goal: LieAlgebra R (LieDerivation R L L)

full_name: LieDerivation.lie_apply
code: @[simp] lemma lie_apply (D₁ D₂ : LieDerivation R L L) (x : L) :
    ⁅D₁, D₂⁆ x = D₁ (D₂ x) - D₂ (D₁ x) 
goal: ⁅D₁, D₂⁆ x = D₁ (D₂ x) - D₂ (D₁ x)

full_name: LieDerivation.toLinearMapLieHom
code: /-- The Lie algebra morphism from Lie derivations into linear endormophisms. -/
def toLinearMapLieHom : LieDerivation R L L →ₗ⁅R⁆ L →ₗ[R] L 
goal: LieDerivation R L L →ₗ⁅R⁆ L →ₗ[R] L

full_name: LieDerivation.toLinearMapLieHom_injective
code: /-- The map from Lie derivations to linear endormophisms is injective. -/
lemma toLinearMapLieHom_injective : Function.Injective (toLinearMapLieHom R L) 
goal: Function.Injective ⇑(LieDerivation.toLinearMapLieHom R L)

full_name: LieDerivation.instNoetherian
code: /-- Lie derivations over a Noetherian Lie algebra form a Noetherian module. -/
instance instNoetherian [IsNoetherian R L] : IsNoetherian R (LieDerivation R L L) 
goal: IsNoetherian R (LieDerivation R L L)

full_name: LieDerivation.inner_apply_apply
code: /-- The natural map from a Lie module to the derivations taking values in it. -/
@[simps!]
def inner : M →ₗ[R] LieDerivation R L M 
goal: ∀ (m_1 : L), ((LieDerivation.inner R L M) m) m_1 = ⁅m_1, m⁆

full_name: LieDerivation.inner
code: /-- The natural map from a Lie module to the derivations taking values in it. -/
@[simps!]
def inner : M →ₗ[R] LieDerivation R L M 
goal: M →ₗ[R] LieDerivation R L M

full_name: LieDerivation.instLieRingModule
code: instance instLieRingModule : LieRingModule L (LieDerivation R L M) 
goal: LieRingModule L (LieDerivation R L M)

full_name: LieDerivation.lie_lieDerivation_apply
code: @[simp] lemma lie_lieDerivation_apply (x y : L) (D : LieDerivation R L M) :
    ⁅x, D⁆ y = ⁅y, D x⁆ 
goal: ⁅x, D⁆ y = ⁅y, D x⁆

full_name: LieDerivation.lie_coe_lieDerivation_apply
code: @[simp] lemma lie_coe_lieDerivation_apply (x : L) (D : LieDerivation R L M) :
    ⁅x, (D : L →ₗ[R] M)⁆ = ⁅x, D⁆ 
goal: ⁅x, ↑D⁆ = ↑⁅x, D⁆

full_name: LieDerivation.instLieModule
code: instance instLieModule : LieModule R L (LieDerivation R L M) 
goal: LieModule R L (LieDerivation R L M)

full_name: LieDerivation.leibniz_lie
code: protected lemma leibniz_lie (x : L) (D₁ D₂ : LieDerivation R L L) :
    ⁅x, ⁅D₁, D₂⁆⁆ = ⁅⁅x, D₁⁆, D₂⁆ + ⁅D₁, ⁅x, D₂⁆⁆ 
goal: ⁅x, ⁅D₁, D₂⁆⁆ = ⁅⁅x, D₁⁆, D₂⁆ + ⁅D₁, ⁅x, D₂⁆⁆