[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
a b c : lib R X
h : Rel R X b c
⊢ Rel R X (a + b) (a + c)
[PROOFSTEP]
rw [add_comm _ b, add_comm _ c]
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
a b c : lib R X
h : Rel R X b c
⊢ Rel R X (b + a) (c + a)
[PROOFSTEP]
exact h.add_right _
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
a b : lib R X
h : Rel R X a b
⊢ Rel R X (-a) (-b)
[PROOFSTEP]
simpa only [neg_one_smul] using h.smul (-1)
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
a b c : lib R X
h : Rel R X b c
⊢ Rel R X (a - b) (a - c)
[PROOFSTEP]
simpa only [sub_eq_add_neg] using h.neg.addLeft a
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
a b c : lib R X
h : Rel R X a b
⊢ Rel R X (a - c) (b - c)
[PROOFSTEP]
simpa only [sub_eq_add_neg] using h.add_right (-c)
[GOAL]
R : Type u
X : Type v
inst✝³ : CommRing R
S : Type u_1
inst✝² : Monoid S
inst✝¹ : DistribMulAction S R
inst✝ : IsScalarTower S R R
t : S
a b : lib R X
h : Rel R X a b
⊢ Rel R X (t • a) (t • b)
[PROOFSTEP]
rw [← smul_one_smul R t a, ← smul_one_smul R t b]
[GOAL]
R : Type u
X : Type v
inst✝³ : CommRing R
S : Type u_1
inst✝² : Monoid S
inst✝¹ : DistribMulAction S R
inst✝ : IsScalarTower S R R
t : S
a b : lib R X
h : Rel R X a b
⊢ Rel R X ((t • 1) • a) ((t • 1) • b)
[PROOFSTEP]
exact h.smul _
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
⊢ Inhabited (FreeLieAlgebra R X)
[PROOFSTEP]
rw [FreeLieAlgebra]
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
⊢ Inhabited (Quot (FreeLieAlgebra.Rel R X))
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
⊢ ∀ (x y z : FreeLieAlgebra R X), ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩
[GOAL]
case mk.mk.mk
R : Type u
X : Type v
inst✝ : CommRing R
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
b : lib R X
z✝ : FreeLieAlgebra R X
c : lib R X
⊢ ⁅Quot.mk (Rel R X) a + Quot.mk (Rel R X) b, Quot.mk (Rel R X) c⁆ =
    ⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) c⁆ + ⁅Quot.mk (Rel R X) b, Quot.mk (Rel R X) c⁆
[PROOFSTEP]
change Quot.mk _ _ = Quot.mk _ _
[GOAL]
case mk.mk.mk
R : Type u
X : Type v
inst✝ : CommRing R
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
b : lib R X
z✝ : FreeLieAlgebra R X
c : lib R X
⊢ Quot.mk (Rel R X) ((fun x x_1 => x * x_1) ((fun x x_1 => x + x_1) a b) c) =
    Quot.mk (Rel R X) ((fun x x_1 => x + x_1) ((fun x x_1 => x * x_1) a c) ((fun x x_1 => x * x_1) b c))
[PROOFSTEP]
simp_rw [add_mul]
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
⊢ ∀ (x y z : FreeLieAlgebra R X), ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩
[GOAL]
case mk.mk.mk
R : Type u
X : Type v
inst✝ : CommRing R
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
b : lib R X
z✝ : FreeLieAlgebra R X
c : lib R X
⊢ ⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) b + Quot.mk (Rel R X) c⁆ =
    ⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) b⁆ + ⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) c⁆
[PROOFSTEP]
change Quot.mk _ _ = Quot.mk _ _
[GOAL]
case mk.mk.mk
R : Type u
X : Type v
inst✝ : CommRing R
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
b : lib R X
z✝ : FreeLieAlgebra R X
c : lib R X
⊢ Quot.mk (Rel R X) ((fun x x_1 => x * x_1) a ((fun x x_1 => x + x_1) b c)) =
    Quot.mk (Rel R X) ((fun x x_1 => x + x_1) ((fun x x_1 => x * x_1) a b) ((fun x x_1 => x * x_1) a c))
[PROOFSTEP]
simp_rw [mul_add]
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
⊢ ∀ (x : FreeLieAlgebra R X), ⁅x, x⁆ = 0
[PROOFSTEP]
rintro ⟨a⟩
[GOAL]
case mk
R : Type u
X : Type v
inst✝ : CommRing R
x✝ : FreeLieAlgebra R X
a : lib R X
⊢ ⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) a⁆ = 0
[PROOFSTEP]
exact Quot.sound (Rel.lie_self a)
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
⊢ ∀ (x y z : FreeLieAlgebra R X), ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩
[GOAL]
case mk.mk.mk
R : Type u
X : Type v
inst✝ : CommRing R
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
b : lib R X
z✝ : FreeLieAlgebra R X
c : lib R X
⊢ ⁅Quot.mk (Rel R X) a, ⁅Quot.mk (Rel R X) b, Quot.mk (Rel R X) c⁆⁆ =
    ⁅⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) b⁆, Quot.mk (Rel R X) c⁆ +
      ⁅Quot.mk (Rel R X) b, ⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) c⁆⁆
[PROOFSTEP]
exact Quot.sound (Rel.leibniz_lie a b c)
[GOAL]
R : Type u
X : Type v
inst✝ : CommRing R
⊢ ∀ (t : R) (x y : FreeLieAlgebra R X), ⁅x, t • y⁆ = t • ⁅x, y⁆
[PROOFSTEP]
rintro t ⟨a⟩ ⟨c⟩
[GOAL]
case mk.mk
R : Type u
X : Type v
inst✝ : CommRing R
t : R
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
c : lib R X
⊢ ⁅Quot.mk (Rel R X) a, t • Quot.mk (Rel R X) c⁆ = t • ⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) c⁆
[PROOFSTEP]
change Quot.mk _ (a • t • c) = Quot.mk _ (t • a • c)
[GOAL]
case mk.mk
R : Type u
X : Type v
inst✝ : CommRing R
t : R
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
c : lib R X
⊢ Quot.mk (Rel R X) (a • t • c) = Quot.mk (Rel R X) (t • a • c)
[PROOFSTEP]
rw [← smul_comm]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b : lib R X
h : Rel R X a b
⊢ ↑(liftAux R f) a = ↑(liftAux R f) b
[PROOFSTEP]
induction h
[GOAL]
case lie_self
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝ : lib R X
⊢ ↑(liftAux R f) (a✝ * a✝) = ↑(liftAux R f) 0
case leibniz_lie
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝ b✝ c✝ : lib R X
⊢ ↑(liftAux R f) (a✝ * (b✝ * c✝)) = ↑(liftAux R f) (a✝ * b✝ * c✝ + b✝ * (a✝ * c✝))
case smul
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b : lib R X
t✝ : R
a✝¹ b✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (t✝ • a✝¹) = ↑(liftAux R f) (t✝ • b✝)
case add_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (a✝¹ + c✝) = ↑(liftAux R f) (b✝ + c✝)
case mul_left
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X b✝ c✝
a_ih✝ : ↑(liftAux R f) b✝ = ↑(liftAux R f) c✝
⊢ ↑(liftAux R f) (a✝¹ * b✝) = ↑(liftAux R f) (a✝¹ * c✝)
case mul_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (a✝¹ * c✝) = ↑(liftAux R f) (b✝ * c✝)
[PROOFSTEP]
case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' : lib R X
⊢ ↑(liftAux R f) (a' * a') = ↑(liftAux R f) 0
[PROOFSTEP]
case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' : lib R X
⊢ ↑(liftAux R f) (a' * a') = ↑(liftAux R f) 0
[PROOFSTEP]
simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
[GOAL]
case leibniz_lie
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝ b✝ c✝ : lib R X
⊢ ↑(liftAux R f) (a✝ * (b✝ * c✝)) = ↑(liftAux R f) (a✝ * b✝ * c✝ + b✝ * (a✝ * c✝))
case smul
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b : lib R X
t✝ : R
a✝¹ b✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (t✝ • a✝¹) = ↑(liftAux R f) (t✝ • b✝)
case add_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (a✝¹ + c✝) = ↑(liftAux R f) (b✝ + c✝)
case mul_left
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X b✝ c✝
a_ih✝ : ↑(liftAux R f) b✝ = ↑(liftAux R f) c✝
⊢ ↑(liftAux R f) (a✝¹ * b✝) = ↑(liftAux R f) (a✝¹ * c✝)
case mul_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (a✝¹ * c✝) = ↑(liftAux R f) (b✝ * c✝)
[PROOFSTEP]
case leibniz_lie a' b' c' => simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' b' c' : lib R X
⊢ ↑(liftAux R f) (a' * (b' * c')) = ↑(liftAux R f) (a' * b' * c' + b' * (a' * c'))
[PROOFSTEP]
case leibniz_lie a' b' c' => simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' b' c' : lib R X
⊢ ↑(liftAux R f) (a' * (b' * c')) = ↑(liftAux R f) (a' * b' * c' + b' * (a' * c'))
[PROOFSTEP]
simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
[GOAL]
case smul
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b : lib R X
t✝ : R
a✝¹ b✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (t✝ • a✝¹) = ↑(liftAux R f) (t✝ • b✝)
case add_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (a✝¹ + c✝) = ↑(liftAux R f) (b✝ + c✝)
case mul_left
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X b✝ c✝
a_ih✝ : ↑(liftAux R f) b✝ = ↑(liftAux R f) c✝
⊢ ↑(liftAux R f) (a✝¹ * b✝) = ↑(liftAux R f) (a✝¹ * c✝)
case mul_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (a✝¹ * c✝) = ↑(liftAux R f) (b✝ * c✝)
[PROOFSTEP]
case smul t a' b' _ h₂ => simp only [liftAux_map_smul, h₂]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b : lib R X
t : R
a' b' : lib R X
a✝ : Rel R X a' b'
h₂ : ↑(liftAux R f) a' = ↑(liftAux R f) b'
⊢ ↑(liftAux R f) (t • a') = ↑(liftAux R f) (t • b')
[PROOFSTEP]
case smul t a' b' _ h₂ => simp only [liftAux_map_smul, h₂]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b : lib R X
t : R
a' b' : lib R X
a✝ : Rel R X a' b'
h₂ : ↑(liftAux R f) a' = ↑(liftAux R f) b'
⊢ ↑(liftAux R f) (t • a') = ↑(liftAux R f) (t • b')
[PROOFSTEP]
simp only [liftAux_map_smul, h₂]
[GOAL]
case add_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (a✝¹ + c✝) = ↑(liftAux R f) (b✝ + c✝)
case mul_left
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X b✝ c✝
a_ih✝ : ↑(liftAux R f) b✝ = ↑(liftAux R f) c✝
⊢ ↑(liftAux R f) (a✝¹ * b✝) = ↑(liftAux R f) (a✝¹ * c✝)
case mul_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (a✝¹ * c✝) = ↑(liftAux R f) (b✝ * c✝)
[PROOFSTEP]
case add_right a' b' c' _ h₂ => simp only [liftAux_map_add, h₂]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' b' c' : lib R X
a✝ : Rel R X a' b'
h₂ : ↑(liftAux R f) a' = ↑(liftAux R f) b'
⊢ ↑(liftAux R f) (a' + c') = ↑(liftAux R f) (b' + c')
[PROOFSTEP]
case add_right a' b' c' _ h₂ => simp only [liftAux_map_add, h₂]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' b' c' : lib R X
a✝ : Rel R X a' b'
h₂ : ↑(liftAux R f) a' = ↑(liftAux R f) b'
⊢ ↑(liftAux R f) (a' + c') = ↑(liftAux R f) (b' + c')
[PROOFSTEP]
simp only [liftAux_map_add, h₂]
[GOAL]
case mul_left
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X b✝ c✝
a_ih✝ : ↑(liftAux R f) b✝ = ↑(liftAux R f) c✝
⊢ ↑(liftAux R f) (a✝¹ * b✝) = ↑(liftAux R f) (a✝¹ * c✝)
case mul_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (a✝¹ * c✝) = ↑(liftAux R f) (b✝ * c✝)
[PROOFSTEP]
case mul_left a' b' c' _ h₂ => simp only [liftAux_map_mul, h₂]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' b' c' : lib R X
a✝ : Rel R X b' c'
h₂ : ↑(liftAux R f) b' = ↑(liftAux R f) c'
⊢ ↑(liftAux R f) (a' * b') = ↑(liftAux R f) (a' * c')
[PROOFSTEP]
case mul_left a' b' c' _ h₂ => simp only [liftAux_map_mul, h₂]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' b' c' : lib R X
a✝ : Rel R X b' c'
h₂ : ↑(liftAux R f) b' = ↑(liftAux R f) c'
⊢ ↑(liftAux R f) (a' * b') = ↑(liftAux R f) (a' * c')
[PROOFSTEP]
simp only [liftAux_map_mul, h₂]
[GOAL]
case mul_right
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a✝¹ b✝ c✝ : lib R X
a✝ : Rel R X a✝¹ b✝
a_ih✝ : ↑(liftAux R f) a✝¹ = ↑(liftAux R f) b✝
⊢ ↑(liftAux R f) (a✝¹ * c✝) = ↑(liftAux R f) (b✝ * c✝)
[PROOFSTEP]
case mul_right a' b' c' _ h₂ => simp only [liftAux_map_mul, h₂]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' b' c' : lib R X
a✝ : Rel R X a' b'
h₂ : ↑(liftAux R f) a' = ↑(liftAux R f) b'
⊢ ↑(liftAux R f) (a' * c') = ↑(liftAux R f) (b' * c')
[PROOFSTEP]
case mul_right a' b' c' _ h₂ => simp only [liftAux_map_mul, h₂]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
a b a' b' c' : lib R X
a✝ : Rel R X a' b'
h₂ : ↑(liftAux R f) a' = ↑(liftAux R f) b'
⊢ ↑(liftAux R f) (a' * c') = ↑(liftAux R f) (b' * c')
[PROOFSTEP]
simp only [liftAux_map_mul, h₂]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
⊢ ∀ (x y : FreeLieAlgebra R X),
    (fun c => Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
        (x + y) =
      (fun c => Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
          x +
        (fun c =>
            Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
          y
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩
[GOAL]
case mk.mk
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
b : lib R X
⊢ (fun c => Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
      (Quot.mk (Rel R X) a + Quot.mk (Rel R X) b) =
    (fun c => Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
        (Quot.mk (Rel R X) a) +
      (fun c => Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
        (Quot.mk (Rel R X) b)
[PROOFSTEP]
rw [← liftAux_map_add]
[GOAL]
case mk.mk
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
b : lib R X
⊢ (fun c => Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
      (Quot.mk (Rel R X) a + Quot.mk (Rel R X) b) =
    ↑(liftAux R f) (a + b)
[PROOFSTEP]
rfl
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
⊢ ∀ (r : R) (x : FreeLieAlgebra R X),
    AddHom.toFun
        {
          toFun := fun c =>
            Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
          map_add' :=
            (_ :
              ∀ (x y : FreeLieAlgebra R X),
                (fun c =>
                      Quot.liftOn c ↑(liftAux R f)
                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                    (x + y) =
                  (fun c =>
                        Quot.liftOn c ↑(liftAux R f)
                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                      x +
                    (fun c =>
                        Quot.liftOn c ↑(liftAux R f)
                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                      y) }
        (r • x) =
      ↑(RingHom.id R) r •
        AddHom.toFun
          {
            toFun := fun c =>
              Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
            map_add' :=
              (_ :
                ∀ (x y : FreeLieAlgebra R X),
                  (fun c =>
                        Quot.liftOn c ↑(liftAux R f)
                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                      (x + y) =
                    (fun c =>
                          Quot.liftOn c ↑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                        x +
                      (fun c =>
                          Quot.liftOn c ↑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                        y) }
          x
[PROOFSTEP]
rintro t ⟨a⟩
[GOAL]
case mk
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
t : R
x✝ : FreeLieAlgebra R X
a : lib R X
⊢ AddHom.toFun
      {
        toFun := fun c =>
          Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
        map_add' :=
          (_ :
            ∀ (x y : FreeLieAlgebra R X),
              (fun c =>
                    Quot.liftOn c ↑(liftAux R f)
                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                  (x + y) =
                (fun c =>
                      Quot.liftOn c ↑(liftAux R f)
                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                    x +
                  (fun c =>
                      Quot.liftOn c ↑(liftAux R f)
                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                    y) }
      (t • Quot.mk (Rel R X) a) =
    ↑(RingHom.id R) t •
      AddHom.toFun
        {
          toFun := fun c =>
            Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
          map_add' :=
            (_ :
              ∀ (x y : FreeLieAlgebra R X),
                (fun c =>
                      Quot.liftOn c ↑(liftAux R f)
                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                    (x + y) =
                  (fun c =>
                        Quot.liftOn c ↑(liftAux R f)
                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                      x +
                    (fun c =>
                        Quot.liftOn c ↑(liftAux R f)
                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                      y) }
        (Quot.mk (Rel R X) a)
[PROOFSTEP]
rw [← liftAux_map_smul]
[GOAL]
case mk
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
t : R
x✝ : FreeLieAlgebra R X
a : lib R X
⊢ AddHom.toFun
      {
        toFun := fun c =>
          Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
        map_add' :=
          (_ :
            ∀ (x y : FreeLieAlgebra R X),
              (fun c =>
                    Quot.liftOn c ↑(liftAux R f)
                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                  (x + y) =
                (fun c =>
                      Quot.liftOn c ↑(liftAux R f)
                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                    x +
                  (fun c =>
                      Quot.liftOn c ↑(liftAux R f)
                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                    y) }
      (t • Quot.mk (Rel R X) a) =
    ↑(liftAux ((fun x => R) t) f) (↑(RingHom.id R) t • a)
[PROOFSTEP]
rfl
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
⊢ ∀ {x y : FreeLieAlgebra R X},
    AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun c =>
                  Quot.liftOn c ↑(liftAux R f)
                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                map_add' :=
                  (_ :
                    ∀ (x y : FreeLieAlgebra R X),
                      (fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                          (x + y) =
                        (fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                            x +
                          (fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                            y) },
            map_smul' :=
              (_ :
                ∀ (t : R) (x : FreeLieAlgebra R X),
                  AddHom.toFun
                      {
                        toFun := fun c =>
                          Quot.liftOn c ↑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                        map_add' :=
                          (_ :
                            ∀ (x y : FreeLieAlgebra R X),
                              (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  (x + y) =
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    x +
                                  (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    y) }
                      (t • x) =
                    ↑(RingHom.id R) t •
                      AddHom.toFun
                        {
                          toFun := fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                          map_add' :=
                            (_ :
                              ∀ (x y : FreeLieAlgebra R X),
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    (x + y) =
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      x +
                                    (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      y) }
                        x) }.toAddHom
        ⁅x, y⁆ =
      ⁅AddHom.toFun
          {
              toAddHom :=
                {
                  toFun := fun c =>
                    Quot.liftOn c ↑(liftAux R f)
                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                  map_add' :=
                    (_ :
                      ∀ (x y : FreeLieAlgebra R X),
                        (fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                            (x + y) =
                          (fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                              x +
                            (fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                              y) },
              map_smul' :=
                (_ :
                  ∀ (t : R) (x : FreeLieAlgebra R X),
                    AddHom.toFun
                        {
                          toFun := fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                          map_add' :=
                            (_ :
                              ∀ (x y : FreeLieAlgebra R X),
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    (x + y) =
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      x +
                                    (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      y) }
                        (t • x) =
                      ↑(RingHom.id R) t •
                        AddHom.toFun
                          {
                            toFun := fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                            map_add' :=
                              (_ :
                                ∀ (x y : FreeLieAlgebra R X),
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      (x + y) =
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        x +
                                      (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        y) }
                          x) }.toAddHom
          x,
        AddHom.toFun
          {
              toAddHom :=
                {
                  toFun := fun c =>
                    Quot.liftOn c ↑(liftAux R f)
                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                  map_add' :=
                    (_ :
                      ∀ (x y : FreeLieAlgebra R X),
                        (fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                            (x + y) =
                          (fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                              x +
                            (fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                              y) },
              map_smul' :=
                (_ :
                  ∀ (t : R) (x : FreeLieAlgebra R X),
                    AddHom.toFun
                        {
                          toFun := fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                          map_add' :=
                            (_ :
                              ∀ (x y : FreeLieAlgebra R X),
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    (x + y) =
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      x +
                                    (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      y) }
                        (t • x) =
                      ↑(RingHom.id R) t •
                        AddHom.toFun
                          {
                            toFun := fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                            map_add' :=
                              (_ :
                                ∀ (x y : FreeLieAlgebra R X),
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      (x + y) =
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        x +
                                      (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        y) }
                          x) }.toAddHom
          y⁆
[PROOFSTEP]
rintro ⟨a⟩ ⟨b⟩
[GOAL]
case mk.mk
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
b : lib R X
⊢ AddHom.toFun
      {
          toAddHom :=
            {
              toFun := fun c =>
                Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
              map_add' :=
                (_ :
                  ∀ (x y : FreeLieAlgebra R X),
                    (fun c =>
                          Quot.liftOn c ↑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                        (x + y) =
                      (fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                          x +
                        (fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                          y) },
          map_smul' :=
            (_ :
              ∀ (t : R) (x : FreeLieAlgebra R X),
                AddHom.toFun
                    {
                      toFun := fun c =>
                        Quot.liftOn c ↑(liftAux R f)
                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                      map_add' :=
                        (_ :
                          ∀ (x y : FreeLieAlgebra R X),
                            (fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                (x + y) =
                              (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  x +
                                (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  y) }
                    (t • x) =
                  ↑(RingHom.id R) t •
                    AddHom.toFun
                      {
                        toFun := fun c =>
                          Quot.liftOn c ↑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                        map_add' :=
                          (_ :
                            ∀ (x y : FreeLieAlgebra R X),
                              (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  (x + y) =
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    x +
                                  (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    y) }
                      x) }.toAddHom
      ⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) b⁆ =
    ⁅AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun c =>
                  Quot.liftOn c ↑(liftAux R f)
                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                map_add' :=
                  (_ :
                    ∀ (x y : FreeLieAlgebra R X),
                      (fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                          (x + y) =
                        (fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                            x +
                          (fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                            y) },
            map_smul' :=
              (_ :
                ∀ (t : R) (x : FreeLieAlgebra R X),
                  AddHom.toFun
                      {
                        toFun := fun c =>
                          Quot.liftOn c ↑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                        map_add' :=
                          (_ :
                            ∀ (x y : FreeLieAlgebra R X),
                              (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  (x + y) =
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    x +
                                  (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    y) }
                      (t • x) =
                    ↑(RingHom.id R) t •
                      AddHom.toFun
                        {
                          toFun := fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                          map_add' :=
                            (_ :
                              ∀ (x y : FreeLieAlgebra R X),
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    (x + y) =
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      x +
                                    (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      y) }
                        x) }.toAddHom
        (Quot.mk (Rel R X) a),
      AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun c =>
                  Quot.liftOn c ↑(liftAux R f)
                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                map_add' :=
                  (_ :
                    ∀ (x y : FreeLieAlgebra R X),
                      (fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                          (x + y) =
                        (fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                            x +
                          (fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                            y) },
            map_smul' :=
              (_ :
                ∀ (t : R) (x : FreeLieAlgebra R X),
                  AddHom.toFun
                      {
                        toFun := fun c =>
                          Quot.liftOn c ↑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                        map_add' :=
                          (_ :
                            ∀ (x y : FreeLieAlgebra R X),
                              (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  (x + y) =
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    x +
                                  (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    y) }
                      (t • x) =
                    ↑(RingHom.id R) t •
                      AddHom.toFun
                        {
                          toFun := fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                          map_add' :=
                            (_ :
                              ∀ (x y : FreeLieAlgebra R X),
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    (x + y) =
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      x +
                                    (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      y) }
                        x) }.toAddHom
        (Quot.mk (Rel R X) b)⁆
[PROOFSTEP]
rw [← liftAux_map_mul]
[GOAL]
case mk.mk
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
b : lib R X
⊢ AddHom.toFun
      {
          toAddHom :=
            {
              toFun := fun c =>
                Quot.liftOn c ↑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
              map_add' :=
                (_ :
                  ∀ (x y : FreeLieAlgebra R X),
                    (fun c =>
                          Quot.liftOn c ↑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                        (x + y) =
                      (fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                          x +
                        (fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                          y) },
          map_smul' :=
            (_ :
              ∀ (t : R) (x : FreeLieAlgebra R X),
                AddHom.toFun
                    {
                      toFun := fun c =>
                        Quot.liftOn c ↑(liftAux R f)
                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                      map_add' :=
                        (_ :
                          ∀ (x y : FreeLieAlgebra R X),
                            (fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                (x + y) =
                              (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  x +
                                (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  y) }
                    (t • x) =
                  ↑(RingHom.id R) t •
                    AddHom.toFun
                      {
                        toFun := fun c =>
                          Quot.liftOn c ↑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                        map_add' :=
                          (_ :
                            ∀ (x y : FreeLieAlgebra R X),
                              (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  (x + y) =
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    x +
                                  (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    y) }
                      x) }.toAddHom
      ⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) b⁆ =
    ↑(liftAux R f) (a * b)
[PROOFSTEP]
rfl
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
⊢ (fun F => ↑F ∘ of R)
      ((fun f =>
          {
            toLinearMap :=
              {
                toAddHom :=
                  {
                    toFun := fun c =>
                      Quot.liftOn c ↑(liftAux R f)
                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                    map_add' :=
                      (_ :
                        ∀ (x y : FreeLieAlgebra R X),
                          (fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                              (x + y) =
                            (fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                x +
                              (fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                y) },
                map_smul' :=
                  (_ :
                    ∀ (t : R) (x : FreeLieAlgebra R X),
                      AddHom.toFun
                          {
                            toFun := fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                            map_add' :=
                              (_ :
                                ∀ (x y : FreeLieAlgebra R X),
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      (x + y) =
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        x +
                                      (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        y) }
                          (t • x) =
                        ↑(RingHom.id R) t •
                          AddHom.toFun
                            {
                              toFun := fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                              map_add' :=
                                (_ :
                                  ∀ (x y : FreeLieAlgebra R X),
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        (x + y) =
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          x +
                                        (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          y) }
                            x) },
            map_lie' :=
              (_ :
                ∀ {x y : FreeLieAlgebra R X},
                  AddHom.toFun
                      {
                          toAddHom :=
                            {
                              toFun := fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                              map_add' :=
                                (_ :
                                  ∀ (x y : FreeLieAlgebra R X),
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        (x + y) =
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          x +
                                        (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          y) },
                          map_smul' :=
                            (_ :
                              ∀ (t : R) (x : FreeLieAlgebra R X),
                                AddHom.toFun
                                    {
                                      toFun := fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                      map_add' :=
                                        (_ :
                                          ∀ (x y : FreeLieAlgebra R X),
                                            (fun c =>
                                                  Quot.liftOn c ↑(liftAux R f)
                                                    (_ :
                                                      ∀ (a b : lib R X),
                                                        Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                (x + y) =
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  x +
                                                (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  y) }
                                    (t • x) =
                                  ↑(RingHom.id R) t •
                                    AddHom.toFun
                                      {
                                        toFun := fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                        map_add' :=
                                          (_ :
                                            ∀ (x y : FreeLieAlgebra R X),
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  (x + y) =
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    x +
                                                  (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    y) }
                                      x) }.toAddHom
                      ⁅x, y⁆ =
                    ⁅AddHom.toFun
                        {
                            toAddHom :=
                              {
                                toFun := fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : FreeLieAlgebra R X),
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          (x + y) =
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            x +
                                          (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            y) },
                            map_smul' :=
                              (_ :
                                ∀ (t : R) (x : FreeLieAlgebra R X),
                                  AddHom.toFun
                                      {
                                        toFun := fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                        map_add' :=
                                          (_ :
                                            ∀ (x y : FreeLieAlgebra R X),
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  (x + y) =
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    x +
                                                  (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    y) }
                                      (t • x) =
                                    ↑(RingHom.id R) t •
                                      AddHom.toFun
                                        {
                                          toFun := fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                          map_add' :=
                                            (_ :
                                              ∀ (x y : FreeLieAlgebra R X),
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    (x + y) =
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      x +
                                                    (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      y) }
                                        x) }.toAddHom
                        x,
                      AddHom.toFun
                        {
                            toAddHom :=
                              {
                                toFun := fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : FreeLieAlgebra R X),
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          (x + y) =
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            x +
                                          (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            y) },
                            map_smul' :=
                              (_ :
                                ∀ (t : R) (x : FreeLieAlgebra R X),
                                  AddHom.toFun
                                      {
                                        toFun := fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                        map_add' :=
                                          (_ :
                                            ∀ (x y : FreeLieAlgebra R X),
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  (x + y) =
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    x +
                                                  (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    y) }
                                      (t • x) =
                                    ↑(RingHom.id R) t •
                                      AddHom.toFun
                                        {
                                          toFun := fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                          map_add' :=
                                            (_ :
                                              ∀ (x y : FreeLieAlgebra R X),
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    (x + y) =
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      x +
                                                    (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      y) }
                                        x) }.toAddHom
                        y⁆) })
        f) =
    f
[PROOFSTEP]
ext x
[GOAL]
case h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
x : X
⊢ (fun F => ↑F ∘ of R)
      ((fun f =>
          {
            toLinearMap :=
              {
                toAddHom :=
                  {
                    toFun := fun c =>
                      Quot.liftOn c ↑(liftAux R f)
                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                    map_add' :=
                      (_ :
                        ∀ (x y : FreeLieAlgebra R X),
                          (fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                              (x + y) =
                            (fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                x +
                              (fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                y) },
                map_smul' :=
                  (_ :
                    ∀ (t : R) (x : FreeLieAlgebra R X),
                      AddHom.toFun
                          {
                            toFun := fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                            map_add' :=
                              (_ :
                                ∀ (x y : FreeLieAlgebra R X),
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      (x + y) =
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        x +
                                      (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        y) }
                          (t • x) =
                        ↑(RingHom.id R) t •
                          AddHom.toFun
                            {
                              toFun := fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                              map_add' :=
                                (_ :
                                  ∀ (x y : FreeLieAlgebra R X),
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        (x + y) =
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          x +
                                        (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          y) }
                            x) },
            map_lie' :=
              (_ :
                ∀ {x y : FreeLieAlgebra R X},
                  AddHom.toFun
                      {
                          toAddHom :=
                            {
                              toFun := fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                              map_add' :=
                                (_ :
                                  ∀ (x y : FreeLieAlgebra R X),
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        (x + y) =
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          x +
                                        (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          y) },
                          map_smul' :=
                            (_ :
                              ∀ (t : R) (x : FreeLieAlgebra R X),
                                AddHom.toFun
                                    {
                                      toFun := fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                      map_add' :=
                                        (_ :
                                          ∀ (x y : FreeLieAlgebra R X),
                                            (fun c =>
                                                  Quot.liftOn c ↑(liftAux R f)
                                                    (_ :
                                                      ∀ (a b : lib R X),
                                                        Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                (x + y) =
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  x +
                                                (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  y) }
                                    (t • x) =
                                  ↑(RingHom.id R) t •
                                    AddHom.toFun
                                      {
                                        toFun := fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                        map_add' :=
                                          (_ :
                                            ∀ (x y : FreeLieAlgebra R X),
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  (x + y) =
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    x +
                                                  (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    y) }
                                      x) }.toAddHom
                      ⁅x, y⁆ =
                    ⁅AddHom.toFun
                        {
                            toAddHom :=
                              {
                                toFun := fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : FreeLieAlgebra R X),
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          (x + y) =
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            x +
                                          (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            y) },
                            map_smul' :=
                              (_ :
                                ∀ (t : R) (x : FreeLieAlgebra R X),
                                  AddHom.toFun
                                      {
                                        toFun := fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                        map_add' :=
                                          (_ :
                                            ∀ (x y : FreeLieAlgebra R X),
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  (x + y) =
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    x +
                                                  (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    y) }
                                      (t • x) =
                                    ↑(RingHom.id R) t •
                                      AddHom.toFun
                                        {
                                          toFun := fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                          map_add' :=
                                            (_ :
                                              ∀ (x y : FreeLieAlgebra R X),
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    (x + y) =
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      x +
                                                    (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      y) }
                                        x) }.toAddHom
                        x,
                      AddHom.toFun
                        {
                            toAddHom :=
                              {
                                toFun := fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : FreeLieAlgebra R X),
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          (x + y) =
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            x +
                                          (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            y) },
                            map_smul' :=
                              (_ :
                                ∀ (t : R) (x : FreeLieAlgebra R X),
                                  AddHom.toFun
                                      {
                                        toFun := fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                        map_add' :=
                                          (_ :
                                            ∀ (x y : FreeLieAlgebra R X),
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  (x + y) =
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    x +
                                                  (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    y) }
                                      (t • x) =
                                    ↑(RingHom.id R) t •
                                      AddHom.toFun
                                        {
                                          toFun := fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                          map_add' :=
                                            (_ :
                                              ∀ (x y : FreeLieAlgebra R X),
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    (x + y) =
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      x +
                                                    (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      y) }
                                        x) }.toAddHom
                        y⁆) })
        f)
      x =
    f x
[PROOFSTEP]
simp only [liftAux, of, Quot.liftOn_mk, LieHom.coe_mk, Function.comp_apply, lib.lift_of_apply]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F : FreeLieAlgebra R X →ₗ⁅R⁆ L
⊢ (fun f =>
        {
          toLinearMap :=
            {
              toAddHom :=
                {
                  toFun := fun c =>
                    Quot.liftOn c ↑(liftAux R f)
                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                  map_add' :=
                    (_ :
                      ∀ (x y : FreeLieAlgebra R X),
                        (fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                            (x + y) =
                          (fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                              x +
                            (fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                              y) },
              map_smul' :=
                (_ :
                  ∀ (t : R) (x : FreeLieAlgebra R X),
                    AddHom.toFun
                        {
                          toFun := fun c =>
                            Quot.liftOn c ↑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                          map_add' :=
                            (_ :
                              ∀ (x y : FreeLieAlgebra R X),
                                (fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                    (x + y) =
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      x +
                                    (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      y) }
                        (t • x) =
                      ↑(RingHom.id R) t •
                        AddHom.toFun
                          {
                            toFun := fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                            map_add' :=
                              (_ :
                                ∀ (x y : FreeLieAlgebra R X),
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      (x + y) =
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        x +
                                      (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        y) }
                          x) },
          map_lie' :=
            (_ :
              ∀ {x y : FreeLieAlgebra R X},
                AddHom.toFun
                    {
                        toAddHom :=
                          {
                            toFun := fun c =>
                              Quot.liftOn c ↑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                            map_add' :=
                              (_ :
                                ∀ (x y : FreeLieAlgebra R X),
                                  (fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                      (x + y) =
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        x +
                                      (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        y) },
                        map_smul' :=
                          (_ :
                            ∀ (t : R) (x : FreeLieAlgebra R X),
                              AddHom.toFun
                                  {
                                    toFun := fun c =>
                                      Quot.liftOn c ↑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                    map_add' :=
                                      (_ :
                                        ∀ (x y : FreeLieAlgebra R X),
                                          (fun c =>
                                                Quot.liftOn c ↑(liftAux R f)
                                                  (_ :
                                                    ∀ (a b : lib R X),
                                                      Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                              (x + y) =
                                            (fun c =>
                                                  Quot.liftOn c ↑(liftAux R f)
                                                    (_ :
                                                      ∀ (a b : lib R X),
                                                        Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                x +
                                              (fun c =>
                                                  Quot.liftOn c ↑(liftAux R f)
                                                    (_ :
                                                      ∀ (a b : lib R X),
                                                        Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                y) }
                                  (t • x) =
                                ↑(RingHom.id R) t •
                                  AddHom.toFun
                                    {
                                      toFun := fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                      map_add' :=
                                        (_ :
                                          ∀ (x y : FreeLieAlgebra R X),
                                            (fun c =>
                                                  Quot.liftOn c ↑(liftAux R f)
                                                    (_ :
                                                      ∀ (a b : lib R X),
                                                        Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                (x + y) =
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  x +
                                                (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  y) }
                                    x) }.toAddHom
                    ⁅x, y⁆ =
                  ⁅AddHom.toFun
                      {
                          toAddHom :=
                            {
                              toFun := fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                              map_add' :=
                                (_ :
                                  ∀ (x y : FreeLieAlgebra R X),
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        (x + y) =
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          x +
                                        (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          y) },
                          map_smul' :=
                            (_ :
                              ∀ (t : R) (x : FreeLieAlgebra R X),
                                AddHom.toFun
                                    {
                                      toFun := fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                      map_add' :=
                                        (_ :
                                          ∀ (x y : FreeLieAlgebra R X),
                                            (fun c =>
                                                  Quot.liftOn c ↑(liftAux R f)
                                                    (_ :
                                                      ∀ (a b : lib R X),
                                                        Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                (x + y) =
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  x +
                                                (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  y) }
                                    (t • x) =
                                  ↑(RingHom.id R) t •
                                    AddHom.toFun
                                      {
                                        toFun := fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                        map_add' :=
                                          (_ :
                                            ∀ (x y : FreeLieAlgebra R X),
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  (x + y) =
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    x +
                                                  (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    y) }
                                      x) }.toAddHom
                      x,
                    AddHom.toFun
                      {
                          toAddHom :=
                            {
                              toFun := fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                              map_add' :=
                                (_ :
                                  ∀ (x y : FreeLieAlgebra R X),
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        (x + y) =
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          x +
                                        (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          y) },
                          map_smul' :=
                            (_ :
                              ∀ (t : R) (x : FreeLieAlgebra R X),
                                AddHom.toFun
                                    {
                                      toFun := fun c =>
                                        Quot.liftOn c ↑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                      map_add' :=
                                        (_ :
                                          ∀ (x y : FreeLieAlgebra R X),
                                            (fun c =>
                                                  Quot.liftOn c ↑(liftAux R f)
                                                    (_ :
                                                      ∀ (a b : lib R X),
                                                        Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                (x + y) =
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  x +
                                                (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  y) }
                                    (t • x) =
                                  ↑(RingHom.id R) t •
                                    AddHom.toFun
                                      {
                                        toFun := fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                        map_add' :=
                                          (_ :
                                            ∀ (x y : FreeLieAlgebra R X),
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  (x + y) =
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    x +
                                                  (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    y) }
                                      x) }.toAddHom
                      y⁆) })
      ((fun F => ↑F ∘ of R) F) =
    F
[PROOFSTEP]
ext ⟨a⟩
[GOAL]
case h.mk
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F : FreeLieAlgebra R X →ₗ⁅R⁆ L
x✝ : FreeLieAlgebra R X
a : lib R X
⊢ ↑((fun f =>
            {
              toLinearMap :=
                {
                  toAddHom :=
                    {
                      toFun := fun c =>
                        Quot.liftOn c ↑(liftAux R f)
                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                      map_add' :=
                        (_ :
                          ∀ (x y : FreeLieAlgebra R X),
                            (fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                (x + y) =
                              (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  x +
                                (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  y) },
                  map_smul' :=
                    (_ :
                      ∀ (t : R) (x : FreeLieAlgebra R X),
                        AddHom.toFun
                            {
                              toFun := fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                              map_add' :=
                                (_ :
                                  ∀ (x y : FreeLieAlgebra R X),
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        (x + y) =
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          x +
                                        (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          y) }
                            (t • x) =
                          ↑(RingHom.id R) t •
                            AddHom.toFun
                              {
                                toFun := fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : FreeLieAlgebra R X),
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          (x + y) =
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            x +
                                          (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            y) }
                              x) },
              map_lie' :=
                (_ :
                  ∀ {x y : FreeLieAlgebra R X},
                    AddHom.toFun
                        {
                            toAddHom :=
                              {
                                toFun := fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : FreeLieAlgebra R X),
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          (x + y) =
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            x +
                                          (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            y) },
                            map_smul' :=
                              (_ :
                                ∀ (t : R) (x : FreeLieAlgebra R X),
                                  AddHom.toFun
                                      {
                                        toFun := fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                        map_add' :=
                                          (_ :
                                            ∀ (x y : FreeLieAlgebra R X),
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  (x + y) =
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    x +
                                                  (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    y) }
                                      (t • x) =
                                    ↑(RingHom.id R) t •
                                      AddHom.toFun
                                        {
                                          toFun := fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                          map_add' :=
                                            (_ :
                                              ∀ (x y : FreeLieAlgebra R X),
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    (x + y) =
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      x +
                                                    (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      y) }
                                        x) }.toAddHom
                        ⁅x, y⁆ =
                      ⁅AddHom.toFun
                          {
                              toAddHom :=
                                {
                                  toFun := fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                  map_add' :=
                                    (_ :
                                      ∀ (x y : FreeLieAlgebra R X),
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            (x + y) =
                                          (fun c =>
                                                Quot.liftOn c ↑(liftAux R f)
                                                  (_ :
                                                    ∀ (a b : lib R X),
                                                      Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                              x +
                                            (fun c =>
                                                Quot.liftOn c ↑(liftAux R f)
                                                  (_ :
                                                    ∀ (a b : lib R X),
                                                      Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                              y) },
                              map_smul' :=
                                (_ :
                                  ∀ (t : R) (x : FreeLieAlgebra R X),
                                    AddHom.toFun
                                        {
                                          toFun := fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                          map_add' :=
                                            (_ :
                                              ∀ (x y : FreeLieAlgebra R X),
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    (x + y) =
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      x +
                                                    (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      y) }
                                        (t • x) =
                                      ↑(RingHom.id R) t •
                                        AddHom.toFun
                                          {
                                            toFun := fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                            map_add' :=
                                              (_ :
                                                ∀ (x y : FreeLieAlgebra R X),
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      (x + y) =
                                                    (fun c =>
                                                          Quot.liftOn c ↑(liftAux R f)
                                                            (_ :
                                                              ∀ (a b : lib R X),
                                                                Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                        x +
                                                      (fun c =>
                                                          Quot.liftOn c ↑(liftAux R f)
                                                            (_ :
                                                              ∀ (a b : lib R X),
                                                                Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                        y) }
                                          x) }.toAddHom
                          x,
                        AddHom.toFun
                          {
                              toAddHom :=
                                {
                                  toFun := fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                  map_add' :=
                                    (_ :
                                      ∀ (x y : FreeLieAlgebra R X),
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            (x + y) =
                                          (fun c =>
                                                Quot.liftOn c ↑(liftAux R f)
                                                  (_ :
                                                    ∀ (a b : lib R X),
                                                      Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                              x +
                                            (fun c =>
                                                Quot.liftOn c ↑(liftAux R f)
                                                  (_ :
                                                    ∀ (a b : lib R X),
                                                      Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                              y) },
                              map_smul' :=
                                (_ :
                                  ∀ (t : R) (x : FreeLieAlgebra R X),
                                    AddHom.toFun
                                        {
                                          toFun := fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                          map_add' :=
                                            (_ :
                                              ∀ (x y : FreeLieAlgebra R X),
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    (x + y) =
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      x +
                                                    (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      y) }
                                        (t • x) =
                                      ↑(RingHom.id R) t •
                                        AddHom.toFun
                                          {
                                            toFun := fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                            map_add' :=
                                              (_ :
                                                ∀ (x y : FreeLieAlgebra R X),
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      (x + y) =
                                                    (fun c =>
                                                          Quot.liftOn c ↑(liftAux R f)
                                                            (_ :
                                                              ∀ (a b : lib R X),
                                                                Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                        x +
                                                      (fun c =>
                                                          Quot.liftOn c ↑(liftAux R f)
                                                            (_ :
                                                              ∀ (a b : lib R X),
                                                                Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                        y) }
                                          x) }.toAddHom
                          y⁆) })
          ((fun F => ↑F ∘ of R) F))
      (Quot.mk (Rel R X) a) =
    ↑F (Quot.mk (Rel R X) a)
[PROOFSTEP]
let F' := F.toNonUnitalAlgHom.comp (mk R)
[GOAL]
case h.mk
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F : FreeLieAlgebra R X →ₗ⁅R⁆ L
x✝ : FreeLieAlgebra R X
a : lib R X
F' : lib R X →ₙₐ[R] CommutatorRing L := NonUnitalAlgHom.comp (LieHom.toNonUnitalAlgHom F) (mk R)
⊢ ↑((fun f =>
            {
              toLinearMap :=
                {
                  toAddHom :=
                    {
                      toFun := fun c =>
                        Quot.liftOn c ↑(liftAux R f)
                          (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                      map_add' :=
                        (_ :
                          ∀ (x y : FreeLieAlgebra R X),
                            (fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                (x + y) =
                              (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  x +
                                (fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                  y) },
                  map_smul' :=
                    (_ :
                      ∀ (t : R) (x : FreeLieAlgebra R X),
                        AddHom.toFun
                            {
                              toFun := fun c =>
                                Quot.liftOn c ↑(liftAux R f)
                                  (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                              map_add' :=
                                (_ :
                                  ∀ (x y : FreeLieAlgebra R X),
                                    (fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                        (x + y) =
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          x +
                                        (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          y) }
                            (t • x) =
                          ↑(RingHom.id R) t •
                            AddHom.toFun
                              {
                                toFun := fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : FreeLieAlgebra R X),
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          (x + y) =
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            x +
                                          (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            y) }
                              x) },
              map_lie' :=
                (_ :
                  ∀ {x y : FreeLieAlgebra R X},
                    AddHom.toFun
                        {
                            toAddHom :=
                              {
                                toFun := fun c =>
                                  Quot.liftOn c ↑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                map_add' :=
                                  (_ :
                                    ∀ (x y : FreeLieAlgebra R X),
                                      (fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                          (x + y) =
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            x +
                                          (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            y) },
                            map_smul' :=
                              (_ :
                                ∀ (t : R) (x : FreeLieAlgebra R X),
                                  AddHom.toFun
                                      {
                                        toFun := fun c =>
                                          Quot.liftOn c ↑(liftAux R f)
                                            (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                        map_add' :=
                                          (_ :
                                            ∀ (x y : FreeLieAlgebra R X),
                                              (fun c =>
                                                    Quot.liftOn c ↑(liftAux R f)
                                                      (_ :
                                                        ∀ (a b : lib R X),
                                                          Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                  (x + y) =
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    x +
                                                  (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    y) }
                                      (t • x) =
                                    ↑(RingHom.id R) t •
                                      AddHom.toFun
                                        {
                                          toFun := fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                          map_add' :=
                                            (_ :
                                              ∀ (x y : FreeLieAlgebra R X),
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    (x + y) =
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      x +
                                                    (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      y) }
                                        x) }.toAddHom
                        ⁅x, y⁆ =
                      ⁅AddHom.toFun
                          {
                              toAddHom :=
                                {
                                  toFun := fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                  map_add' :=
                                    (_ :
                                      ∀ (x y : FreeLieAlgebra R X),
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            (x + y) =
                                          (fun c =>
                                                Quot.liftOn c ↑(liftAux R f)
                                                  (_ :
                                                    ∀ (a b : lib R X),
                                                      Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                              x +
                                            (fun c =>
                                                Quot.liftOn c ↑(liftAux R f)
                                                  (_ :
                                                    ∀ (a b : lib R X),
                                                      Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                              y) },
                              map_smul' :=
                                (_ :
                                  ∀ (t : R) (x : FreeLieAlgebra R X),
                                    AddHom.toFun
                                        {
                                          toFun := fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                          map_add' :=
                                            (_ :
                                              ∀ (x y : FreeLieAlgebra R X),
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    (x + y) =
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      x +
                                                    (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      y) }
                                        (t • x) =
                                      ↑(RingHom.id R) t •
                                        AddHom.toFun
                                          {
                                            toFun := fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                            map_add' :=
                                              (_ :
                                                ∀ (x y : FreeLieAlgebra R X),
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      (x + y) =
                                                    (fun c =>
                                                          Quot.liftOn c ↑(liftAux R f)
                                                            (_ :
                                                              ∀ (a b : lib R X),
                                                                Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                        x +
                                                      (fun c =>
                                                          Quot.liftOn c ↑(liftAux R f)
                                                            (_ :
                                                              ∀ (a b : lib R X),
                                                                Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                        y) }
                                          x) }.toAddHom
                          x,
                        AddHom.toFun
                          {
                              toAddHom :=
                                {
                                  toFun := fun c =>
                                    Quot.liftOn c ↑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                  map_add' :=
                                    (_ :
                                      ∀ (x y : FreeLieAlgebra R X),
                                        (fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                            (x + y) =
                                          (fun c =>
                                                Quot.liftOn c ↑(liftAux R f)
                                                  (_ :
                                                    ∀ (a b : lib R X),
                                                      Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                              x +
                                            (fun c =>
                                                Quot.liftOn c ↑(liftAux R f)
                                                  (_ :
                                                    ∀ (a b : lib R X),
                                                      Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                              y) },
                              map_smul' :=
                                (_ :
                                  ∀ (t : R) (x : FreeLieAlgebra R X),
                                    AddHom.toFun
                                        {
                                          toFun := fun c =>
                                            Quot.liftOn c ↑(liftAux R f)
                                              (_ :
                                                ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                          map_add' :=
                                            (_ :
                                              ∀ (x y : FreeLieAlgebra R X),
                                                (fun c =>
                                                      Quot.liftOn c ↑(liftAux R f)
                                                        (_ :
                                                          ∀ (a b : lib R X),
                                                            Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                    (x + y) =
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      x +
                                                    (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      y) }
                                        (t • x) =
                                      ↑(RingHom.id R) t •
                                        AddHom.toFun
                                          {
                                            toFun := fun c =>
                                              Quot.liftOn c ↑(liftAux R f)
                                                (_ :
                                                  ∀ (a b : lib R X), Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b),
                                            map_add' :=
                                              (_ :
                                                ∀ (x y : FreeLieAlgebra R X),
                                                  (fun c =>
                                                        Quot.liftOn c ↑(liftAux R f)
                                                          (_ :
                                                            ∀ (a b : lib R X),
                                                              Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                      (x + y) =
                                                    (fun c =>
                                                          Quot.liftOn c ↑(liftAux R f)
                                                            (_ :
                                                              ∀ (a b : lib R X),
                                                                Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                        x +
                                                      (fun c =>
                                                          Quot.liftOn c ↑(liftAux R f)
                                                            (_ :
                                                              ∀ (a b : lib R X),
                                                                Rel R X a b → ↑(liftAux R f) a = ↑(liftAux R f) b))
                                                        y) }
                                          x) }.toAddHom
                          y⁆) })
          ((fun F => ↑F ∘ of R) F))
      (Quot.mk (Rel R X) a) =
    ↑F (Quot.mk (Rel R X) a)
[PROOFSTEP]
exact NonUnitalAlgHom.congr_fun (lib.lift_comp_of R F') a
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
x : X
⊢ ↑(↑(lift R) f) (of R x) = f x
[PROOFSTEP]
rw [← @Function.comp_apply _ _ _ (lift R f) (of R) x, of_comp_lift]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F : FreeLieAlgebra R X →ₗ⁅R⁆ L
⊢ ↑(lift R) (↑F ∘ of R) = F
[PROOFSTEP]
rw [← lift_symm_apply]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F : FreeLieAlgebra R X →ₗ⁅R⁆ L
⊢ ↑(lift R) (↑(lift R).symm F) = F
[PROOFSTEP]
exact (lift R).apply_symm_apply F
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F₁ F₂ : FreeLieAlgebra R X →ₗ⁅R⁆ L
h : ∀ (x : X), ↑F₁ (of R x) = ↑F₂ (of R x)
⊢ ↑(lift R).symm F₁ = ↑(lift R).symm F₂
[PROOFSTEP]
ext
[GOAL]
case h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F₁ F₂ : FreeLieAlgebra R X →ₗ⁅R⁆ L
h : ∀ (x : X), ↑F₁ (of R x) = ↑F₂ (of R x)
x✝ : X
⊢ ↑(lift R).symm F₁ x✝ = ↑(lift R).symm F₂ x✝
[PROOFSTEP]
simp [h]
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
⊢ AlgHom.comp (↑(UniversalEnvelopingAlgebra.lift R) (↑(lift R) (FreeAlgebra.ι R)))
      (↑(FreeAlgebra.lift R) (↑(UniversalEnvelopingAlgebra.ι R) ∘ of R)) =
    AlgHom.id R (FreeAlgebra R X)
[PROOFSTEP]
ext
[GOAL]
case w.h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝ : X
⊢ (↑(AlgHom.comp (↑(UniversalEnvelopingAlgebra.lift R) (↑(lift R) (FreeAlgebra.ι R)))
            (↑(FreeAlgebra.lift R) (↑(UniversalEnvelopingAlgebra.ι R) ∘ of R))) ∘
        FreeAlgebra.ι R)
      x✝ =
    (↑(AlgHom.id R (FreeAlgebra R X)) ∘ FreeAlgebra.ι R) x✝
[PROOFSTEP]
simp
[GOAL]
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
⊢ AlgHom.comp (↑(FreeAlgebra.lift R) (↑(UniversalEnvelopingAlgebra.ι R) ∘ of R))
      (↑(UniversalEnvelopingAlgebra.lift R) (↑(lift R) (FreeAlgebra.ι R))) =
    AlgHom.id R (UniversalEnvelopingAlgebra R (FreeLieAlgebra R X))
[PROOFSTEP]
ext
[GOAL]
case h.h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝ : X
⊢ ↑(LieHom.comp
          (AlgHom.toLieHom
            (AlgHom.comp (↑(FreeAlgebra.lift R) (↑(UniversalEnvelopingAlgebra.ι R) ∘ of R))
              (↑(UniversalEnvelopingAlgebra.lift R) (↑(lift R) (FreeAlgebra.ι R)))))
          (UniversalEnvelopingAlgebra.ι R))
      (of R x✝) =
    ↑(LieHom.comp (AlgHom.toLieHom (AlgHom.id R (UniversalEnvelopingAlgebra R (FreeLieAlgebra R X))))
          (UniversalEnvelopingAlgebra.ι R))
      (of R x✝)
[PROOFSTEP]
simp