ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Algebra/Order/Ring/Cone.lean

full_name: Ring.PositiveCone.one_nonneg
code: /-- A positive cone in a ring consists of a positive cone in underlying `AddCommGroup`,
which contains `1` and such that the positive elements are closed under multiplication. -/
structure PositiveCone (α : Type*) [Ring α] extends AddCommGroup.PositiveCone α where
  /-- In a positive cone, `1` is `nonneg` -/
  one_nonneg : nonneg 1
  /-- In a positive cone, if `a` and `b` are `pos` then so is `a * b` -/
  mul_pos : ∀ a b, pos a → pos b → pos (a * b)
goal: self.nonneg 1

full_name: Ring.PositiveCone
code: /-- A positive cone in a ring consists of a positive cone in underlying `AddCommGroup`,
which contains `1` and such that the positive elements are closed under multiplication. -/
structure PositiveCone (α : Type*) [Ring α] extends AddCommGroup.PositiveCone α where
  /-- In a positive cone, `1` is `nonneg` -/
  one_nonneg : nonneg 1
  /-- In a positive cone, if `a` and `b` are `pos` then so is `a * b` -/
  mul_pos : ∀ a b, pos a → pos b → pos (a * b)
goal: Type u_2

full_name: Ring.PositiveCone.mul_pos
code: /-- A positive cone in a ring consists of a positive cone in underlying `AddCommGroup`,
which contains `1` and such that the positive elements are closed under multiplication. -/
structure PositiveCone (α : Type*) [Ring α] extends AddCommGroup.PositiveCone α where
  /-- In a positive cone, `1` is `nonneg` -/
  one_nonneg : nonneg 1
  /-- In a positive cone, if `a` and `b` are `pos` then so is `a * b` -/
  mul_pos : ∀ a b, pos a → pos b → pos (a * b)
goal: self.pos a → self.pos b → self.pos (a * b)

full_name: Ring.TotalPositiveCone
code: /-- A total positive cone in a nontrivial ring induces a linear order. -/
structure TotalPositiveCone (α : Type*) [Ring α] extends PositiveCone α,
  AddCommGroup.TotalPositiveCone α
goal: Type u_2

full_name: Ring.PositiveCone.one_pos
code: theorem PositiveCone.one_pos (C : PositiveCone α) : C.pos 1 
goal: C.pos 1

full_name: StrictOrderedRing.mkOfPositiveCone
code: /-- Construct a `StrictOrderedRing` by designating a positive cone in an existing `Ring`. -/
def StrictOrderedRing.mkOfPositiveCone (C : PositiveCone α) : StrictOrderedRing α 
goal: StrictOrderedRing α

full_name: LinearOrderedRing.mkOfPositiveCone
code: /-- Construct a `LinearOrderedRing` by
designating a positive cone in an existing `Ring`. -/
def LinearOrderedRing.mkOfPositiveCone (C : TotalPositiveCone α) : LinearOrderedRing α 
goal: LinearOrderedRing α
File: Mathlib/Algebra/Order/Ring/Nat.lean

full_name: Nat.instLinearOrderedCommSemiring
code: instance instLinearOrderedCommSemiring : LinearOrderedCommSemiring ℕ 
goal: LinearOrderedCommSemiring ℕ

full_name: Nat.instLinearOrderedCommMonoidWithZero
code: instance instLinearOrderedCommMonoidWithZero : LinearOrderedCommMonoidWithZero ℕ 
goal: LinearOrderedCommMonoidWithZero ℕ

full_name: Nat.instCanonicallyOrderedCommSemiring
code: instance instCanonicallyOrderedCommSemiring : CanonicallyOrderedCommSemiring ℕ 
goal: CanonicallyOrderedCommSemiring ℕ

full_name: Nat.instLinearOrderedSemiring
code: instance instLinearOrderedSemiring : LinearOrderedSemiring ℕ 
goal: LinearOrderedSemiring ℕ

full_name: Nat.instStrictOrderedSemiring
code: instance instStrictOrderedSemiring : StrictOrderedSemiring ℕ 
goal: StrictOrderedSemiring ℕ

full_name: Nat.instStrictOrderedCommSemiring
code: instance instStrictOrderedCommSemiring : StrictOrderedCommSemiring ℕ 
goal: StrictOrderedCommSemiring ℕ

full_name: Nat.instOrderedSemiring
code: instance instOrderedSemiring : OrderedSemiring ℕ 
goal: OrderedSemiring ℕ

full_name: Nat.instOrderedCommSemiring
code: instance instOrderedCommSemiring : OrderedCommSemiring ℕ 
goal: OrderedCommSemiring ℕ

full_name: Nat.isCompl_even_odd
code: lemma isCompl_even_odd : IsCompl { n : ℕ | Even n } { n | Odd n } 
goal: IsCompl {n | Even n} {n | Odd n}
File: Mathlib/Algebra/Order/Ring/Prod.lean

full_name: instOrderedSemiringProd
code: instance [OrderedSemiring α] [OrderedSemiring β] : OrderedSemiring (α × β) 
goal: OrderedSemiring (α × β)

full_name: instOrderedCommSemiringProd
code: instance [OrderedCommSemiring α] [OrderedCommSemiring β] : OrderedCommSemiring (α × β) 
goal: OrderedCommSemiring (α × β)

full_name: instOrderedRingProd
code: instance [OrderedRing α] [OrderedRing β] : OrderedRing (α × β) 
goal: OrderedRing (α × β)

full_name: instOrderedCommRingProd
code: instance [OrderedCommRing α] [OrderedCommRing β] : OrderedCommRing (α × β) 
goal: OrderedCommRing (α × β)
File: Mathlib/Algebra/Order/Ring/Pow.lean

full_name: one_add_mul_le_pow'
code: /-- **Bernoulli's inequality**. This version works for semirings but requires
additional hypotheses `0 ≤ a * a` and `0 ≤ (1 + a) * (1 + a)`. -/
lemma one_add_mul_le_pow' (Hsq : 0 ≤ a * a) (Hsq' : 0 ≤ (1 + a) * (1 + a)) (H : 0 ≤ 2 + a) :
    ∀ n : ℕ, 1 + n * a ≤ (1 + a) ^ n
  
goal: 1 + ↑n * a ≤ (1 + a) ^ n

full_name: one_add_mul_le_pow
code: /-- **Bernoulli's inequality** for `n : ℕ`, `-2 ≤ a`. -/
lemma one_add_mul_le_pow (H : -2 ≤ a) (n : ℕ) : 1 + n * a ≤ (1 + a) ^ n 
goal: 1 + ↑n * a ≤ (1 + a) ^ n

full_name: one_add_mul_sub_le_pow
code: /-- **Bernoulli's inequality** reformulated to estimate `a^n`. -/
lemma one_add_mul_sub_le_pow (H : -1 ≤ a) (n : ℕ) : 1 + n * (a - 1) ≤ a ^ n 
goal: 1 + ↑n * (a - 1) ≤ a ^ n
File: Mathlib/Algebra/Order/Ring/Star.lean

full_name: _private.Mathlib.Algebra.Order.Ring.Star.0.StarOrderedRing.mul_le_mul_of_nonneg_left
code: private lemma mul_le_mul_of_nonneg_left {R : Type*} [CommSemiring R] [PartialOrder R]
    [StarRing R] [StarOrderedRing R] {a b c : R} (hab : a ≤ b) (hc : 0 ≤ c) : c * a ≤ c * b 
goal: c * a ≤ c * b

full_name: StarOrderedRing.toOrderedCommSemiring
code: /-- A commutative star-ordered semiring is an ordered semiring.

This is not registered as an instance because it introduces a type class loop between `CommSemiring`
and `OrderedCommSemiring`, and it seem loops still cause issues sometimes.

See note [reducible non-instances]. -/
abbrev toOrderedCommSemiring (R : Type*) [CommSemiring R] [PartialOrder R]
    [StarRing R] [StarOrderedRing R] : OrderedCommSemiring R 
goal: OrderedCommSemiring R

full_name: StarOrderedRing.toOrderedCommRing
code: /-- A commutative star-ordered ring is an ordered ring.

This is not registered as an instance because it introduces a type class loop between `CommSemiring`
and `OrderedCommSemiring`, and it seem loops still cause issues sometimes.

See note [reducible non-instances]. -/
abbrev toOrderedCommRing (R : Type*) [CommRing R] [PartialOrder R]
    [StarRing R] [StarOrderedRing R] : OrderedCommRing R 
goal: OrderedCommRing R
File: Mathlib/Algebra/Order/Interval/Multiset.lean

full_name: Multiset.map_add_left_Icc
code: lemma map_add_left_Icc (a b c : α) : (Icc a b).map (c + ·) = Icc (c + a) (c + b) 
goal: Multiset.map (fun x => c + x) (Multiset.Icc a b) = Multiset.Icc (c + a) (c + b)

full_name: Multiset.map_add_left_Ico
code: lemma map_add_left_Ico (a b c : α) : (Ico a b).map (c + ·) = Ico (c + a) (c + b) 
goal: Multiset.map (fun x => c + x) (Multiset.Ico a b) = Multiset.Ico (c + a) (c + b)

full_name: Multiset.map_add_left_Ioc
code: lemma map_add_left_Ioc (a b c : α) : (Ioc a b).map (c + ·) = Ioc (c + a) (c + b) 
goal: Multiset.map (fun x => c + x) (Multiset.Ioc a b) = Multiset.Ioc (c + a) (c + b)

full_name: Multiset.map_add_left_Ioo
code: lemma map_add_left_Ioo (a b c : α) : (Ioo a b).map (c + ·) = Ioo (c + a) (c + b) 
goal: Multiset.map (fun x => c + x) (Multiset.Ioo a b) = Multiset.Ioo (c + a) (c + b)

full_name: Multiset.map_add_right_Icc
code: lemma map_add_right_Icc (a b c : α) : ((Icc a b).map fun x => x + c) = Icc (a + c) (b + c) 
goal: Multiset.map (fun x => x + c) (Multiset.Icc a b) = Multiset.Icc (a + c) (b + c)

full_name: Multiset.map_add_right_Ico
code: lemma map_add_right_Ico (a b c : α) : ((Ico a b).map fun x => x + c) = Ico (a + c) (b + c) 
goal: Multiset.map (fun x => x + c) (Multiset.Ico a b) = Multiset.Ico (a + c) (b + c)

full_name: Multiset.map_add_right_Ioc
code: lemma map_add_right_Ioc (a b c : α) : ((Ioc a b).map fun x => x + c) = Ioc (a + c) (b + c) 
goal: Multiset.map (fun x => x + c) (Multiset.Ioc a b) = Multiset.Ioc (a + c) (b + c)

full_name: Multiset.map_add_right_Ioo
code: lemma map_add_right_Ioo (a b c : α) : ((Ioo a b).map fun x => x + c) = Ioo (a + c) (b + c) 
goal: Multiset.map (fun x => x + c) (Multiset.Ioo a b) = Multiset.Ioo (a + c) (b + c)
File: Mathlib/Algebra/Order/BigOperators/Ring/List.lean

full_name: List.prod_pos
code: /-- The product of a list of positive natural numbers is positive,
and likewise for any nontrivial ordered semiring. -/
lemma prod_pos [StrictOrderedSemiring R] (l : List R) (h : ∀ a ∈ l, (0 : R) < a) :
    0 < l.prod 
goal: 0 < l.prod

full_name: CanonicallyOrderedCommSemiring.list_prod_pos
code: /-- A variant of `List.prod_pos` for `CanonicallyOrderedCommSemiring`. -/
@[simp] lemma _root_.CanonicallyOrderedCommSemiring.list_prod_pos
    {α : Type*} [CanonicallyOrderedCommSemiring α] [Nontrivial α] :
    ∀ {l : List α}, 0 < l.prod ↔ (∀ x ∈ l, (0 : α) < x)
  
goal: 0 < l.prod ↔ ∀ x ∈ l, 0 < x
File: Mathlib/Algebra/Order/BigOperators/Ring/Multiset.lean

full_name: Multiset.prod_nonneg
code: lemma prod_nonneg (h : ∀ a ∈ s, 0 ≤ a) : 0 ≤ s.prod 
goal: 0 ≤ s.prod

full_name: CanonicallyOrderedCommSemiring.multiset_prod_pos
code: @[simp]
lemma _root_.CanonicallyOrderedCommSemiring.multiset_prod_pos [CanonicallyOrderedCommSemiring R]
    [Nontrivial R] {m : Multiset R} : 0 < m.prod ↔ ∀ x ∈ m, 0 < x 
goal: 0 < m.prod ↔ ∀ x ∈ m, 0 < x
File: Mathlib/Algebra/Quotient.lean

full_name: HasQuotient.quotient'
code: /-- `HasQuotient A B` is a notation typeclass that allows us to write `A ⧸ b` for `b : B`.
This allows the usual notation for quotients of algebraic structures,
such as groups, modules and rings.

`A` is a parameter, despite being unused in the definition below, so it appears in the notation.
-/
class HasQuotient (A : outParam <| Type u) (B : Type v) where
  /-- auxiliary quotient function, the one used will have `A` explicit -/
  quotient' : B → Type max u v
goal: B → Type (max u v)

full_name: HasQuotient
code: /-- `HasQuotient A B` is a notation typeclass that allows us to write `A ⧸ b` for `b : B`.
This allows the usual notation for quotients of algebraic structures,
such as groups, modules and rings.

`A` is a parameter, despite being unused in the definition below, so it appears in the notation.
-/
class HasQuotient (A : outParam <| Type u) (B : Type v) where
  /-- auxiliary quotient function, the one used will have `A` explicit -/
  quotient' : B → Type max u v
goal: Type (max (u + 1) (v + 1))

full_name: HasQuotient.Quotient
code: /-- `HasQuotient.Quotient A b` (with notation `A ⧸ b`) is the quotient
 of the type `A` by `b`.

This differs from `HasQuotient.quotient'` in that the `A` argument is
 explicit, which is necessary to make Lean show the notation in the
 goal state.
-/
abbrev HasQuotient.Quotient (A : outParam <| Type u) {B : Type v}
    [HasQuotient A B] (b : B) : Type max u v 
goal: Type (max u v)

full_name: «_aux_Mathlib_Algebra_Quotient___macroRules_term_⧸__1»
code: /-- Quotient notation based on the `HasQuotient` typeclass -/
notation:35 G " ⧸ " H:34 => HasQuotient.Quotient G H
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Quotient___unexpand_HasQuotient_Quotient_1
code: /-- Quotient notation based on the `HasQuotient` typeclass -/
notation:35 G " ⧸ " H:34 => HasQuotient.Quotient G H
goal: Lean.PrettyPrinter.Unexpander
File: Mathlib/Algebra/Lie/Matrix.lean

full_name: lieEquivMatrix'
code: /-- The natural equivalence between linear endomorphisms of finite free modules and square matrices
is compatible with the Lie algebra structures. -/
def lieEquivMatrix' : Module.End R (n → R) ≃ₗ⁅R⁆ Matrix n n R 
goal: Module.End R (n → R) ≃ₗ⁅R⁆ Matrix n n R

full_name: lieEquivMatrix'_apply
code: @[simp]
theorem lieEquivMatrix'_apply (f : Module.End R (n → R)) :
    lieEquivMatrix' f = LinearMap.toMatrix' f 
goal: lieEquivMatrix' f = LinearMap.toMatrix' f

full_name: lieEquivMatrix'_symm_apply
code: @[simp]
theorem lieEquivMatrix'_symm_apply (A : Matrix n n R) :
    (@lieEquivMatrix' R _ n _ _).symm A = Matrix.toLin' A 
goal: lieEquivMatrix'.symm A = Matrix.toLin' A

full_name: Matrix.lieConj
code: /-- An invertible matrix induces a Lie algebra equivalence from the space of matrices to itself. -/
def Matrix.lieConj (P : Matrix n n R) (h : Invertible P) : Matrix n n R ≃ₗ⁅R⁆ Matrix n n R 
goal: Matrix n n R ≃ₗ⁅R⁆ Matrix n n R

full_name: Matrix.lieConj_apply
code: @[simp]
theorem Matrix.lieConj_apply (P A : Matrix n n R) (h : Invertible P) :
    P.lieConj h A = P * A * P⁻¹ 
goal: (P.lieConj h) A = P * A * P⁻¹

full_name: Matrix.lieConj_symm_apply
code: @[simp]
theorem Matrix.lieConj_symm_apply (P A : Matrix n n R) (h : Invertible P) :
    (P.lieConj h).symm A = P⁻¹ * A * P 
goal: (P.lieConj h).symm A = P⁻¹ * A * P

full_name: Matrix.reindexLieEquiv
code: /-- For square matrices, the natural map that reindexes a matrix's rows and columns with equivalent
types, `Matrix.reindex`, is an equivalence of Lie algebras. -/
def Matrix.reindexLieEquiv : Matrix n n R ≃ₗ⁅R⁆ Matrix m m R 
goal: Matrix n n R ≃ₗ⁅R⁆ Matrix m m R

full_name: Matrix.reindexLieEquiv_apply
code: @[simp]
theorem Matrix.reindexLieEquiv_apply (M : Matrix n n R) :
    Matrix.reindexLieEquiv e M = Matrix.reindex e e M 
goal: (Matrix.reindexLieEquiv e) M = (Matrix.reindex e e) M

full_name: Matrix.reindexLieEquiv_symm
code: @[simp]
theorem Matrix.reindexLieEquiv_symm :
    (Matrix.reindexLieEquiv e : _ ≃ₗ⁅R⁆ _).symm = Matrix.reindexLieEquiv e.symm 
goal: (Matrix.reindexLieEquiv e).symm = Matrix.reindexLieEquiv e.symm
File: Mathlib/Algebra/Lie/Character.lean

full_name: LieAlgebra.LieCharacter
code: /-- A character of a Lie algebra is a morphism to the scalars. -/
abbrev LieCharacter 
goal: Type (max v u)

full_name: LieAlgebra.lieCharacter_apply_lie
code: theorem lieCharacter_apply_lie (χ : LieCharacter R L) (x y : L) : χ ⁅x, y⁆ = 0 
goal: χ ⁅x, y⁆ = 0

full_name: LieAlgebra.lieCharacter_apply_lie'
code: @[simp]
theorem lieCharacter_apply_lie' (χ : LieCharacter R L) (x y : L) : ⁅χ x, χ y⁆ = 0 
goal: ⁅χ x, χ y⁆ = 0

full_name: LieAlgebra.lieCharacter_apply_of_mem_derived
code: theorem lieCharacter_apply_of_mem_derived (χ : LieCharacter R L) {x : L}
    (h : x ∈ derivedSeries R L 1) : χ x = 0 
goal: χ x = 0

full_name: LieAlgebra.lieCharacterEquivLinearDual
code: /-- For an Abelian Lie algebra, characters are just linear forms. -/
@[simps! apply symm_apply]
def lieCharacterEquivLinearDual [IsLieAbelian L] : LieCharacter R L ≃ Module.Dual R L 
goal: LieAlgebra.LieCharacter R L ≃ Module.Dual R L

full_name: LieAlgebra.lieCharacterEquivLinearDual_apply
code: /-- For an Abelian Lie algebra, characters are just linear forms. -/
@[simps! apply symm_apply]
def lieCharacterEquivLinearDual [IsLieAbelian L] : LieCharacter R L ≃ Module.Dual R L 
goal: LieAlgebra.lieCharacterEquivLinearDual χ = ↑χ

full_name: LieAlgebra.lieCharacterEquivLinearDual_symm_apply
code: /-- For an Abelian Lie algebra, characters are just linear forms. -/
@[simps! apply symm_apply]
def lieCharacterEquivLinearDual [IsLieAbelian L] : LieCharacter R L ≃ Module.Dual R L 
goal: LieAlgebra.lieCharacterEquivLinearDual.symm ψ = { toLinearMap := ψ, map_lie' := ⋯ }
File: Mathlib/Algebra/Lie/Killing.lean

full_name: LieAlgebra.IsKilling
code: /-- We say a Lie algebra is Killing if its Killing form is non-singular.

NB: This is not standard terminology (the literature does not seem to name Lie algebras with this
property). -/
class IsKilling : Prop :=
  /-- We say a Lie algebra is Killing if its Killing form is non-singular. -/
  killingCompl_top_eq_bot : LieIdeal.killingCompl R L ⊤ = ⊥
goal: Prop

full_name: LieAlgebra.IsKilling.killingCompl_top_eq_bot
code: /-- We say a Lie algebra is Killing if its Killing form is non-singular.

NB: This is not standard terminology (the literature does not seem to name Lie algebras with this
property). -/
class IsKilling : Prop :=
  /-- We say a Lie algebra is Killing if its Killing form is non-singular. -/
  killingCompl_top_eq_bot : LieIdeal.killingCompl R L ⊤ = ⊥
goal: LieIdeal.killingCompl R L ⊤ = ⊥

full_name: LieAlgebra.IsKilling.ker_killingForm_eq_bot
code: @[simp] lemma ker_killingForm_eq_bot :
    LinearMap.ker (killingForm R L) = ⊥ 
goal: LinearMap.ker (killingForm R L) = ⊥

full_name: LieAlgebra.IsKilling.killingForm_nondegenerate
code: lemma killingForm_nondegenerate :
    (killingForm R L).Nondegenerate 
goal: (killingForm R L).Nondegenerate

full_name: LieAlgebra.IsKilling.ideal_eq_bot_of_isLieAbelian
code: lemma ideal_eq_bot_of_isLieAbelian [IsDomain R] [IsPrincipalIdealRing R]
    (I : LieIdeal R L) [IsLieAbelian I] : I = ⊥ 
goal: I = ⊥

full_name: LieAlgebra.IsKilling.instSemisimple
code: instance instSemisimple [IsKilling K L] [Module.Finite K L] : IsSemisimple K L 
goal: LieAlgebra.IsSemisimple K L

full_name: LieAlgebra.IsKilling.instHasTrivialRadical
code: /-- The converse of this is true over a field of characteristic zero. There are counterexamples
over fields with positive characteristic.

Note that when the coefficients are a field this instance is redundant since we have
`LieAlgebra.IsKilling.instSemisimple` and `LieAlgebra.IsSemisimple.instHasTrivialRadical`. -/
instance instHasTrivialRadical [IsDomain R] [IsPrincipalIdealRing R] : HasTrivialRadical R L 
goal: LieAlgebra.HasTrivialRadical R L

full_name: LieAlgebra.killingForm_of_equiv_apply
code: /-- Given an equivalence `e` of Lie algebras from `L` to `L'`, and elements `x y : L`, the
respective Killing forms of `L` and `L'` satisfy `κ'(e x, e y) = κ(x, y)`. -/
@[simp] lemma killingForm_of_equiv_apply (e : L ≃ₗ⁅R⁆ L') (x y : L) :
    killingForm R L' (e x) (e y) = killingForm R L x y 
goal: ((killingForm R L') (e x)) (e y) = ((killingForm R L) x) y

full_name: LieAlgebra.isKilling_of_equiv
code: /-- Given a Killing Lie algebra `L`, if `L'` is isomorphic to `L`, then `L'` is Killing too. -/
lemma isKilling_of_equiv [IsKilling R L] (e : L ≃ₗ⁅R⁆ L') : IsKilling R L' 
goal: LieAlgebra.IsKilling R L'
File: Mathlib/Algebra/Lie/EngelSubalgebra.lean

full_name: LieSubalgebra.engel
code: /-- The Engel subalgebra `Engel R x` consists of
all `y : L` such that `(ad R L x)^n` kills `y` for some `n`.

Engel subalgebras are self-normalizing (`LieSubalgebra.normalizer_engel`),
and minimal ones are nilpotent, hence Cartan subalgebras. -/
@[simps!]
def engel (x : L) : LieSubalgebra R L 
goal: LieSubalgebra R L

full_name: LieSubalgebra.engel_carrier
code: /-- The Engel subalgebra `Engel R x` consists of
all `y : L` such that `(ad R L x)^n` kills `y` for some `n`.

Engel subalgebras are self-normalizing (`LieSubalgebra.normalizer_engel`),
and minimal ones are nilpotent, hence Cartan subalgebras. -/
@[simps!]
def engel (x : L) : LieSubalgebra R L 
goal: ↑(LieSubalgebra.engel R x) = ⋂ s ∈ fun x_1 => ∀ (a : ℕ), LinearMap.ker ((LieAlgebra.ad R L) x ^ a) ≤ x_1, ↑s

full_name: LieSubalgebra.mem_engel_iff
code: lemma mem_engel_iff (x y : L) :
    y ∈ engel R x ↔ ∃ n : ℕ, ((ad R L x) ^ n) y = 0 
goal: y ∈ LieSubalgebra.engel R x ↔ ∃ n, ((LieAlgebra.ad R L) x ^ n) y = 0

full_name: LieSubalgebra.self_mem_engel
code: lemma self_mem_engel (x : L) : x ∈ engel R x 
goal: x ∈ LieSubalgebra.engel R x

full_name: LieSubalgebra.engel_zero
code: @[simp]
lemma engel_zero : engel R (0 : L) = ⊤ 
goal: LieSubalgebra.engel R 0 = ⊤

full_name: LieSubalgebra.normalizer_engel
code: /-- Engel subalgebras are self-normalizing.
See `LieSubalgebra.normalizer_eq_self_of_engel_le` for a proof that Lie-subalgebras
containing an Engel subalgebra are also self-normalizing,
provided that the ambient Lie algebra is artinina. -/
@[simp]
lemma normalizer_engel (x : L) : normalizer (engel R x) = engel R x 
goal: (LieSubalgebra.engel R x).normalizer = LieSubalgebra.engel R x

full_name: LieSubalgebra.normalizer_eq_self_of_engel_le
code: /-- A Lie-subalgebra of an Artinian Lie algebra is self-normalizing
if it contains an Engel subalgebra.
See `LieSubalgebra.normalizer_engel` for a proof that Engel subalgebras are self-normalizing,
avoiding the Artinian condition. -/
lemma normalizer_eq_self_of_engel_le [IsArtinian R L]
    (H : LieSubalgebra R L) (x : L) (h : engel R x ≤ H) :
    normalizer H = H 
goal: H.normalizer = H

full_name: LieSubalgebra.isNilpotent_of_forall_le_engel
code: /-- A Lie subalgebra of a Noetherian Lie algebra is nilpotent
if it is contained in the Engel subalgebra of all its elements. -/
lemma isNilpotent_of_forall_le_engel [IsNoetherian R L]
    (H : LieSubalgebra R L) (h : ∀ x ∈ H, H ≤ engel R x) :
    LieAlgebra.IsNilpotent R H 
goal: LieAlgebra.IsNilpotent R ↥H
File: Mathlib/Algebra/Lie/NonUnitalNonAssocAlgebra.lean

full_name: CommutatorRing
code: /-- Type synonym for turning a `LieRing` into a `NonUnitalNonAssocSemiring`.

A `LieRing` can be regarded as a `NonUnitalNonAssocSemiring` by turning its
`Bracket` (denoted `⁅, ⁆`) into a `Mul` (denoted `*`). -/
def CommutatorRing (L : Type v) : Type v 
goal: Type v

full_name: instNonUnitalNonAssocSemiringCommutatorRing
code: /-- A `LieRing` can be regarded as a `NonUnitalNonAssocSemiring` by turning its
`Bracket` (denoted `⁅, ⁆`) into a `Mul` (denoted `*`). -/
instance : NonUnitalNonAssocSemiring (CommutatorRing L) 
goal: NonUnitalNonAssocSemiring (CommutatorRing L)

full_name: LieAlgebra.instNonemptyCommutatorRing
code: instance (L : Type v) [Nonempty L] : Nonempty (CommutatorRing L) 
goal: Nonempty (CommutatorRing L)

full_name: LieAlgebra.instInhabitedCommutatorRing
code: instance (L : Type v) [Inhabited L] : Inhabited (CommutatorRing L) 
goal: Inhabited (CommutatorRing L)

full_name: LieAlgebra.instLieRingCommutatorRing
code: instance : LieRing (CommutatorRing L) 
goal: LieRing (CommutatorRing L)

full_name: LieAlgebra.instCommutatorRing
code: instance : LieAlgebra R (CommutatorRing L) 
goal: LieAlgebra R (CommutatorRing L)

full_name: LieAlgebra.isScalarTower
code: /-- Regarding the `LieRing` of a `LieAlgebra` as a `NonUnitalNonAssocSemiring`, we can
reinterpret the `smul_lie` law as an `IsScalarTower`. -/
instance isScalarTower : IsScalarTower R (CommutatorRing L) (CommutatorRing L) 
goal: IsScalarTower R (CommutatorRing L) (CommutatorRing L)

full_name: LieAlgebra.smulCommClass
code: /-- Regarding the `LieRing` of a `LieAlgebra` as a `NonUnitalNonAssocSemiring`, we can
reinterpret the `lie_smul` law as an `SMulCommClass`. -/
instance smulCommClass : SMulCommClass R (CommutatorRing L) (CommutatorRing L) 
goal: SMulCommClass R (CommutatorRing L) (CommutatorRing L)

full_name: LieHom.toNonUnitalAlgHom_apply
code: /-- Regarding the `LieRing` of a `LieAlgebra` as a `NonUnitalNonAssocSemiring`, we can
regard a `LieHom` as a `NonUnitalAlgHom`. -/
@[simps]
def toNonUnitalAlgHom (f : L →ₗ⁅R⁆ L₂) : CommutatorRing L →ₙₐ[R] CommutatorRing L₂ 
goal: f.toNonUnitalAlgHom a = f a

full_name: LieHom.toNonUnitalAlgHom_toFun
code: /-- Regarding the `LieRing` of a `LieAlgebra` as a `NonUnitalNonAssocSemiring`, we can
regard a `LieHom` as a `NonUnitalAlgHom`. -/
@[simps]
def toNonUnitalAlgHom (f : L →ₗ⁅R⁆ L₂) : CommutatorRing L →ₙₐ[R] CommutatorRing L₂ 
goal: f.toNonUnitalAlgHom a = f a

full_name: LieHom.toNonUnitalAlgHom
code: /-- Regarding the `LieRing` of a `LieAlgebra` as a `NonUnitalNonAssocSemiring`, we can
regard a `LieHom` as a `NonUnitalAlgHom`. -/
@[simps]
def toNonUnitalAlgHom (f : L →ₗ⁅R⁆ L₂) : CommutatorRing L →ₙₐ[R] CommutatorRing L₂ 
goal: CommutatorRing L →ₙₐ[R] CommutatorRing L₂

full_name: LieHom.toNonUnitalAlgHom_injective
code: theorem toNonUnitalAlgHom_injective :
    Function.Injective (toNonUnitalAlgHom : _ → CommutatorRing L →ₙₐ[R] CommutatorRing L₂) 
goal: Function.Injective LieHom.toNonUnitalAlgHom