File: Mathlib/Algebra/Lie/Basic.lean

full_name: LieRing
code: /-- A Lie ring is an additive group with compatible product, known as the bracket, satisfying the
Jacobi identity. -/
class LieRing (L : Type v) extends AddCommGroup L, Bracket L L where
  /-- A Lie ring bracket is additive in its first component. -/
  protected add_lie : ∀ x y z : L, ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆
  /-- A Lie ring bracket is additive in its second component. -/
  protected lie_add : ∀ x y z : L, ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆
  /-- A Lie ring bracket vanishes on the diagonal in L × L. -/
  protected lie_self : ∀ x : L, ⁅x, x⁆ = 0
  /-- A Lie ring bracket satisfies a Leibniz / Jacobi identity. -/
  protected leibniz_lie : ∀ x y z : L, ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆
goal: Type v

full_name: LieRing.leibniz_lie
code: /-- A Lie ring is an additive group with compatible product, known as the bracket, satisfying the
Jacobi identity. -/
class LieRing (L : Type v) extends AddCommGroup L, Bracket L L where
  /-- A Lie ring bracket is additive in its first component. -/
  protected add_lie : ∀ x y z : L, ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆
  /-- A Lie ring bracket is additive in its second component. -/
  protected lie_add : ∀ x y z : L, ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆
  /-- A Lie ring bracket vanishes on the diagonal in L × L. -/
  protected lie_self : ∀ x : L, ⁅x, x⁆ = 0
  /-- A Lie ring bracket satisfies a Leibniz / Jacobi identity. -/
  protected leibniz_lie : ∀ x y z : L, ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆
goal: ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆

full_name: LieRing.lie_self
code: /-- A Lie ring is an additive group with compatible product, known as the bracket, satisfying the
Jacobi identity. -/
class LieRing (L : Type v) extends AddCommGroup L, Bracket L L where
  /-- A Lie ring bracket is additive in its first component. -/
  protected add_lie : ∀ x y z : L, ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆
  /-- A Lie ring bracket is additive in its second component. -/
  protected lie_add : ∀ x y z : L, ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆
  /-- A Lie ring bracket vanishes on the diagonal in L × L. -/
  protected lie_self : ∀ x : L, ⁅x, x⁆ = 0
  /-- A Lie ring bracket satisfies a Leibniz / Jacobi identity. -/
  protected leibniz_lie : ∀ x y z : L, ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆
goal: ⁅x, x⁆ = 0

full_name: LieRing.add_lie
code: /-- A Lie ring is an additive group with compatible product, known as the bracket, satisfying the
Jacobi identity. -/
class LieRing (L : Type v) extends AddCommGroup L, Bracket L L where
  /-- A Lie ring bracket is additive in its first component. -/
  protected add_lie : ∀ x y z : L, ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆
  /-- A Lie ring bracket is additive in its second component. -/
  protected lie_add : ∀ x y z : L, ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆
  /-- A Lie ring bracket vanishes on the diagonal in L × L. -/
  protected lie_self : ∀ x : L, ⁅x, x⁆ = 0
  /-- A Lie ring bracket satisfies a Leibniz / Jacobi identity. -/
  protected leibniz_lie : ∀ x y z : L, ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆
goal: ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆

full_name: LieRing.lie_add
code: /-- A Lie ring is an additive group with compatible product, known as the bracket, satisfying the
Jacobi identity. -/
class LieRing (L : Type v) extends AddCommGroup L, Bracket L L where
  /-- A Lie ring bracket is additive in its first component. -/
  protected add_lie : ∀ x y z : L, ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆
  /-- A Lie ring bracket is additive in its second component. -/
  protected lie_add : ∀ x y z : L, ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆
  /-- A Lie ring bracket vanishes on the diagonal in L × L. -/
  protected lie_self : ∀ x : L, ⁅x, x⁆ = 0
  /-- A Lie ring bracket satisfies a Leibniz / Jacobi identity. -/
  protected leibniz_lie : ∀ x y z : L, ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆
goal: ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆

full_name: LieAlgebra
code: /-- A Lie algebra is a module with compatible product, known as the bracket, satisfying the Jacobi
identity. Forgetting the scalar multiplication, every Lie algebra is a Lie ring. -/
class LieAlgebra (R : Type u) (L : Type v) [CommRing R] [LieRing L] extends Module R L where
  /-- A Lie algebra bracket is compatible with scalar multiplication in its second argument.

  The compatibility in the first argument is not a class property, but follows since every
  Lie algebra has a natural Lie module action on itself, see `LieModule`. -/
  protected lie_smul : ∀ (t : R) (x y : L), ⁅x, t • y⁆ = t • ⁅x, y⁆
goal: Type (max u v)

full_name: LieAlgebra.lie_smul
code: /-- A Lie algebra is a module with compatible product, known as the bracket, satisfying the Jacobi
identity. Forgetting the scalar multiplication, every Lie algebra is a Lie ring. -/
class LieAlgebra (R : Type u) (L : Type v) [CommRing R] [LieRing L] extends Module R L where
  /-- A Lie algebra bracket is compatible with scalar multiplication in its second argument.

  The compatibility in the first argument is not a class property, but follows since every
  Lie algebra has a natural Lie module action on itself, see `LieModule`. -/
  protected lie_smul : ∀ (t : R) (x y : L), ⁅x, t • y⁆ = t • ⁅x, y⁆
goal: ⁅x, t • y⁆ = t • ⁅x, y⁆

full_name: LieRingModule.add_lie
code: /-- A Lie ring module is an additive group, together with an additive action of a
Lie ring on this group, such that the Lie bracket acts as the commutator of endomorphisms.
(For representations of Lie *algebras* see `LieModule`.) -/
class LieRingModule (L : Type v) (M : Type w) [LieRing L] [AddCommGroup M] extends Bracket L M where
  /-- A Lie ring module bracket is additive in its first component. -/
  protected add_lie : ∀ (x y : L) (m : M), ⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆
  /-- A Lie ring module bracket is additive in its second component. -/
  protected lie_add : ∀ (x : L) (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆
  /-- A Lie ring module bracket satisfies a Leibniz / Jacobi identity. -/
  protected leibniz_lie : ∀ (x y : L) (m : M), ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆
goal: ⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆

full_name: LieRingModule
code: /-- A Lie ring module is an additive group, together with an additive action of a
Lie ring on this group, such that the Lie bracket acts as the commutator of endomorphisms.
(For representations of Lie *algebras* see `LieModule`.) -/
class LieRingModule (L : Type v) (M : Type w) [LieRing L] [AddCommGroup M] extends Bracket L M where
  /-- A Lie ring module bracket is additive in its first component. -/
  protected add_lie : ∀ (x y : L) (m : M), ⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆
  /-- A Lie ring module bracket is additive in its second component. -/
  protected lie_add : ∀ (x : L) (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆
  /-- A Lie ring module bracket satisfies a Leibniz / Jacobi identity. -/
  protected leibniz_lie : ∀ (x y : L) (m : M), ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆
goal: Type (max v w)

full_name: LieRingModule.leibniz_lie
code: /-- A Lie ring module is an additive group, together with an additive action of a
Lie ring on this group, such that the Lie bracket acts as the commutator of endomorphisms.
(For representations of Lie *algebras* see `LieModule`.) -/
class LieRingModule (L : Type v) (M : Type w) [LieRing L] [AddCommGroup M] extends Bracket L M where
  /-- A Lie ring module bracket is additive in its first component. -/
  protected add_lie : ∀ (x y : L) (m : M), ⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆
  /-- A Lie ring module bracket is additive in its second component. -/
  protected lie_add : ∀ (x : L) (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆
  /-- A Lie ring module bracket satisfies a Leibniz / Jacobi identity. -/
  protected leibniz_lie : ∀ (x y : L) (m : M), ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆
goal: ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆

full_name: LieRingModule.lie_add
code: /-- A Lie ring module is an additive group, together with an additive action of a
Lie ring on this group, such that the Lie bracket acts as the commutator of endomorphisms.
(For representations of Lie *algebras* see `LieModule`.) -/
class LieRingModule (L : Type v) (M : Type w) [LieRing L] [AddCommGroup M] extends Bracket L M where
  /-- A Lie ring module bracket is additive in its first component. -/
  protected add_lie : ∀ (x y : L) (m : M), ⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆
  /-- A Lie ring module bracket is additive in its second component. -/
  protected lie_add : ∀ (x : L) (m n : M), ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆
  /-- A Lie ring module bracket satisfies a Leibniz / Jacobi identity. -/
  protected leibniz_lie : ∀ (x y : L) (m : M), ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆
goal: ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆

full_name: LieModule.lie_smul
code: /-- A Lie module is a module over a commutative ring, together with a linear action of a Lie
algebra on this module, such that the Lie bracket acts as the commutator of endomorphisms. -/
class LieModule (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [LieAlgebra R L]
  [AddCommGroup M] [Module R M] [LieRingModule L M] : Prop where
  /-- A Lie module bracket is compatible with scalar multiplication in its first argument. -/
  protected smul_lie : ∀ (t : R) (x : L) (m : M), ⁅t • x, m⁆ = t • ⁅x, m⁆
  /-- A Lie module bracket is compatible with scalar multiplication in its second argument. -/
  protected lie_smul : ∀ (t : R) (x : L) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆
goal: ⁅x, t • m⁆ = t • ⁅x, m⁆

full_name: LieModule.smul_lie
code: /-- A Lie module is a module over a commutative ring, together with a linear action of a Lie
algebra on this module, such that the Lie bracket acts as the commutator of endomorphisms. -/
class LieModule (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [LieAlgebra R L]
  [AddCommGroup M] [Module R M] [LieRingModule L M] : Prop where
  /-- A Lie module bracket is compatible with scalar multiplication in its first argument. -/
  protected smul_lie : ∀ (t : R) (x : L) (m : M), ⁅t • x, m⁆ = t • ⁅x, m⁆
  /-- A Lie module bracket is compatible with scalar multiplication in its second argument. -/
  protected lie_smul : ∀ (t : R) (x : L) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆
goal: ⁅t • x, m⁆ = t • ⁅x, m⁆

full_name: LieModule
code: /-- A Lie module is a module over a commutative ring, together with a linear action of a Lie
algebra on this module, such that the Lie bracket acts as the commutator of endomorphisms. -/
class LieModule (R : Type u) (L : Type v) (M : Type w) [CommRing R] [LieRing L] [LieAlgebra R L]
  [AddCommGroup M] [Module R M] [LieRingModule L M] : Prop where
  /-- A Lie module bracket is compatible with scalar multiplication in its first argument. -/
  protected smul_lie : ∀ (t : R) (x : L) (m : M), ⁅t • x, m⁆ = t • ⁅x, m⁆
  /-- A Lie module bracket is compatible with scalar multiplication in its second argument. -/
  protected lie_smul : ∀ (t : R) (x : L) (m : M), ⁅x, t • m⁆ = t • ⁅x, m⁆
goal: Prop

full_name: add_lie
code: @[simp]
theorem add_lie : ⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆ 
goal: ⁅x + y, m⁆ = ⁅x, m⁆ + ⁅y, m⁆

full_name: lie_add
code: @[simp]
theorem lie_add : ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆ 
goal: ⁅x, m + n⁆ = ⁅x, m⁆ + ⁅x, n⁆

full_name: smul_lie
code: @[simp]
theorem smul_lie : ⁅t • x, m⁆ = t • ⁅x, m⁆ 
goal: ⁅t • x, m⁆ = t • ⁅x, m⁆

full_name: lie_smul
code: @[simp]
theorem lie_smul : ⁅x, t • m⁆ = t • ⁅x, m⁆ 
goal: ⁅x, t • m⁆ = t • ⁅x, m⁆

full_name: leibniz_lie
code: theorem leibniz_lie : ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆ 
goal: ⁅x, ⁅y, m⁆⁆ = ⁅⁅x, y⁆, m⁆ + ⁅y, ⁅x, m⁆⁆

full_name: lie_zero
code: @[simp]
theorem lie_zero : ⁅x, 0⁆ = (0 : M) 
goal: ⁅x, 0⁆ = 0

full_name: zero_lie
code: @[simp]
theorem zero_lie : ⁅(0 : L), m⁆ = 0 
goal: ⁅0, m⁆ = 0

full_name: lie_self
code: @[simp]
theorem lie_self : ⁅x, x⁆ = 0 
goal: ⁅x, x⁆ = 0

full_name: lieRingSelfModule
code: instance lieRingSelfModule : LieRingModule L L 
goal: LieRingModule L L

full_name: lie_skew
code: @[simp]
theorem lie_skew : -⁅y, x⁆ = ⁅x, y⁆ 
goal: -⁅y, x⁆ = ⁅x, y⁆

full_name: lieAlgebraSelfModule
code: /-- Every Lie algebra is a module over itself. -/
instance lieAlgebraSelfModule : LieModule R L L 
goal: LieModule R L L

full_name: neg_lie
code: @[simp]
theorem neg_lie : ⁅-x, m⁆ = -⁅x, m⁆ 
goal: ⁅-x, m⁆ = -⁅x, m⁆

full_name: lie_neg
code: @[simp]
theorem lie_neg : ⁅x, -m⁆ = -⁅x, m⁆ 
goal: ⁅x, -m⁆ = -⁅x, m⁆

full_name: sub_lie
code: @[simp]
theorem sub_lie : ⁅x - y, m⁆ = ⁅x, m⁆ - ⁅y, m⁆ 
goal: ⁅x - y, m⁆ = ⁅x, m⁆ - ⁅y, m⁆

full_name: lie_sub
code: @[simp]
theorem lie_sub : ⁅x, m - n⁆ = ⁅x, m⁆ - ⁅x, n⁆ 
goal: ⁅x, m - n⁆ = ⁅x, m⁆ - ⁅x, n⁆

full_name: nsmul_lie
code: @[simp]
theorem nsmul_lie (n : ℕ) : ⁅n • x, m⁆ = n • ⁅x, m⁆ 
goal: ⁅n • x, m⁆ = n • ⁅x, m⁆

full_name: lie_nsmul
code: @[simp]
theorem lie_nsmul (n : ℕ) : ⁅x, n • m⁆ = n • ⁅x, m⁆ 
goal: ⁅x, n • m⁆ = n • ⁅x, m⁆

full_name: zsmul_lie
code: @[simp]
theorem zsmul_lie (a : ℤ) : ⁅a • x, m⁆ = a • ⁅x, m⁆ 
goal: ⁅a • x, m⁆ = a • ⁅x, m⁆

full_name: lie_zsmul
code: @[simp]
theorem lie_zsmul (a : ℤ) : ⁅x, a • m⁆ = a • ⁅x, m⁆ 
goal: ⁅x, a • m⁆ = a • ⁅x, m⁆

full_name: lie_lie
code: @[simp]
lemma lie_lie : ⁅⁅x, y⁆, m⁆ = ⁅x, ⁅y, m⁆⁆ - ⁅y, ⁅x, m⁆⁆ 
goal: ⁅⁅x, y⁆, m⁆ = ⁅x, ⁅y, m⁆⁆ - ⁅y, ⁅x, m⁆⁆

full_name: lie_jacobi
code: theorem lie_jacobi : ⁅x, ⁅y, z⁆⁆ + ⁅y, ⁅z, x⁆⁆ + ⁅z, ⁅x, y⁆⁆ = 0 
goal: ⁅x, ⁅y, z⁆⁆ + ⁅y, ⁅z, x⁆⁆ + ⁅z, ⁅x, y⁆⁆ = 0

full_name: LieRing.instLieAlgebra
code: instance LieRing.instLieAlgebra : LieAlgebra ℤ L 
goal: LieAlgebra ℤ L

full_name: LinearMap.instLieRingModule
code: instance LinearMap.instLieRingModule : LieRingModule L (M →ₗ[R] N) 
goal: LieRingModule L (M →ₗ[R] N)

full_name: LieHom.lie_apply
code: @[simp]
theorem LieHom.lie_apply (f : M →ₗ[R] N) (x : L) (m : M) : ⁅x, f⁆ m = ⁅x, f m⁆ - f ⁅x, m⁆ 
goal: ⁅x, f⁆ m = ⁅x, f m⁆ - f ⁅x, m⁆

full_name: LinearMap.instLieModule
code: instance LinearMap.instLieModule : LieModule R L (M →ₗ[R] N) 
goal: LieModule R L (M →ₗ[R] N)

full_name: Module.Dual.instLieRingModule
code: /-- We could avoid defining this by instead defining a `LieRingModule L R` instance with a zero
bracket and relying on `LinearMap.instLieRingModule`. We do not do this because in the case that
`L = R` we would have a non-defeq diamond via `Ring.instBracket`. -/
instance Module.Dual.instLieRingModule : LieRingModule L (M →ₗ[R] R) 
goal: LieRingModule L (M →ₗ[R] R)

full_name: Module.Dual.lie_apply
code: @[simp] lemma Module.Dual.lie_apply (f : M →ₗ[R] R) : ⁅x, f⁆ m = - f ⁅x, m⁆ 
goal: ⁅x, f⁆ m = -f ⁅x, m⁆

full_name: Module.Dual.instLieModule
code: instance Module.Dual.instLieModule : LieModule R L (M →ₗ[R] R) 
goal: LieModule R L (M →ₗ[R] R)

full_name: LieHom
code: /-- A morphism of Lie algebras is a linear map respecting the bracket operations. -/
structure LieHom (R L L' : Type*) [CommRing R] [LieRing L] [LieAlgebra R L]
  [LieRing L'] [LieAlgebra R L'] extends L →ₗ[R] L' where
  /-- A morphism of Lie algebras is compatible with brackets. -/
  map_lie' : ∀ {x y : L}, toFun ⁅x, y⁆ = ⁅toFun x, toFun y⁆
goal: Type (max u_2 u_3)

full_name: LieHom.map_lie'
code: /-- A morphism of Lie algebras is a linear map respecting the bracket operations. -/
structure LieHom (R L L' : Type*) [CommRing R] [LieRing L] [LieAlgebra R L]
  [LieRing L'] [LieAlgebra R L'] extends L →ₗ[R] L' where
  /-- A morphism of Lie algebras is compatible with brackets. -/
  map_lie' : ∀ {x y : L}, toFun ⁅x, y⁆ = ⁅toFun x, toFun y⁆
goal: (↑self).toFun ⁅x, y⁆ = ⁅(↑self).toFun x, (↑self).toFun y⁆

full_name: «_aux_Mathlib_Algebra_Lie_Basic___macroRules_term_→ₗ⁅_⁆__1»
code: @[inherit_doc]
notation:25 L " →ₗ⁅" R:25 "⁆ " L':0 => LieHom R L L'
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Lie_Basic___unexpand_LieHom_1
code: @[inherit_doc]
notation:25 L " →ₗ⁅" R:25 "⁆ " L':0 => LieHom R L L'
goal: Lean.PrettyPrinter.Unexpander

full_name: LieHom.instCoeLinearMapId
code: instance : Coe (L₁ →ₗ⁅R⁆ L₂) (L₁ →ₗ[R] L₂) 
goal: Coe (L₁ →ₗ⁅R⁆ L₂) (L₁ →ₗ[R] L₂)

full_name: LieHom.instFunLike
code: instance : FunLike (L₁ →ₗ⁅R⁆ L₂) L₁ L₂ 
goal: FunLike (L₁ →ₗ⁅R⁆ L₂) L₁ L₂

full_name: LieHom.coe_toLinearMap
code: @[simp, norm_cast]
theorem coe_toLinearMap (f : L₁ →ₗ⁅R⁆ L₂) : ⇑(f : L₁ →ₗ[R] L₂) = f 
goal: ⇑↑f = ⇑f

full_name: LieHom.toFun_eq_coe
code: @[simp]
theorem toFun_eq_coe (f : L₁ →ₗ⁅R⁆ L₂) : f.toFun = ⇑f 
goal: (↑f).toFun = ⇑f

full_name: LieHom.map_smul
code: @[simp]
theorem map_smul (f : L₁ →ₗ⁅R⁆ L₂) (c : R) (x : L₁) : f (c • x) = c • f x 
goal: f (c • x) = c • f x

full_name: LieHom.map_add
code: @[simp]
theorem map_add (f : L₁ →ₗ⁅R⁆ L₂) (x y : L₁) : f (x + y) = f x + f y 
goal: f (x + y) = f x + f y

full_name: LieHom.map_sub
code: @[simp]
theorem map_sub (f : L₁ →ₗ⁅R⁆ L₂) (x y : L₁) : f (x - y) = f x - f y 
goal: f (x - y) = f x - f y

full_name: LieHom.map_neg
code: @[simp]
theorem map_neg (f : L₁ →ₗ⁅R⁆ L₂) (x : L₁) : f (-x) = -f x 
goal: f (-x) = -f x

full_name: LieHom.map_lie
code: @[simp]
theorem map_lie (f : L₁ →ₗ⁅R⁆ L₂) (x y : L₁) : f ⁅x, y⁆ = ⁅f x, f y⁆ 
goal: f ⁅x, y⁆ = ⁅f x, f y⁆

full_name: LieHom.map_zero
code: @[simp]
theorem map_zero (f : L₁ →ₗ⁅R⁆ L₂) : f 0 = 0 
goal: f 0 = 0

full_name: LieHom.id
code: /-- The identity map is a morphism of Lie algebras. -/
def id : L₁ →ₗ⁅R⁆ L₁ 
goal: L₁ →ₗ⁅R⁆ L₁

full_name: LieHom.coe_id
code: @[simp]
theorem coe_id : ⇑(id : L₁ →ₗ⁅R⁆ L₁) = _root_.id 
goal: ⇑LieHom.id = id

full_name: LieHom.id_apply
code: theorem id_apply (x : L₁) : (id : L₁ →ₗ⁅R⁆ L₁) x = x 
goal: LieHom.id x = x

full_name: LieHom.instZero
code: /-- The constant 0 map is a Lie algebra morphism. -/
instance : Zero (L₁ →ₗ⁅R⁆ L₂) 
goal: Zero (L₁ →ₗ⁅R⁆ L₂)

full_name: LieHom.coe_zero
code: @[norm_cast, simp]
theorem coe_zero : ((0 : L₁ →ₗ⁅R⁆ L₂) : L₁ → L₂) = 0 
goal: ⇑0 = 0

full_name: LieHom.zero_apply
code: theorem zero_apply (x : L₁) : (0 : L₁ →ₗ⁅R⁆ L₂) x = 0 
goal: 0 x = 0

full_name: LieHom.instOne
code: /-- The identity map is a Lie algebra morphism. -/
instance : One (L₁ →ₗ⁅R⁆ L₁) 
goal: One (L₁ →ₗ⁅R⁆ L₁)

full_name: LieHom.coe_one
code: @[simp]
theorem coe_one : ((1 : L₁ →ₗ⁅R⁆ L₁) : L₁ → L₁) = _root_.id 
goal: ⇑1 = id

full_name: LieHom.one_apply
code: theorem one_apply (x : L₁) : (1 : L₁ →ₗ⁅R⁆ L₁) x = x 
goal: 1 x = x

full_name: LieHom.instInhabited
code: instance : Inhabited (L₁ →ₗ⁅R⁆ L₂) 
goal: Inhabited (L₁ →ₗ⁅R⁆ L₂)

full_name: LieHom.coe_injective
code: theorem coe_injective : @Function.Injective (L₁ →ₗ⁅R⁆ L₂) (L₁ → L₂) (↑) 
goal: Function.Injective DFunLike.coe

full_name: LieHom.ext
code: @[ext]
theorem ext {f g : L₁ →ₗ⁅R⁆ L₂} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: LieHom.ext_iff
code: theorem ext_iff {f g : L₁ →ₗ⁅R⁆ L₂} : f = g ↔ ∀ x, f x = g x 
goal: f = g ↔ ∀ (x : L₁), f x = g x

full_name: LieHom.congr_fun
code: theorem congr_fun {f g : L₁ →ₗ⁅R⁆ L₂} (h : f = g) (x : L₁) : f x = g x 
goal: f x = g x

full_name: LieHom.mk_coe
code: @[simp]
theorem mk_coe (f : L₁ →ₗ⁅R⁆ L₂) (h₁ h₂ h₃) : (⟨⟨⟨f, h₁⟩, h₂⟩, h₃⟩ : L₁ →ₗ⁅R⁆ L₂) = f 
goal: { toFun := ⇑f, map_add' := h₁, map_smul' := h₂, map_lie' := h₃ } = f

full_name: LieHom.coe_mk
code: @[simp]
theorem coe_mk (f : L₁ → L₂) (h₁ h₂ h₃) : ((⟨⟨⟨f, h₁⟩, h₂⟩, h₃⟩ : L₁ →ₗ⁅R⁆ L₂) : L₁ → L₂) = f 
goal: ⇑{ toFun := f, map_add' := h₁, map_smul' := h₂, map_lie' := h₃ } = f

full_name: LieHom.comp
code: /-- The composition of morphisms is a morphism. -/
def comp (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂) : L₁ →ₗ⁅R⁆ L₃ 
goal: L₁ →ₗ⁅R⁆ L₃

full_name: LieHom.comp_apply
code: theorem comp_apply (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂) (x : L₁) : f.comp g x = f (g x) 
goal: (f.comp g) x = f (g x)

full_name: LieHom.coe_comp
code: @[norm_cast, simp]
theorem coe_comp (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂) : (f.comp g : L₁ → L₃) = f ∘ g 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: LieHom.coe_linearMap_comp
code: @[norm_cast, simp]
theorem coe_linearMap_comp (f : L₂ →ₗ⁅R⁆ L₃) (g : L₁ →ₗ⁅R⁆ L₂) :
    (f.comp g : L₁ →ₗ[R] L₃) = (f : L₂ →ₗ[R] L₃).comp (g : L₁ →ₗ[R] L₂) 
goal: ↑(f.comp g) = ↑f ∘ₗ ↑g

full_name: LieHom.comp_id
code: @[simp]
theorem comp_id (f : L₁ →ₗ⁅R⁆ L₂) : f.comp (id : L₁ →ₗ⁅R⁆ L₁) = f 
goal: f.comp LieHom.id = f

full_name: LieHom.id_comp
code: @[simp]
theorem id_comp (f : L₁ →ₗ⁅R⁆ L₂) : (id : L₂ →ₗ⁅R⁆ L₂).comp f = f 
goal: LieHom.id.comp f = f

full_name: LieHom.inverse
code: /-- The inverse of a bijective morphism is a morphism. -/
def inverse (f : L₁ →ₗ⁅R⁆ L₂) (g : L₂ → L₁) (h₁ : Function.LeftInverse g f)
    (h₂ : Function.RightInverse g f) : L₂ →ₗ⁅R⁆ L₁ 
goal: L₂ →ₗ⁅R⁆ L₁

full_name: LieRingModule.compLieHom
code: /-- A Lie ring module may be pulled back along a morphism of Lie algebras.

See note [reducible non-instances]. -/
def LieRingModule.compLieHom : LieRingModule L₁ M 
goal: LieRingModule L₁ M

full_name: LieRingModule.compLieHom_apply
code: theorem LieRingModule.compLieHom_apply (x : L₁) (m : M) :
    haveI := LieRingModule.compLieHom M f
    ⁅x, m⁆ = ⁅f x, m⁆ 
goal: ⁅x, m⁆ = ⁅f x, m⁆

full_name: LieModule.compLieHom
code: /-- A Lie module may be pulled back along a morphism of Lie algebras. -/
theorem LieModule.compLieHom [Module R M] [LieModule R L₂ M] :
    @LieModule R L₁ M _ _ _ _ _ (LieRingModule.compLieHom M f) 
goal: LieModule R L₁ M

full_name: LieEquiv
code: /-- An equivalence of Lie algebras is a morphism which is also a linear equivalence. We could
instead define an equivalence to be a morphism which is also a (plain) equivalence. However it is
more convenient to define via linear equivalence to get `.toLinearEquiv` for free. -/
structure LieEquiv (R : Type u) (L : Type v) (L' : Type w) [CommRing R] [LieRing L] [LieAlgebra R L]
  [LieRing L'] [LieAlgebra R L'] extends L →ₗ⁅R⁆ L' where
  /-- The inverse function of an equivalence of Lie algebras -/
  invFun : L' → L
  /-- The inverse function of an equivalence of Lie algebras is a left inverse of the underlying
  function. -/
  left_inv : Function.LeftInverse invFun toLieHom.toFun
  /-- The inverse function of an equivalence of Lie algebras is a right inverse of the underlying
  function. -/
  right_inv : Function.RightInverse invFun toLieHom.toFun
goal: Type (max v w)

full_name: LieEquiv.invFun
code: /-- An equivalence of Lie algebras is a morphism which is also a linear equivalence. We could
instead define an equivalence to be a morphism which is also a (plain) equivalence. However it is
more convenient to define via linear equivalence to get `.toLinearEquiv` for free. -/
structure LieEquiv (R : Type u) (L : Type v) (L' : Type w) [CommRing R] [LieRing L] [LieAlgebra R L]
  [LieRing L'] [LieAlgebra R L'] extends L →ₗ⁅R⁆ L' where
  /-- The inverse function of an equivalence of Lie algebras -/
  invFun : L' → L
  /-- The inverse function of an equivalence of Lie algebras is a left inverse of the underlying
  function. -/
  left_inv : Function.LeftInverse invFun toLieHom.toFun
  /-- The inverse function of an equivalence of Lie algebras is a right inverse of the underlying
  function. -/
  right_inv : Function.RightInverse invFun toLieHom.toFun
goal: L' → L

full_name: LieEquiv.left_inv
code: /-- An equivalence of Lie algebras is a morphism which is also a linear equivalence. We could
instead define an equivalence to be a morphism which is also a (plain) equivalence. However it is
more convenient to define via linear equivalence to get `.toLinearEquiv` for free. -/
structure LieEquiv (R : Type u) (L : Type v) (L' : Type w) [CommRing R] [LieRing L] [LieAlgebra R L]
  [LieRing L'] [LieAlgebra R L'] extends L →ₗ⁅R⁆ L' where
  /-- The inverse function of an equivalence of Lie algebras -/
  invFun : L' → L
  /-- The inverse function of an equivalence of Lie algebras is a left inverse of the underlying
  function. -/
  left_inv : Function.LeftInverse invFun toLieHom.toFun
  /-- The inverse function of an equivalence of Lie algebras is a right inverse of the underlying
  function. -/
  right_inv : Function.RightInverse invFun toLieHom.toFun
goal: Function.LeftInverse self.invFun (↑self.toLieHom).toFun

full_name: LieEquiv.right_inv
code: /-- An equivalence of Lie algebras is a morphism which is also a linear equivalence. We could
instead define an equivalence to be a morphism which is also a (plain) equivalence. However it is
more convenient to define via linear equivalence to get `.toLinearEquiv` for free. -/
structure LieEquiv (R : Type u) (L : Type v) (L' : Type w) [CommRing R] [LieRing L] [LieAlgebra R L]
  [LieRing L'] [LieAlgebra R L'] extends L →ₗ⁅R⁆ L' where
  /-- The inverse function of an equivalence of Lie algebras -/
  invFun : L' → L
  /-- The inverse function of an equivalence of Lie algebras is a left inverse of the underlying
  function. -/
  left_inv : Function.LeftInverse invFun toLieHom.toFun
  /-- The inverse function of an equivalence of Lie algebras is a right inverse of the underlying
  function. -/
  right_inv : Function.RightInverse invFun toLieHom.toFun
goal: Function.RightInverse self.invFun (↑self.toLieHom).toFun

full_name: «_aux_Mathlib_Algebra_Lie_Basic___macroRules_term_≃ₗ⁅_⁆__1»
code: @[inherit_doc]
notation:50 L " ≃ₗ⁅" R "⁆ " L' => LieEquiv R L L'
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Lie_Basic___unexpand_LieEquiv_1
code: @[inherit_doc]
notation:50 L " ≃ₗ⁅" R "⁆ " L' => LieEquiv R L L'
goal: Lean.PrettyPrinter.Unexpander

full_name: LieEquiv.toLinearEquiv
code: /-- Consider an equivalence of Lie algebras as a linear equivalence. -/
def toLinearEquiv (f : L₁ ≃ₗ⁅R⁆ L₂) : L₁ ≃ₗ[R] L₂ 
goal: L₁ ≃ₗ[R] L₂

full_name: LieEquiv.hasCoeToLieHom
code: instance hasCoeToLieHom : Coe (L₁ ≃ₗ⁅R⁆ L₂) (L₁ →ₗ⁅R⁆ L₂) 
goal: Coe (L₁ ≃ₗ⁅R⁆ L₂) (L₁ →ₗ⁅R⁆ L₂)

full_name: LieEquiv.hasCoeToLinearEquiv
code: instance hasCoeToLinearEquiv : Coe (L₁ ≃ₗ⁅R⁆ L₂) (L₁ ≃ₗ[R] L₂) 
goal: Coe (L₁ ≃ₗ⁅R⁆ L₂) (L₁ ≃ₗ[R] L₂)

full_name: LieEquiv.instEquivLike
code: instance : EquivLike (L₁ ≃ₗ⁅R⁆ L₂) L₁ L₂ 
goal: EquivLike (L₁ ≃ₗ⁅R⁆ L₂) L₁ L₂

full_name: LieEquiv.coe_to_lieHom
code: theorem coe_to_lieHom (e : L₁ ≃ₗ⁅R⁆ L₂) : ⇑(e : L₁ →ₗ⁅R⁆ L₂) = e 
goal: ⇑e.toLieHom = ⇑e

full_name: LieEquiv.coe_to_linearEquiv
code: @[simp]
theorem coe_to_linearEquiv (e : L₁ ≃ₗ⁅R⁆ L₂) : ⇑(e : L₁ ≃ₗ[R] L₂) = e 
goal: ⇑e.toLinearEquiv = ⇑e

full_name: LieEquiv.to_linearEquiv_mk
code: @[simp]
theorem to_linearEquiv_mk (f : L₁ →ₗ⁅R⁆ L₂) (g h₁ h₂) :
    (mk f g h₁ h₂ : L₁ ≃ₗ[R] L₂) =
      { f with
        invFun := g
        left_inv := h₁
        right_inv := h₂ } 
goal: { toLieHom := f, invFun := g, left_inv := h₁, right_inv := h₂ }.toLinearEquiv =
  { toLinearMap := ↑f, invFun := g, left_inv := h₁, right_inv := h₂ }

full_name: LieEquiv.coe_linearEquiv_injective
code: theorem coe_linearEquiv_injective : Injective ((↑) : (L₁ ≃ₗ⁅R⁆ L₂) → L₁ ≃ₗ[R] L₂) 
goal: Function.Injective LieEquiv.toLinearEquiv

full_name: LieEquiv.coe_injective
code: theorem coe_injective : @Injective (L₁ ≃ₗ⁅R⁆ L₂) (L₁ → L₂) (↑) 
goal: Function.Injective DFunLike.coe

full_name: LieEquiv.ext
code: @[ext]
theorem ext {f g : L₁ ≃ₗ⁅R⁆ L₂} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: LieEquiv.instOne
code: instance : One (L₁ ≃ₗ⁅R⁆ L₁) 
goal: One (L₁ ≃ₗ⁅R⁆ L₁)

full_name: LieEquiv.one_apply
code: @[simp]
theorem one_apply (x : L₁) : (1 : L₁ ≃ₗ⁅R⁆ L₁) x = x 
goal: 1 x = x

full_name: LieEquiv.instInhabited
code: instance : Inhabited (L₁ ≃ₗ⁅R⁆ L₁) 
goal: Inhabited (L₁ ≃ₗ⁅R⁆ L₁)

full_name: LieEquiv.map_lie
code: lemma map_lie (e : L₁ ≃ₗ⁅R⁆ L₂) (x y : L₁) : e ⁅x, y⁆ = ⁅e x, e y⁆ 
goal: e ⁅x, y⁆ = ⁅e x, e y⁆

full_name: LieEquiv.refl
code: /-- Lie algebra equivalences are reflexive. -/
def refl : L₁ ≃ₗ⁅R⁆ L₁ 
goal: L₁ ≃ₗ⁅R⁆ L₁

full_name: LieEquiv.refl_apply
code: @[simp]
theorem refl_apply (x : L₁) : (refl : L₁ ≃ₗ⁅R⁆ L₁) x = x 
goal: LieEquiv.refl x = x

full_name: LieEquiv.symm
code: /-- Lie algebra equivalences are symmetric. -/
@[symm]
def symm (e : L₁ ≃ₗ⁅R⁆ L₂) : L₂ ≃ₗ⁅R⁆ L₁ 
goal: L₂ ≃ₗ⁅R⁆ L₁

full_name: LieEquiv.symm_symm
code: @[simp]
theorem symm_symm (e : L₁ ≃ₗ⁅R⁆ L₂) : e.symm.symm = e 
goal: e.symm.symm = e

full_name: LieEquiv.symm_bijective
code: theorem symm_bijective : Function.Bijective (LieEquiv.symm : (L₁ ≃ₗ⁅R⁆ L₂) → L₂ ≃ₗ⁅R⁆ L₁) 
goal: Function.Bijective LieEquiv.symm

full_name: LieEquiv.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (e : L₁ ≃ₗ⁅R⁆ L₂) : ∀ x, e (e.symm x) = x 
goal: e (e.symm x) = x

full_name: LieEquiv.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (e : L₁ ≃ₗ⁅R⁆ L₂) : ∀ x, e.symm (e x) = x 
goal: e.symm (e x) = x

full_name: LieEquiv.refl_symm
code: @[simp]
theorem refl_symm : (refl : L₁ ≃ₗ⁅R⁆ L₁).symm = refl 
goal: LieEquiv.refl.symm = LieEquiv.refl

full_name: LieEquiv.trans
code: /-- Lie algebra equivalences are transitive. -/
@[trans]
def trans (e₁ : L₁ ≃ₗ⁅R⁆ L₂) (e₂ : L₂ ≃ₗ⁅R⁆ L₃) : L₁ ≃ₗ⁅R⁆ L₃ 
goal: L₁ ≃ₗ⁅R⁆ L₃

full_name: LieEquiv.self_trans_symm
code: @[simp]
theorem self_trans_symm (e : L₁ ≃ₗ⁅R⁆ L₂) : e.trans e.symm = refl 
goal: e.trans e.symm = LieEquiv.refl

full_name: LieEquiv.symm_trans_self
code: @[simp]
theorem symm_trans_self (e : L₁ ≃ₗ⁅R⁆ L₂) : e.symm.trans e = refl 
goal: e.symm.trans e = LieEquiv.refl

full_name: LieEquiv.trans_apply
code: @[simp]
theorem trans_apply (e₁ : L₁ ≃ₗ⁅R⁆ L₂) (e₂ : L₂ ≃ₗ⁅R⁆ L₃) (x : L₁) : (e₁.trans e₂) x = e₂ (e₁ x) 
goal: (e₁.trans e₂) x = e₂ (e₁ x)

full_name: LieEquiv.symm_trans
code: @[simp]
theorem symm_trans (e₁ : L₁ ≃ₗ⁅R⁆ L₂) (e₂ : L₂ ≃ₗ⁅R⁆ L₃) :
    (e₁.trans e₂).symm = e₂.symm.trans e₁.symm 
goal: (e₁.trans e₂).symm = e₂.symm.trans e₁.symm

full_name: LieEquiv.bijective
code: protected theorem bijective (e : L₁ ≃ₗ⁅R⁆ L₂) : Function.Bijective ((e : L₁ →ₗ⁅R⁆ L₂) : L₁ → L₂) 
goal: Function.Bijective ⇑e.toLieHom

full_name: LieEquiv.injective
code: protected theorem injective (e : L₁ ≃ₗ⁅R⁆ L₂) : Function.Injective ((e : L₁ →ₗ⁅R⁆ L₂) : L₁ → L₂) 
goal: Function.Injective ⇑e.toLieHom

full_name: LieEquiv.surjective
code: protected theorem surjective (e : L₁ ≃ₗ⁅R⁆ L₂) :
    Function.Surjective ((e : L₁ →ₗ⁅R⁆ L₂) : L₁ → L₂) 
goal: Function.Surjective ⇑e.toLieHom

full_name: LieEquiv.ofBijective_toFun
code: /-- A bijective morphism of Lie algebras yields an equivalence of Lie algebras. -/
@[simps!]
noncomputable def ofBijective (f : L₁ →ₗ⁅R⁆ L₂) (h : Function.Bijective f) : L₁ ≃ₗ⁅R⁆ L₂ 
goal: (LieEquiv.ofBijective f h) a = f a

full_name: LieEquiv.ofBijective
code: /-- A bijective morphism of Lie algebras yields an equivalence of Lie algebras. -/
@[simps!]
noncomputable def ofBijective (f : L₁ →ₗ⁅R⁆ L₂) (h : Function.Bijective f) : L₁ ≃ₗ⁅R⁆ L₂ 
goal: L₁ ≃ₗ⁅R⁆ L₂

full_name: LieEquiv.ofBijective_invFun
code: /-- A bijective morphism of Lie algebras yields an equivalence of Lie algebras. -/
@[simps!]
noncomputable def ofBijective (f : L₁ →ₗ⁅R⁆ L₂) (h : Function.Bijective f) : L₁ ≃ₗ⁅R⁆ L₂ 
goal: ∀ (a : L₂), (LieEquiv.ofBijective f h).invFun a = (LinearEquiv.ofBijective (↑f) h).symm a

full_name: LieModuleHom.map_lie'
code: /-- A morphism of Lie algebra modules is a linear map which commutes with the action of the Lie
algebra. -/
structure LieModuleHom extends M →ₗ[R] N where
  /-- A module of Lie algebra modules is compatible with the action of the Lie algebra on the
  modules. -/
  map_lie' : ∀ {x : L} {m : M}, toFun ⁅x, m⁆ = ⁅x, toFun m⁆
goal: (↑self).toFun ⁅x, m⁆ = ⁅x, (↑self).toFun m⁆

full_name: LieModuleHom
code: /-- A morphism of Lie algebra modules is a linear map which commutes with the action of the Lie
algebra. -/
structure LieModuleHom extends M →ₗ[R] N where
  /-- A module of Lie algebra modules is compatible with the action of the Lie algebra on the
  modules. -/
  map_lie' : ∀ {x : L} {m : M}, toFun ⁅x, m⁆ = ⁅x, toFun m⁆
goal: Type (max w w₁)

full_name: _aux_Mathlib_Algebra_Lie_Basic___unexpand_LieModuleHom_1
code: @[inherit_doc]
notation:25 M " →ₗ⁅" R "," L:25 "⁆ " N:0 => LieModuleHom R L M N
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Lie_Basic___macroRules_term_→ₗ⁅_,_⁆__1»
code: @[inherit_doc]
notation:25 M " →ₗ⁅" R "," L:25 "⁆ " N:0 => LieModuleHom R L M N
goal: Lean.Macro

full_name: LieModuleHom.instCoeOutLinearMapId
code: instance : CoeOut (M →ₗ⁅R,L⁆ N) (M →ₗ[R] N) 
goal: CoeOut (M →ₗ⁅R,L⁆ N) (M →ₗ[R] N)

full_name: LieModuleHom.instFunLike
code: instance : FunLike (M →ₗ⁅R, L⁆ N) M N 
goal: FunLike (M →ₗ⁅R,L⁆ N) M N

full_name: LieModuleHom.coe_toLinearMap
code: @[simp, norm_cast]
theorem coe_toLinearMap (f : M →ₗ⁅R,L⁆ N) : ((f : M →ₗ[R] N) : M → N) = f 
goal: ⇑↑f = ⇑f

full_name: LieModuleHom.map_smul
code: @[simp]
theorem map_smul (f : M →ₗ⁅R,L⁆ N) (c : R) (x : M) : f (c • x) = c • f x 
goal: f (c • x) = c • f x

full_name: LieModuleHom.map_add
code: @[simp]
theorem map_add (f : M →ₗ⁅R,L⁆ N) (x y : M) : f (x + y) = f x + f y 
goal: f (x + y) = f x + f y

full_name: LieModuleHom.map_sub
code: @[simp]
theorem map_sub (f : M →ₗ⁅R,L⁆ N) (x y : M) : f (x - y) = f x - f y 
goal: f (x - y) = f x - f y

full_name: LieModuleHom.map_neg
code: @[simp]
theorem map_neg (f : M →ₗ⁅R,L⁆ N) (x : M) : f (-x) = -f x 
goal: f (-x) = -f x

full_name: LieModuleHom.map_lie
code: @[simp]
theorem map_lie (f : M →ₗ⁅R,L⁆ N) (x : L) (m : M) : f ⁅x, m⁆ = ⁅x, f m⁆ 
goal: f ⁅x, m⁆ = ⁅x, f m⁆

full_name: LieModuleHom.map_lie₂
code: theorem map_lie₂ (f : M →ₗ⁅R,L⁆ N →ₗ[R] P) (x : L) (m : M) (n : N) :
    ⁅x, f m n⁆ = f ⁅x, m⁆ n + f m ⁅x, n⁆ 
goal: ⁅x, (f m) n⁆ = (f ⁅x, m⁆) n + (f m) ⁅x, n⁆

full_name: LieModuleHom.map_zero
code: @[simp]
theorem map_zero (f : M →ₗ⁅R,L⁆ N) : f 0 = 0 
goal: f 0 = 0

full_name: LieModuleHom.id
code: /-- The identity map is a morphism of Lie modules. -/
def id : M →ₗ⁅R,L⁆ M 
goal: M →ₗ⁅R,L⁆ M

full_name: LieModuleHom.coe_id
code: @[simp]
theorem coe_id : ((id : M →ₗ⁅R,L⁆ M) : M → M) = _root_.id 
goal: ⇑LieModuleHom.id = id

full_name: LieModuleHom.id_apply
code: theorem id_apply (x : M) : (id : M →ₗ⁅R,L⁆ M) x = x 
goal: LieModuleHom.id x = x

full_name: LieModuleHom.instZero
code: /-- The constant 0 map is a Lie module morphism. -/
instance : Zero (M →ₗ⁅R,L⁆ N) 
goal: Zero (M →ₗ⁅R,L⁆ N)

full_name: LieModuleHom.coe_zero
code: @[norm_cast, simp]
theorem coe_zero : ⇑(0 : M →ₗ⁅R,L⁆ N) = 0 
goal: ⇑0 = 0

full_name: LieModuleHom.zero_apply
code: theorem zero_apply (m : M) : (0 : M →ₗ⁅R,L⁆ N) m = 0 
goal: 0 m = 0

full_name: LieModuleHom.instOne
code: /-- The identity map is a Lie module morphism. -/
instance : One (M →ₗ⁅R,L⁆ M) 
goal: One (M →ₗ⁅R,L⁆ M)

full_name: LieModuleHom.instInhabited
code: instance : Inhabited (M →ₗ⁅R,L⁆ N) 
goal: Inhabited (M →ₗ⁅R,L⁆ N)

full_name: LieModuleHom.coe_injective
code: theorem coe_injective : @Function.Injective (M →ₗ⁅R,L⁆ N) (M → N) (↑) 
goal: Function.Injective DFunLike.coe

full_name: LieModuleHom.ext
code: @[ext]
theorem ext {f g : M →ₗ⁅R,L⁆ N} (h : ∀ m, f m = g m) : f = g 
goal: f = g

full_name: LieModuleHom.ext_iff
code: theorem ext_iff {f g : M →ₗ⁅R,L⁆ N} : f = g ↔ ∀ m, f m = g m 
goal: f = g ↔ ∀ (m : M), f m = g m

full_name: LieModuleHom.congr_fun
code: theorem congr_fun {f g : M →ₗ⁅R,L⁆ N} (h : f = g) (x : M) : f x = g x 
goal: f x = g x

full_name: LieModuleHom.mk_coe
code: @[simp]
theorem mk_coe (f : M →ₗ⁅R,L⁆ N) (h) : (⟨f, h⟩ : M →ₗ⁅R,L⁆ N) = f 
goal: { toLinearMap := ↑f, map_lie' := h } = f

full_name: LieModuleHom.coe_mk
code: @[simp]
theorem coe_mk (f : M →ₗ[R] N) (h) : ((⟨f, h⟩ : M →ₗ⁅R,L⁆ N) : M → N) = f 
goal: ⇑{ toLinearMap := f, map_lie' := h } = ⇑f

full_name: LieModuleHom.coe_linear_mk
code: @[norm_cast]
theorem coe_linear_mk (f : M →ₗ[R] N) (h) : ((⟨f, h⟩ : M →ₗ⁅R,L⁆ N) : M →ₗ[R] N) = f 
goal: ↑{ toLinearMap := f, map_lie' := h } = f

full_name: LieModuleHom.comp
code: /-- The composition of Lie module morphisms is a morphism. -/
def comp (f : N →ₗ⁅R,L⁆ P) (g : M →ₗ⁅R,L⁆ N) : M →ₗ⁅R,L⁆ P 
goal: M →ₗ⁅R,L⁆ P

full_name: LieModuleHom.comp_apply
code: theorem comp_apply (f : N →ₗ⁅R,L⁆ P) (g : M →ₗ⁅R,L⁆ N) (m : M) : f.comp g m = f (g m) 
goal: (f.comp g) m = f (g m)

full_name: LieModuleHom.coe_comp
code: @[norm_cast, simp]
theorem coe_comp (f : N →ₗ⁅R,L⁆ P) (g : M →ₗ⁅R,L⁆ N) : ⇑(f.comp g) = f ∘ g 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: LieModuleHom.coe_linearMap_comp
code: @[norm_cast, simp]
theorem coe_linearMap_comp (f : N →ₗ⁅R,L⁆ P) (g : M →ₗ⁅R,L⁆ N) :
    (f.comp g : M →ₗ[R] P) = (f : N →ₗ[R] P).comp (g : M →ₗ[R] N) 
goal: ↑(f.comp g) = ↑f ∘ₗ ↑g

full_name: LieModuleHom.inverse
code: /-- The inverse of a bijective morphism of Lie modules is a morphism of Lie modules. -/
def inverse (f : M →ₗ⁅R,L⁆ N) (g : N → M) (h₁ : Function.LeftInverse g f)
    (h₂ : Function.RightInverse g f) : N →ₗ⁅R,L⁆ M 
goal: N →ₗ⁅R,L⁆ M

full_name: LieModuleHom.instAdd
code: instance : Add (M →ₗ⁅R,L⁆ N) 
goal: Add (M →ₗ⁅R,L⁆ N)

full_name: LieModuleHom.instSub
code: instance : Sub (M →ₗ⁅R,L⁆ N) 
goal: Sub (M →ₗ⁅R,L⁆ N)

full_name: LieModuleHom.instNeg
code: instance : Neg (M →ₗ⁅R,L⁆ N) 
goal: Neg (M →ₗ⁅R,L⁆ N)

full_name: LieModuleHom.coe_add
code: @[norm_cast, simp]
theorem coe_add (f g : M →ₗ⁅R,L⁆ N) : ⇑(f + g) = f + g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: LieModuleHom.add_apply
code: theorem add_apply (f g : M →ₗ⁅R,L⁆ N) (m : M) : (f + g) m = f m + g m 
goal: (f + g) m = f m + g m

full_name: LieModuleHom.coe_sub
code: @[norm_cast, simp]
theorem coe_sub (f g : M →ₗ⁅R,L⁆ N) : ⇑(f - g) = f - g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: LieModuleHom.sub_apply
code: theorem sub_apply (f g : M →ₗ⁅R,L⁆ N) (m : M) : (f - g) m = f m - g m 
goal: (f - g) m = f m - g m

full_name: LieModuleHom.coe_neg
code: @[norm_cast, simp]
theorem coe_neg (f : M →ₗ⁅R,L⁆ N) : ⇑(-f) = -f 
goal: ⇑(-f) = -⇑f

full_name: LieModuleHom.neg_apply
code: theorem neg_apply (f : M →ₗ⁅R,L⁆ N) (m : M) : (-f) m = -f m 
goal: (-f) m = -f m

full_name: LieModuleHom.hasNSMul
code: instance hasNSMul : SMul ℕ (M →ₗ⁅R,L⁆ N) 
goal: SMul ℕ (M →ₗ⁅R,L⁆ N)

full_name: LieModuleHom.coe_nsmul
code: @[norm_cast, simp]
theorem coe_nsmul (n : ℕ) (f : M →ₗ⁅R,L⁆ N) : ⇑(n • f) = n • (⇑f) 
goal: ⇑(n • f) = n • ⇑f

full_name: LieModuleHom.nsmul_apply
code: theorem nsmul_apply (n : ℕ) (f : M →ₗ⁅R,L⁆ N) (m : M) : (n • f) m = n • f m 
goal: (n • f) m = n • f m

full_name: LieModuleHom.hasZSMul
code: instance hasZSMul : SMul ℤ (M →ₗ⁅R,L⁆ N) 
goal: SMul ℤ (M →ₗ⁅R,L⁆ N)

full_name: LieModuleHom.coe_zsmul
code: @[norm_cast, simp]
theorem coe_zsmul (z : ℤ) (f : M →ₗ⁅R,L⁆ N) : ⇑(z • f) = z • (⇑f) 
goal: ⇑(z • f) = z • ⇑f

full_name: LieModuleHom.zsmul_apply
code: theorem zsmul_apply (z : ℤ) (f : M →ₗ⁅R,L⁆ N) (m : M) : (z • f) m = z • f m 
goal: (z • f) m = z • f m

full_name: LieModuleHom.instAddCommGroup
code: instance : AddCommGroup (M →ₗ⁅R,L⁆ N) 
goal: AddCommGroup (M →ₗ⁅R,L⁆ N)

full_name: LieModuleHom.instSMul
code: instance : SMul R (M →ₗ⁅R,L⁆ N) 
goal: SMul R (M →ₗ⁅R,L⁆ N)

full_name: LieModuleHom.coe_smul
code: @[norm_cast, simp]
theorem coe_smul (t : R) (f : M →ₗ⁅R,L⁆ N) : ⇑(t • f) = t • (⇑f) 
goal: ⇑(t • f) = t • ⇑f

full_name: LieModuleHom.smul_apply
code: theorem smul_apply (t : R) (f : M →ₗ⁅R,L⁆ N) (m : M) : (t • f) m = t • f m 
goal: (t • f) m = t • f m

full_name: LieModuleHom.instModule
code: instance : Module R (M →ₗ⁅R,L⁆ N) 
goal: Module R (M →ₗ⁅R,L⁆ N)

full_name: LieModuleEquiv.right_inv
code: /-- An equivalence of Lie algebra modules is a linear equivalence which is also a morphism of
Lie algebra modules. -/
structure LieModuleEquiv extends M →ₗ⁅R,L⁆ N where
  /-- The inverse function of an equivalence of Lie modules -/
  invFun : N → M
  /-- The inverse function of an equivalence of Lie modules is a left inverse of the underlying
  function. -/
  left_inv : Function.LeftInverse invFun toFun
  /-- The inverse function of an equivalence of Lie modules is a right inverse of the underlying
  function. -/
  right_inv : Function.RightInverse invFun toFun
goal: Function.RightInverse self.invFun (↑self.toLieModuleHom).toFun

full_name: LieModuleEquiv.invFun
code: /-- An equivalence of Lie algebra modules is a linear equivalence which is also a morphism of
Lie algebra modules. -/
structure LieModuleEquiv extends M →ₗ⁅R,L⁆ N where
  /-- The inverse function of an equivalence of Lie modules -/
  invFun : N → M
  /-- The inverse function of an equivalence of Lie modules is a left inverse of the underlying
  function. -/
  left_inv : Function.LeftInverse invFun toFun
  /-- The inverse function of an equivalence of Lie modules is a right inverse of the underlying
  function. -/
  right_inv : Function.RightInverse invFun toFun
goal: N → M

full_name: LieModuleEquiv.left_inv
code: /-- An equivalence of Lie algebra modules is a linear equivalence which is also a morphism of
Lie algebra modules. -/
structure LieModuleEquiv extends M →ₗ⁅R,L⁆ N where
  /-- The inverse function of an equivalence of Lie modules -/
  invFun : N → M
  /-- The inverse function of an equivalence of Lie modules is a left inverse of the underlying
  function. -/
  left_inv : Function.LeftInverse invFun toFun
  /-- The inverse function of an equivalence of Lie modules is a right inverse of the underlying
  function. -/
  right_inv : Function.RightInverse invFun toFun
goal: Function.LeftInverse self.invFun (↑self.toLieModuleHom).toFun

full_name: LieModuleEquiv
code: /-- An equivalence of Lie algebra modules is a linear equivalence which is also a morphism of
Lie algebra modules. -/
structure LieModuleEquiv extends M →ₗ⁅R,L⁆ N where
  /-- The inverse function of an equivalence of Lie modules -/
  invFun : N → M
  /-- The inverse function of an equivalence of Lie modules is a left inverse of the underlying
  function. -/
  left_inv : Function.LeftInverse invFun toFun
  /-- The inverse function of an equivalence of Lie modules is a right inverse of the underlying
  function. -/
  right_inv : Function.RightInverse invFun toFun
goal: Type (max w w₁)

full_name: «_aux_Mathlib_Algebra_Lie_Basic___macroRules_term_≃ₗ⁅_,_⁆__1»
code: @[inherit_doc]
notation:25 M " ≃ₗ⁅" R "," L:25 "⁆ " N:0 => LieModuleEquiv R L M N
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Lie_Basic___unexpand_LieModuleEquiv_1
code: @[inherit_doc]
notation:25 M " ≃ₗ⁅" R "," L:25 "⁆ " N:0 => LieModuleEquiv R L M N
goal: Lean.PrettyPrinter.Unexpander

full_name: LieModuleEquiv.toLinearEquiv
code: /-- View an equivalence of Lie modules as a linear equivalence. -/
def toLinearEquiv (e : M ≃ₗ⁅R,L⁆ N) : M ≃ₗ[R] N 
goal: M ≃ₗ[R] N

full_name: LieModuleEquiv.toEquiv
code: /-- View an equivalence of Lie modules as a type level equivalence. -/
def toEquiv (e : M ≃ₗ⁅R,L⁆ N) : M ≃ N 
goal: M ≃ N

full_name: LieModuleEquiv.hasCoeToEquiv
code: instance hasCoeToEquiv : CoeOut (M ≃ₗ⁅R,L⁆ N) (M ≃ N) 
goal: CoeOut (M ≃ₗ⁅R,L⁆ N) (M ≃ N)

full_name: LieModuleEquiv.hasCoeToLieModuleHom
code: instance hasCoeToLieModuleHom : Coe (M ≃ₗ⁅R,L⁆ N) (M →ₗ⁅R,L⁆ N) 
goal: Coe (M ≃ₗ⁅R,L⁆ N) (M →ₗ⁅R,L⁆ N)

full_name: LieModuleEquiv.hasCoeToLinearEquiv
code: instance hasCoeToLinearEquiv : CoeOut (M ≃ₗ⁅R,L⁆ N) (M ≃ₗ[R] N) 
goal: CoeOut (M ≃ₗ⁅R,L⁆ N) (M ≃ₗ[R] N)

full_name: LieModuleEquiv.instEquivLike
code: instance : EquivLike (M ≃ₗ⁅R,L⁆ N) M N 
goal: EquivLike (M ≃ₗ⁅R,L⁆ N) M N

full_name: LieModuleEquiv.coe_coe
code: @[simp] lemma coe_coe (e : M ≃ₗ⁅R,L⁆ N) : ⇑(e : M →ₗ⁅R,L⁆ N) = e 
goal: ⇑e.toLieModuleHom = ⇑e

full_name: LieModuleEquiv.injective
code: theorem injective (e : M ≃ₗ⁅R,L⁆ N) : Function.Injective e 
goal: Function.Injective ⇑e

full_name: LieModuleEquiv.surjective
code: theorem surjective (e : M ≃ₗ⁅R,L⁆ N) : Function.Surjective e 
goal: Function.Surjective ⇑e

full_name: LieModuleEquiv.toEquiv_mk
code: @[simp]
theorem toEquiv_mk (f : M →ₗ⁅R,L⁆ N) (g : N → M) (h₁ h₂) :
    toEquiv (mk f g h₁ h₂ : M ≃ₗ⁅R,L⁆ N) = Equiv.mk f g h₁ h₂ 
goal: { toLieModuleHom := f, invFun := g, left_inv := h₁, right_inv := h₂ }.toEquiv =
  { toFun := ⇑f, invFun := g, left_inv := h₁, right_inv := h₂ }

full_name: LieModuleEquiv.coe_mk
code: @[simp]
theorem coe_mk (f : M →ₗ⁅R,L⁆ N) (invFun h₁ h₂) :
    ((⟨f, invFun, h₁, h₂⟩ : M ≃ₗ⁅R,L⁆ N) : M → N) = f 
goal: ⇑{ toLieModuleHom := f, invFun := invFun, left_inv := h₁, right_inv := h₂ } = ⇑f

full_name: LieModuleEquiv.coe_to_lieModuleHom
code: theorem coe_to_lieModuleHom (e : M ≃ₗ⁅R,L⁆ N) : ⇑(e : M →ₗ⁅R,L⁆ N) = e 
goal: ⇑e.toLieModuleHom = ⇑e

full_name: LieModuleEquiv.coe_to_linearEquiv
code: @[simp]
theorem coe_to_linearEquiv (e : M ≃ₗ⁅R,L⁆ N) : ((e : M ≃ₗ[R] N) : M → N) = e 
goal: ⇑e.toLinearEquiv = ⇑e

full_name: LieModuleEquiv.toEquiv_injective
code: theorem toEquiv_injective : Function.Injective (toEquiv : (M ≃ₗ⁅R,L⁆ N) → M ≃ N) 
goal: Function.Injective LieModuleEquiv.toEquiv

full_name: LieModuleEquiv.ext
code: @[ext]
theorem ext (e₁ e₂ : M ≃ₗ⁅R,L⁆ N) (h : ∀ m, e₁ m = e₂ m) : e₁ = e₂ 
goal: e₁ = e₂

full_name: LieModuleEquiv.instOne
code: instance : One (M ≃ₗ⁅R,L⁆ M) 
goal: One (M ≃ₗ⁅R,L⁆ M)

full_name: LieModuleEquiv.one_apply
code: @[simp]
theorem one_apply (m : M) : (1 : M ≃ₗ⁅R,L⁆ M) m = m 
goal: 1 m = m

full_name: LieModuleEquiv.instInhabited
code: instance : Inhabited (M ≃ₗ⁅R,L⁆ M) 
goal: Inhabited (M ≃ₗ⁅R,L⁆ M)

full_name: LieModuleEquiv.refl
code: /-- Lie module equivalences are reflexive. -/
@[refl]
def refl : M ≃ₗ⁅R,L⁆ M 
goal: M ≃ₗ⁅R,L⁆ M

full_name: LieModuleEquiv.refl_apply
code: @[simp]
theorem refl_apply (m : M) : (refl : M ≃ₗ⁅R,L⁆ M) m = m 
goal: LieModuleEquiv.refl m = m

full_name: LieModuleEquiv.symm
code: /-- Lie module equivalences are symmetric. -/
@[symm]
def symm (e : M ≃ₗ⁅R,L⁆ N) : N ≃ₗ⁅R,L⁆ M 
goal: N ≃ₗ⁅R,L⁆ M

full_name: LieModuleEquiv.apply_symm_apply
code: @[simp]
theorem apply_symm_apply (e : M ≃ₗ⁅R,L⁆ N) : ∀ x, e (e.symm x) = x 
goal: e (e.symm x) = x

full_name: LieModuleEquiv.symm_apply_apply
code: @[simp]
theorem symm_apply_apply (e : M ≃ₗ⁅R,L⁆ N) : ∀ x, e.symm (e x) = x 
goal: e.symm (e x) = x

full_name: LieModuleEquiv.apply_eq_iff_eq_symm_apply
code: theorem apply_eq_iff_eq_symm_apply {m : M} {n : N} (e : M ≃ₗ⁅R,L⁆ N) :
    e m = n ↔ m = e.symm n 
goal: e m = n ↔ m = e.symm n

full_name: LieModuleEquiv.symm_symm
code: @[simp]
theorem symm_symm (e : M ≃ₗ⁅R,L⁆ N) : e.symm.symm = e 
goal: e.symm.symm = e

full_name: LieModuleEquiv.symm_bijective
code: theorem symm_bijective :
    Function.Bijective (LieModuleEquiv.symm : (M ≃ₗ⁅R,L⁆ N) → N ≃ₗ⁅R,L⁆ M) 
goal: Function.Bijective LieModuleEquiv.symm

full_name: LieModuleEquiv.trans
code: /-- Lie module equivalences are transitive. -/
@[trans]
def trans (e₁ : M ≃ₗ⁅R,L⁆ N) (e₂ : N ≃ₗ⁅R,L⁆ P) : M ≃ₗ⁅R,L⁆ P 
goal: M ≃ₗ⁅R,L⁆ P

full_name: LieModuleEquiv.trans_apply
code: @[simp]
theorem trans_apply (e₁ : M ≃ₗ⁅R,L⁆ N) (e₂ : N ≃ₗ⁅R,L⁆ P) (m : M) : (e₁.trans e₂) m = e₂ (e₁ m) 
goal: (e₁.trans e₂) m = e₂ (e₁ m)

full_name: LieModuleEquiv.symm_trans
code: @[simp]
theorem symm_trans (e₁ : M ≃ₗ⁅R,L⁆ N) (e₂ : N ≃ₗ⁅R,L⁆ P) :
    (e₁.trans e₂).symm = e₂.symm.trans e₁.symm 
goal: (e₁.trans e₂).symm = e₂.symm.trans e₁.symm

full_name: LieModuleEquiv.self_trans_symm
code: @[simp]
theorem self_trans_symm (e : M ≃ₗ⁅R,L⁆ N) : e.trans e.symm = refl 
goal: e.trans e.symm = LieModuleEquiv.refl

full_name: LieModuleEquiv.symm_trans_self
code: @[simp]
theorem symm_trans_self (e : M ≃ₗ⁅R,L⁆ N) : e.symm.trans e = refl 
goal: e.symm.trans e = LieModuleEquiv.refl