File: Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean

full_name: LeftInvariantDerivation.left_invariant''
code: /-- Left-invariant global derivations.

A global derivation is left-invariant if it is equal to its pullback along left multiplication by
an arbitrary element of `G`.
-/
structure LeftInvariantDerivation extends Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯ where
  left_invariant'' :
    ∀ g, 𝒅ₕ (smoothLeftMul_one I g) (Derivation.evalAt 1 toDerivation) =
      Derivation.evalAt g toDerivation
goal: (𝒅ₕ ⋯) ((Derivation.evalAt 1) ↑self) = (Derivation.evalAt g) ↑self

full_name: LeftInvariantDerivation
code: /-- Left-invariant global derivations.

A global derivation is left-invariant if it is equal to its pullback along left multiplication by
an arbitrary element of `G`.
-/
structure LeftInvariantDerivation extends Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯ where
  left_invariant'' :
    ∀ g, 𝒅ₕ (smoothLeftMul_one I g) (Derivation.evalAt 1 toDerivation) =
      Derivation.evalAt g toDerivation
goal: Type (max u_1 u_4)

full_name: LeftInvariantDerivation.instCoeDerivationContMDiffMapModelWithCornersSelfTopENat
code: instance : Coe (LeftInvariantDerivation I G) (Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯) 
goal: Coe (LeftInvariantDerivation I G) (Derivation 𝕜 C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯ C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯)

full_name: LeftInvariantDerivation.toDerivation_injective
code: theorem toDerivation_injective :
    Function.Injective (toDerivation : LeftInvariantDerivation I G → _) 
goal: Function.Injective LeftInvariantDerivation.toDerivation

full_name: LeftInvariantDerivation.instFunLikeContMDiffMapModelWithCornersSelfTopENat
code: instance : FunLike (LeftInvariantDerivation I G) C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯ 
goal: FunLike (LeftInvariantDerivation I G) C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯ C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯

full_name: LeftInvariantDerivation.instLinearMapClassContMDiffMapModelWithCornersSelfTopENat
code: instance : LinearMapClass (LeftInvariantDerivation I G) 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯ 
goal: LinearMapClass (LeftInvariantDerivation I G) 𝕜 C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯ C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯

full_name: LeftInvariantDerivation.toFun_eq_coe
code: theorem toFun_eq_coe : X.toFun = ⇑X 
goal: (↑↑X).toFun = ⇑X

full_name: LeftInvariantDerivation.coe_injective
code: theorem coe_injective :
    @Function.Injective (LeftInvariantDerivation I G) (_ → C^∞⟮I, G; 𝕜⟯) DFunLike.coe 
goal: Function.Injective DFunLike.coe

full_name: LeftInvariantDerivation.ext
code: @[ext]
theorem ext (h : ∀ f, X f = Y f) : X = Y 
goal: X = Y

full_name: LeftInvariantDerivation.coe_derivation
code: theorem coe_derivation :
    ⇑(X : Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯) = (X : C^∞⟮I, G; 𝕜⟯ → C^∞⟮I, G; 𝕜⟯) 
goal: ⇑↑X = ⇑X

full_name: LeftInvariantDerivation.left_invariant'
code: /-- Premature version of the lemma. Prefer using `left_invariant` instead. -/
theorem left_invariant' :
    𝒅ₕ (smoothLeftMul_one I g) (Derivation.evalAt (1 : G) ↑X) = Derivation.evalAt g ↑X 
goal: (𝒅ₕ ⋯) ((Derivation.evalAt 1) ↑X) = (Derivation.evalAt g) ↑X

full_name: LeftInvariantDerivation.map_add
code: protected theorem map_add : X (f + f') = X f + X f' 
goal: X (f + f') = X f + X f'

full_name: LeftInvariantDerivation.map_zero
code: protected theorem map_zero : X 0 = 0 
goal: X 0 = 0

full_name: LeftInvariantDerivation.map_neg
code: protected theorem map_neg : X (-f) = -X f 
goal: X (-f) = -X f

full_name: LeftInvariantDerivation.map_sub
code: protected theorem map_sub : X (f - f') = X f - X f' 
goal: X (f - f') = X f - X f'

full_name: LeftInvariantDerivation.map_smul
code: protected theorem map_smul : X (r • f) = r • X f 
goal: X (r • f) = r • X f

full_name: LeftInvariantDerivation.leibniz
code: @[simp]
theorem leibniz : X (f * f') = f • X f' + f' • X f 
goal: X (f * f') = f • X f' + f' • X f

full_name: LeftInvariantDerivation.instZero
code: instance : Zero (LeftInvariantDerivation I G) 
goal: Zero (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.instInhabited
code: instance : Inhabited (LeftInvariantDerivation I G) 
goal: Inhabited (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.instAdd
code: instance : Add (LeftInvariantDerivation I G) 
goal: Add (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.instNeg
code: instance : Neg (LeftInvariantDerivation I G) 
goal: Neg (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.instSub
code: instance : Sub (LeftInvariantDerivation I G) 
goal: Sub (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.coe_add
code: @[simp]
theorem coe_add : ⇑(X + Y) = X + Y 
goal: ⇑(X + Y) = ⇑X + ⇑Y

full_name: LeftInvariantDerivation.coe_zero
code: @[simp]
theorem coe_zero : ⇑(0 : LeftInvariantDerivation I G) = 0 
goal: ⇑0 = 0

full_name: LeftInvariantDerivation.coe_neg
code: @[simp]
theorem coe_neg : ⇑(-X) = -X 
goal: ⇑(-X) = -⇑X

full_name: LeftInvariantDerivation.coe_sub
code: @[simp]
theorem coe_sub : ⇑(X - Y) = X - Y 
goal: ⇑(X - Y) = ⇑X - ⇑Y

full_name: LeftInvariantDerivation.lift_add
code: @[simp, norm_cast]
theorem lift_add : (↑(X + Y) : Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯) = X + Y 
goal: ↑(X + Y) = ↑X + ↑Y

full_name: LeftInvariantDerivation.lift_zero
code: @[simp, norm_cast]
theorem lift_zero :
    (↑(0 : LeftInvariantDerivation I G) : Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯) = 0 
goal: ↑0 = 0

full_name: LeftInvariantDerivation.hasNatScalar
code: instance hasNatScalar : SMul ℕ (LeftInvariantDerivation I G) 
goal: SMul ℕ (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.hasIntScalar
code: instance hasIntScalar : SMul ℤ (LeftInvariantDerivation I G) 
goal: SMul ℤ (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.instAddCommGroup
code: instance : AddCommGroup (LeftInvariantDerivation I G) 
goal: AddCommGroup (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.instSMul
code: instance : SMul 𝕜 (LeftInvariantDerivation I G) 
goal: SMul 𝕜 (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.coe_smul
code: @[simp]
theorem coe_smul : ⇑(r • X) = r • ⇑X 
goal: ⇑(r • X) = r • ⇑X

full_name: LeftInvariantDerivation.lift_smul
code: @[simp]
theorem lift_smul (k : 𝕜) : (k • X).1 = k • X.1 
goal: ↑(k • X) = k • ↑X

full_name: LeftInvariantDerivation.coeFnAddMonoidHom
code: /-- The coercion to function is a monoid homomorphism. -/
@[simps]
def coeFnAddMonoidHom : LeftInvariantDerivation I G →+ C^∞⟮I, G; 𝕜⟯ → C^∞⟮I, G; 𝕜⟯ 
goal: LeftInvariantDerivation I G →+ C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯ → C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯

full_name: LeftInvariantDerivation.coeFnAddMonoidHom_apply
code: /-- The coercion to function is a monoid homomorphism. -/
@[simps]
def coeFnAddMonoidHom : LeftInvariantDerivation I G →+ C^∞⟮I, G; 𝕜⟯ → C^∞⟮I, G; 𝕜⟯ 
goal: ∀ (a : LeftInvariantDerivation I G) (a_1 : C^⊤⟮I, G; 𝓘(𝕜, 𝕜), 𝕜⟯),
  (LeftInvariantDerivation.coeFnAddMonoidHom I G) a a_1 = a a_1

full_name: LeftInvariantDerivation.instModule
code: instance : Module 𝕜 (LeftInvariantDerivation I G) 
goal: Module 𝕜 (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.evalAt
code: /-- Evaluation at a point for left invariant derivation. Same thing as for generic global
derivations (`Derivation.evalAt`). -/
def evalAt : LeftInvariantDerivation I G →ₗ[𝕜] PointDerivation I g 
goal: LeftInvariantDerivation I G →ₗ[𝕜] PointDerivation I g

full_name: LeftInvariantDerivation.evalAt_apply
code: theorem evalAt_apply : evalAt g X f = (X f) g 
goal: ((LeftInvariantDerivation.evalAt g) X) f = (X f) g

full_name: LeftInvariantDerivation.evalAt_coe
code: @[simp]
theorem evalAt_coe : Derivation.evalAt g ↑X = evalAt g X 
goal: (Derivation.evalAt g) ↑X = (LeftInvariantDerivation.evalAt g) X

full_name: LeftInvariantDerivation.left_invariant
code: theorem left_invariant : 𝒅ₕ (smoothLeftMul_one I g) (evalAt (1 : G) X) = evalAt g X 
goal: (𝒅ₕ ⋯) ((LeftInvariantDerivation.evalAt 1) X) = (LeftInvariantDerivation.evalAt g) X

full_name: LeftInvariantDerivation.evalAt_mul
code: theorem evalAt_mul : evalAt (g * h) X = 𝒅ₕ (L_apply I g h) (evalAt h X) 
goal: (LeftInvariantDerivation.evalAt (g * h)) X = (𝒅ₕ ⋯) ((LeftInvariantDerivation.evalAt h) X)

full_name: LeftInvariantDerivation.comp_L
code: theorem comp_L : (X f).comp (𝑳 I g) = X (f.comp (𝑳 I g)) 
goal: (X f).comp (𝑳 I g) = X (f.comp (𝑳 I g))

full_name: LeftInvariantDerivation.instBracket
code: instance : Bracket (LeftInvariantDerivation I G) (LeftInvariantDerivation I G) 
goal: Bracket (LeftInvariantDerivation I G) (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.commutator_coe_derivation
code: @[simp]
theorem commutator_coe_derivation :
    ⇑⁅X, Y⁆ =
      (⁅(X : Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯), Y⁆ :
        Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯) 
goal: ⇑⁅X, Y⁆ = ⇑⁅↑X, ↑Y⁆

full_name: LeftInvariantDerivation.commutator_apply
code: theorem commutator_apply : ⁅X, Y⁆ f = X (Y f) - Y (X f) 
goal: ⁅X, Y⁆ f = X (Y f) - Y (X f)

full_name: LeftInvariantDerivation.instLieRing
code: instance : LieRing (LeftInvariantDerivation I G) 
goal: LieRing (LeftInvariantDerivation I G)

full_name: LeftInvariantDerivation.instLieAlgebra
code: instance : LieAlgebra 𝕜 (LeftInvariantDerivation I G) 
goal: LieAlgebra 𝕜 (LeftInvariantDerivation I G)