File: Mathlib/Algebra/Lie/Free.lean

full_name: _aux_Mathlib_Algebra_Lie_Free___unexpand_FreeNonUnitalNonAssocAlgebra_1
code: local notation "lib" => FreeNonUnitalNonAssocAlgebra
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_Algebra_Lie_Free___macroRules_termLib_1
code: local notation "lib" => FreeNonUnitalNonAssocAlgebra
goal: Lean.Macro

full_name: «_aux_Mathlib_Algebra_Lie_Free___macroRules_termLib.lift_1»
code: local notation "lib.lift" => FreeNonUnitalNonAssocAlgebra.lift
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Lie_Free___unexpand_FreeNonUnitalNonAssocAlgebra_lift_1
code: local notation "lib.lift" => FreeNonUnitalNonAssocAlgebra.lift
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Lie_Free___macroRules_termLib.of_1»
code: local notation "lib.of" => FreeNonUnitalNonAssocAlgebra.of
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Lie_Free___unexpand_FreeNonUnitalNonAssocAlgebra_of_1
code: local notation "lib.of" => FreeNonUnitalNonAssocAlgebra.of
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Lie_Free___macroRules_termLib.lift_of_apply_1»
code: local notation "lib.lift_of_apply" => FreeNonUnitalNonAssocAlgebra.lift_of_apply
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Lie_Free___unexpand_FreeNonUnitalNonAssocAlgebra_lift_of_apply_1
code: local notation "lib.lift_of_apply" => FreeNonUnitalNonAssocAlgebra.lift_of_apply
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Algebra_Lie_Free___macroRules_termLib.lift_comp_of_1»
code: local notation "lib.lift_comp_of" => FreeNonUnitalNonAssocAlgebra.lift_comp_of
goal: Lean.Macro

full_name: _aux_Mathlib_Algebra_Lie_Free___unexpand_FreeNonUnitalNonAssocAlgebra_lift_comp_of_1
code: local notation "lib.lift_comp_of" => FreeNonUnitalNonAssocAlgebra.lift_comp_of
goal: Lean.PrettyPrinter.Unexpander

full_name: FreeLieAlgebra.Rel.add_right
code: /-- The quotient of `lib R X` by the equivalence relation generated by this relation will give us
the free Lie algebra. -/
inductive Rel : lib R X → lib R X → Prop
  | lie_self (a : lib R X) : Rel (a * a) 0
  | leibniz_lie (a b c : lib R X) : Rel (a * (b * c)) (a * b * c + b * (a * c))
  | smul (t : R) {a b : lib R X} : Rel a b → Rel (t • a) (t • b)
  | add_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a + c) (b + c)
  | mul_left (a : lib R X) {b c : lib R X} : Rel b c → Rel (a * b) (a * c)
  | mul_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a * c) (b * c)
goal: FreeLieAlgebra.Rel R X a b → FreeLieAlgebra.Rel R X (a + c) (b + c)

full_name: FreeLieAlgebra.Rel.mul_right
code: /-- The quotient of `lib R X` by the equivalence relation generated by this relation will give us
the free Lie algebra. -/
inductive Rel : lib R X → lib R X → Prop
  | lie_self (a : lib R X) : Rel (a * a) 0
  | leibniz_lie (a b c : lib R X) : Rel (a * (b * c)) (a * b * c + b * (a * c))
  | smul (t : R) {a b : lib R X} : Rel a b → Rel (t • a) (t • b)
  | add_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a + c) (b + c)
  | mul_left (a : lib R X) {b c : lib R X} : Rel b c → Rel (a * b) (a * c)
  | mul_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a * c) (b * c)
goal: FreeLieAlgebra.Rel R X a b → FreeLieAlgebra.Rel R X (a * c) (b * c)

full_name: FreeLieAlgebra.Rel
code: /-- The quotient of `lib R X` by the equivalence relation generated by this relation will give us
the free Lie algebra. -/
inductive Rel : lib R X → lib R X → Prop
  | lie_self (a : lib R X) : Rel (a * a) 0
  | leibniz_lie (a b c : lib R X) : Rel (a * (b * c)) (a * b * c + b * (a * c))
  | smul (t : R) {a b : lib R X} : Rel a b → Rel (t • a) (t • b)
  | add_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a + c) (b + c)
  | mul_left (a : lib R X) {b c : lib R X} : Rel b c → Rel (a * b) (a * c)
  | mul_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a * c) (b * c)
goal: lib R X → lib R X → Prop

full_name: FreeLieAlgebra.Rel.lie_self
code: /-- The quotient of `lib R X` by the equivalence relation generated by this relation will give us
the free Lie algebra. -/
inductive Rel : lib R X → lib R X → Prop
  | lie_self (a : lib R X) : Rel (a * a) 0
  | leibniz_lie (a b c : lib R X) : Rel (a * (b * c)) (a * b * c + b * (a * c))
  | smul (t : R) {a b : lib R X} : Rel a b → Rel (t • a) (t • b)
  | add_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a + c) (b + c)
  | mul_left (a : lib R X) {b c : lib R X} : Rel b c → Rel (a * b) (a * c)
  | mul_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a * c) (b * c)
goal: FreeLieAlgebra.Rel R X (a * a) 0

full_name: FreeLieAlgebra.Rel.leibniz_lie
code: /-- The quotient of `lib R X` by the equivalence relation generated by this relation will give us
the free Lie algebra. -/
inductive Rel : lib R X → lib R X → Prop
  | lie_self (a : lib R X) : Rel (a * a) 0
  | leibniz_lie (a b c : lib R X) : Rel (a * (b * c)) (a * b * c + b * (a * c))
  | smul (t : R) {a b : lib R X} : Rel a b → Rel (t • a) (t • b)
  | add_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a + c) (b + c)
  | mul_left (a : lib R X) {b c : lib R X} : Rel b c → Rel (a * b) (a * c)
  | mul_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a * c) (b * c)
goal: FreeLieAlgebra.Rel R X (a * (b * c)) (a * b * c + b * (a * c))

full_name: FreeLieAlgebra.Rel.smul
code: /-- The quotient of `lib R X` by the equivalence relation generated by this relation will give us
the free Lie algebra. -/
inductive Rel : lib R X → lib R X → Prop
  | lie_self (a : lib R X) : Rel (a * a) 0
  | leibniz_lie (a b c : lib R X) : Rel (a * (b * c)) (a * b * c + b * (a * c))
  | smul (t : R) {a b : lib R X} : Rel a b → Rel (t • a) (t • b)
  | add_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a + c) (b + c)
  | mul_left (a : lib R X) {b c : lib R X} : Rel b c → Rel (a * b) (a * c)
  | mul_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a * c) (b * c)
goal: FreeLieAlgebra.Rel R X a b → FreeLieAlgebra.Rel R X (t • a) (t • b)

full_name: FreeLieAlgebra.Rel.mul_left
code: /-- The quotient of `lib R X` by the equivalence relation generated by this relation will give us
the free Lie algebra. -/
inductive Rel : lib R X → lib R X → Prop
  | lie_self (a : lib R X) : Rel (a * a) 0
  | leibniz_lie (a b c : lib R X) : Rel (a * (b * c)) (a * b * c + b * (a * c))
  | smul (t : R) {a b : lib R X} : Rel a b → Rel (t • a) (t • b)
  | add_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a + c) (b + c)
  | mul_left (a : lib R X) {b c : lib R X} : Rel b c → Rel (a * b) (a * c)
  | mul_right {a b : lib R X} (c : lib R X) : Rel a b → Rel (a * c) (b * c)
goal: FreeLieAlgebra.Rel R X b c → FreeLieAlgebra.Rel R X (a * b) (a * c)

full_name: FreeLieAlgebra.Rel.addLeft
code: theorem Rel.addLeft (a : lib R X) {b c : lib R X} (h : Rel R X b c) : Rel R X (a + b) (a + c) 
goal: FreeLieAlgebra.Rel R X (a + b) (a + c)

full_name: FreeLieAlgebra.Rel.neg
code: theorem Rel.neg {a b : lib R X} (h : Rel R X a b) : Rel R X (-a) (-b) 
goal: FreeLieAlgebra.Rel R X (-a) (-b)

full_name: FreeLieAlgebra.Rel.subLeft
code: theorem Rel.subLeft (a : lib R X) {b c : lib R X} (h : Rel R X b c) : Rel R X (a - b) (a - c) 
goal: FreeLieAlgebra.Rel R X (a - b) (a - c)

full_name: FreeLieAlgebra.Rel.subRight
code: theorem Rel.subRight {a b : lib R X} (c : lib R X) (h : Rel R X a b) : Rel R X (a - c) (b - c) 
goal: FreeLieAlgebra.Rel R X (a - c) (b - c)

full_name: FreeLieAlgebra.Rel.smulOfTower
code: theorem Rel.smulOfTower {S : Type*} [Monoid S] [DistribMulAction S R] [IsScalarTower S R R] (t : S)
    (a b : lib R X) (h : Rel R X a b) : Rel R X (t • a) (t • b) 
goal: FreeLieAlgebra.Rel R X (t • a) (t • b)

full_name: FreeLieAlgebra
code: /-- The free Lie algebra on the type `X` with coefficients in the commutative ring `R`. -/
def FreeLieAlgebra 
goal: Type (max u v)

full_name: instInhabitedFreeLieAlgebra
code: instance : Inhabited (FreeLieAlgebra R X) 
goal: Inhabited (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instSMulOfIsScalarTower
code: instance {S : Type*} [Monoid S] [DistribMulAction S R] [IsScalarTower S R R] :
    SMul S (FreeLieAlgebra R X) 
goal: SMul S (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instIsCentralScalar
code: instance {S : Type*} [Monoid S] [DistribMulAction S R] [DistribMulAction Sᵐᵒᵖ R]
    [IsScalarTower S R R] [IsCentralScalar S R] : IsCentralScalar S (FreeLieAlgebra R X) 
goal: IsCentralScalar S (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instZero
code: instance : Zero (FreeLieAlgebra R X) 
goal: Zero (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instAdd
code: instance : Add (FreeLieAlgebra R X) 
goal: Add (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instNeg
code: instance : Neg (FreeLieAlgebra R X) 
goal: Neg (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instSub
code: instance : Sub (FreeLieAlgebra R X) 
goal: Sub (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instAddGroup
code: instance : AddGroup (FreeLieAlgebra R X) 
goal: AddGroup (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instAddCommSemigroup
code: instance : AddCommSemigroup (FreeLieAlgebra R X) 
goal: AddCommSemigroup (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instAddCommGroup
code: instance : AddCommGroup (FreeLieAlgebra R X) 
goal: AddCommGroup (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instModuleOfIsScalarTower
code: instance {S : Type*} [Semiring S] [Module S R] [IsScalarTower S R R] :
    Module S (FreeLieAlgebra R X) 
goal: Module S (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instLieRing
code: /-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) 
goal: LieRing (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.instLieAlgebra
code: instance : LieAlgebra R (FreeLieAlgebra R X) 
goal: LieAlgebra R (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.of
code: /-- The embedding of `X` into the free Lie algebra of `X` with coefficients in the commutative ring
`R`. -/
def of : X → FreeLieAlgebra R X 
goal: X → FreeLieAlgebra R X

full_name: FreeLieAlgebra.liftAux
code: /-- An auxiliary definition used to construct the equivalence `lift` below. -/
def liftAux (f : X → CommutatorRing L) 
goal: lib R X →ₙₐ[R] CommutatorRing L

full_name: FreeLieAlgebra.liftAux_map_smul
code: theorem liftAux_map_smul (f : X → L) (t : R) (a : lib R X) :
    liftAux R f (t • a) = t • liftAux R f a 
goal: (FreeLieAlgebra.liftAux R f) (t • a) = t • (FreeLieAlgebra.liftAux R f) a

full_name: FreeLieAlgebra.liftAux_map_add
code: theorem liftAux_map_add (f : X → L) (a b : lib R X) :
    liftAux R f (a + b) = liftAux R f a + liftAux R f b 
goal: (FreeLieAlgebra.liftAux R f) (a + b) = (FreeLieAlgebra.liftAux R f) a + (FreeLieAlgebra.liftAux R f) b

full_name: FreeLieAlgebra.liftAux_map_mul
code: theorem liftAux_map_mul (f : X → L) (a b : lib R X) :
    liftAux R f (a * b) = ⁅liftAux R f a, liftAux R f b⁆ 
goal: (FreeLieAlgebra.liftAux R f) (a * b) = ⁅(FreeLieAlgebra.liftAux R f) a, (FreeLieAlgebra.liftAux R f) b⁆

full_name: FreeLieAlgebra.liftAux_spec
code: theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b 
goal: (FreeLieAlgebra.liftAux R f) a = (FreeLieAlgebra.liftAux R f) b

full_name: FreeLieAlgebra.mk
code: /-- The quotient map as a `NonUnitalAlgHom`. -/
def mk : lib R X →ₙₐ[R] CommutatorRing (FreeLieAlgebra R X) 
goal: lib R X →ₙₐ[R] CommutatorRing (FreeLieAlgebra R X)

full_name: FreeLieAlgebra.lift
code: /-- The functor `X ↦ FreeLieAlgebra R X` from the category of types to the category of Lie
algebras over `R` is adjoint to the forgetful functor in the other direction. -/
def lift : (X → L) ≃ (FreeLieAlgebra R X →ₗ⁅R⁆ L) 
goal: (X → L) ≃ (FreeLieAlgebra R X →ₗ⁅R⁆ L)

full_name: FreeLieAlgebra.lift_symm_apply
code: @[simp]
theorem lift_symm_apply (F : FreeLieAlgebra R X →ₗ⁅R⁆ L) : (lift R).symm F = F ∘ of R 
goal: (FreeLieAlgebra.lift R).symm F = ⇑F ∘ FreeLieAlgebra.of R

full_name: FreeLieAlgebra.of_comp_lift
code: @[simp]
theorem of_comp_lift (f : X → L) : lift R f ∘ of R = f 
goal: ⇑((FreeLieAlgebra.lift R) f) ∘ FreeLieAlgebra.of R = f

full_name: FreeLieAlgebra.lift_unique
code: @[simp]
theorem lift_unique (f : X → L) (g : FreeLieAlgebra R X →ₗ⁅R⁆ L) : g ∘ of R = f ↔ g = lift R f 
goal: ⇑g ∘ FreeLieAlgebra.of R = f ↔ g = (FreeLieAlgebra.lift R) f

full_name: FreeLieAlgebra.lift_of_apply
code: @[simp]
theorem lift_of_apply (f : X → L) (x) : lift R f (of R x) = f x 
goal: ((FreeLieAlgebra.lift R) f) (FreeLieAlgebra.of R x) = f x

full_name: FreeLieAlgebra.lift_comp_of
code: @[simp]
theorem lift_comp_of (F : FreeLieAlgebra R X →ₗ⁅R⁆ L) : lift R (F ∘ of R) = F 
goal: (FreeLieAlgebra.lift R) (⇑F ∘ FreeLieAlgebra.of R) = F

full_name: FreeLieAlgebra.hom_ext
code: @[ext]
theorem hom_ext {F₁ F₂ : FreeLieAlgebra R X →ₗ⁅R⁆ L} (h : ∀ x, F₁ (of R x) = F₂ (of R x)) :
    F₁ = F₂ 
goal: F₁ = F₂

full_name: FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra
code: /-- The universal enveloping algebra of the free Lie algebra is just the free unital associative
algebra. -/
@[simps!]
def universalEnvelopingEquivFreeAlgebra :
    UniversalEnvelopingAlgebra R (FreeLieAlgebra R X) ≃ₐ[R] FreeAlgebra R X 
goal: UniversalEnvelopingAlgebra R (FreeLieAlgebra R X) ≃ₐ[R] FreeAlgebra R X

full_name: FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra_apply
code: /-- The universal enveloping algebra of the free Lie algebra is just the free unital associative
algebra. -/
@[simps!]
def universalEnvelopingEquivFreeAlgebra :
    UniversalEnvelopingAlgebra R (FreeLieAlgebra R X) ≃ₐ[R] FreeAlgebra R X 
goal: (FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra R X) a =
  ((UniversalEnvelopingAlgebra.lift R) ((FreeLieAlgebra.lift R) (FreeAlgebra.ι R))) a

full_name: FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra_symm_apply
code: /-- The universal enveloping algebra of the free Lie algebra is just the free unital associative
algebra. -/
@[simps!]
def universalEnvelopingEquivFreeAlgebra :
    UniversalEnvelopingAlgebra R (FreeLieAlgebra R X) ≃ₐ[R] FreeAlgebra R X 
goal: (FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra R X).symm a =
  ((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ FreeLieAlgebra.of R)) a