l3lab/ntp-mathlib huggingface dataset:
theorem HasDerivWithinAt.clm_apply (hc : HasDerivWithinAt c c' s x)
    (hu : HasDerivWithinAt u u' s x) :
    HasDerivWithinAt (fun y => (c y) (u y)) (c' (u x) + c x u') s x := by
  have := (hc.hasFDerivWithinAt.clm_apply hu.hasFDerivWithinAt).hasDerivWithinAt
  

Proof state:
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
c : 𝕜 → F →L[𝕜] G
c' : F →L[𝕜] G
d : 𝕜 → E →L[𝕜] F
d' : E →L[𝕜] F
u : 𝕜 → F
u' : F
hc : HasDerivWithinAt c c' s x
hu : HasDerivWithinAt u u' s x
this :
  HasDerivWithinAt (fun y => (c y) (u y))
    ((comp (c x) (smulRight 1 u') + (ContinuousLinearMap.flip (smulRight 1 c')) (u x)) 1) s x
⊢ HasDerivWithinAt (fun y => (c y) (u y)) (c' (u x) + (c x) u') s x

Next tactic:
rwa [add_apply, comp_apply, flip_apply, smulRight_apply, smulRight_apply, one_apply, one_smul,
    one_smul, add_comm] at this
theorem HasDerivAt.clm_apply (hc : HasDerivAt c c' x) (hu : HasDerivAt u u' x) :
    HasDerivAt (fun y => (c y) (u y)) (c' (u x) + c x u') x := by
  

Proof state:
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
c : 𝕜 → F →L[𝕜] G
c' : F →L[𝕜] G
d : 𝕜 → E →L[𝕜] F
d' : E →L[𝕜] F
u : 𝕜 → F
u' : F
hc : HasDerivAt c c' x
hu : HasDerivAt u u' x
⊢ HasDerivAt (fun y => (c y) (u y)) (c' (u x) + (c x) u') x

Next tactic:
have := (hc.hasFDerivAt.clm_apply hu.hasFDerivAt).hasDerivAt
theorem HasDerivAt.clm_apply (hc : HasDerivAt c c' x) (hu : HasDerivAt u u' x) :
    HasDerivAt (fun y => (c y) (u y)) (c' (u x) + c x u') x := by
  have := (hc.hasFDerivAt.clm_apply hu.hasFDerivAt).hasDerivAt
  

Proof state:
𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
E : Type w
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
c : 𝕜 → F →L[𝕜] G
c' : F →L[𝕜] G
d : 𝕜 → E →L[𝕜] F
d' : E →L[𝕜] F
u : 𝕜 → F
u' : F
hc : HasDerivAt c c' x
hu : HasDerivAt u u' x
this :
  HasDerivAt (fun y => (c y) (u y))
    ((comp (c x) (smulRight 1 u') + (ContinuousLinearMap.flip (smulRight 1 c')) (u x)) 1) x
⊢ HasDerivAt (fun y => (c y) (u y)) (c' (u x) + (c x) u') x

Next tactic:
rwa [add_apply, comp_apply, flip_apply, smulRight_apply, smulRight_apply, one_apply, one_smul,
    one_smul, add_comm] at this
theorem Rel.addLeft (a : lib R X) {b c : lib R X} (h : Rel R X b c) : Rel R X (a + b) (a + c) := by
  

Proof state:
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)

Next tactic:
rw [add_comm _ b, add_comm _ c]
theorem Rel.addLeft (a : lib R X) {b c : lib R X} (h : Rel R X b c) : Rel R X (a + b) (a + c) := by
  rw [add_comm _ b, add_comm _ c]; 

Proof state:
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)

Next tactic:
exact h.add_right _
theorem Rel.neg {a b : lib R X} (h : Rel R X a b) : Rel R X (-a) (-b) := by
  

Proof state:
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)

Next tactic:
simpa only [neg_one_smul] using h.smul (-1)
theorem Rel.subLeft (a : lib R X) {b c : lib R X} (h : Rel R X b c) : Rel R X (a - b) (a - c) := by
  

Proof state:
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)

Next tactic:
simpa only [sub_eq_add_neg] using h.neg.addLeft a
theorem Rel.subRight {a b : lib R X} (c : lib R X) (h : Rel R X a b) : Rel R X (a - c) (b - c) := by
  

Proof state:
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)

Next tactic:
simpa only [sub_eq_add_neg] using h.add_right (-c)
theorem Rel.smulOfTower {S : Type*} [Monoid S] [DistribMulAction S R] [IsScalarTower S R R] (t : S)
    (a b : lib R X) (h : Rel R X a b) : Rel R X (t • a) (t • b) := by
  

Proof state:
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)

Next tactic:
rw [← smul_one_smul R t a, ← smul_one_smul R t b]
theorem Rel.smulOfTower {S : Type*} [Monoid S] [DistribMulAction S R] [IsScalarTower S R R] (t : S)
    (a b : lib R X) (h : Rel R X a b) : Rel R X (t • a) (t • b) := by
  rw [← smul_one_smul R t a, ← smul_one_smul R t b]
  

Proof state:
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)

Next tactic:
exact h.smul _
instance : Inhabited (FreeLieAlgebra R X) := by 

Proof state:
R : Type u
X : Type v
inst✝ : CommRing R
⊢ Inhabited (FreeLieAlgebra R X)

Next tactic:
rw [FreeLieAlgebra]
instance : Inhabited (FreeLieAlgebra R X) := by rw [FreeLieAlgebra]; 

Proof state:
R : Type u
X : Type v
inst✝ : CommRing R
⊢ Inhabited (Quot (FreeLieAlgebra.Rel R X))

Next tactic:
infer_instance
/-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) where
  bracket := Quot.map₂ (· * ·) (fun _ _ _ => Rel.mul_left _) fun _ _ _ => Rel.mul_right _
  add_lie := by 

Proof state:
R : Type u
X : Type v
inst✝ : CommRing R
⊢ ∀ (x y z : FreeLieAlgebra R X), ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆

Next tactic:
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩
/-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) where
  bracket := Quot.map₂ (· * ·) (fun _ _ _ => Rel.mul_left _) fun _ _ _ => Rel.mul_right _
  add_lie := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; 

Proof state:
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⁆

Next tactic:
change Quot.mk _ _ = Quot.mk _ _
/-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) where
  bracket := Quot.map₂ (· * ·) (fun _ _ _ => Rel.mul_left _) fun _ _ _ => Rel.mul_right _
  add_lie := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; 

Proof state:
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))

Next tactic:
simp_rw [add_mul]
/-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) where
  bracket := Quot.map₂ (· * ·) (fun _ _ _ => Rel.mul_left _) fun _ _ _ => Rel.mul_right _
  add_lie := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [add_mul]
  lie_add := by 

Proof state:
R : Type u
X : Type v
inst✝ : CommRing R
⊢ ∀ (x y z : FreeLieAlgebra R X), ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆

Next tactic:
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩
/-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) where
  bracket := Quot.map₂ (· * ·) (fun _ _ _ => Rel.mul_left _) fun _ _ _ => Rel.mul_right _
  add_lie := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [add_mul]
  lie_add := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; 

Proof state:
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⁆

Next tactic:
change Quot.mk _ _ = Quot.mk _ _
/-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) where
  bracket := Quot.map₂ (· * ·) (fun _ _ _ => Rel.mul_left _) fun _ _ _ => Rel.mul_right _
  add_lie := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [add_mul]
  lie_add := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; 

Proof state:
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))

Next tactic:
simp_rw [mul_add]
/-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) where
  bracket := Quot.map₂ (· * ·) (fun _ _ _ => Rel.mul_left _) fun _ _ _ => Rel.mul_right _
  add_lie := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [add_mul]
  lie_add := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [mul_add]
  lie_self := by 

Proof state:
R : Type u
X : Type v
inst✝ : CommRing R
⊢ ∀ (x : FreeLieAlgebra R X), ⁅x, x⁆ = 0

Next tactic:
rintro ⟨a⟩
/-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) where
  bracket := Quot.map₂ (· * ·) (fun _ _ _ => Rel.mul_left _) fun _ _ _ => Rel.mul_right _
  add_lie := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [add_mul]
  lie_add := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [mul_add]
  lie_self := by rintro ⟨a⟩; 

Proof state:
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

Next tactic:
exact Quot.sound (Rel.lie_self a)
/-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) where
  bracket := Quot.map₂ (· * ·) (fun _ _ _ => Rel.mul_left _) fun _ _ _ => Rel.mul_right _
  add_lie := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [add_mul]
  lie_add := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [mul_add]
  lie_self := by rintro ⟨a⟩; exact Quot.sound (Rel.lie_self a)
  leibniz_lie := by 

Proof state:
R : Type u
X : Type v
inst✝ : CommRing R
⊢ ∀ (x y z : FreeLieAlgebra R X), ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆

Next tactic:
rintro ⟨a⟩ ⟨b⟩ ⟨c⟩
/-- Note that here we turn the `Mul` coming from the `NonUnitalNonAssocSemiring` structure
on `lib R X` into a `Bracket` on `FreeLieAlgebra`. -/
instance : LieRing (FreeLieAlgebra R X) where
  bracket := Quot.map₂ (· * ·) (fun _ _ _ => Rel.mul_left _) fun _ _ _ => Rel.mul_right _
  add_lie := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [add_mul]
  lie_add := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; change Quot.mk _ _ = Quot.mk _ _; simp_rw [mul_add]
  lie_self := by rintro ⟨a⟩; exact Quot.sound (Rel.lie_self a)
  leibniz_lie := by rintro ⟨a⟩ ⟨b⟩ ⟨c⟩; 

Proof state:
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⁆⁆

Next tactic:
exact Quot.sound (Rel.leibniz_lie a b c)
instance : LieAlgebra R (FreeLieAlgebra R X) where
  lie_smul := by
    

Proof state:
R : Type u
X : Type v
inst✝ : CommRing R
⊢ ∀ (t : R) (x y : FreeLieAlgebra R X), ⁅x, t • y⁆ = t • ⁅x, y⁆

Next tactic:
rintro t ⟨a⟩ ⟨c⟩
instance : LieAlgebra R (FreeLieAlgebra R X) where
  lie_smul := by
    rintro t ⟨a⟩ ⟨c⟩
    

Proof state:
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⁆

Next tactic:
change Quot.mk _ (a • t • c) = Quot.mk _ (t • a • c)
instance : LieAlgebra R (FreeLieAlgebra R X) where
  lie_smul := by
    rintro t ⟨a⟩ ⟨c⟩
    change Quot.mk _ (a • t • c) = Quot.mk _ (t • a • c)
    

Proof state:
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)

Next tactic:
rw [← smul_comm]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  

Proof state:
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

Next tactic:
induction h
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  

Proof state:
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✝)

Next tactic:
case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  

Proof state:
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

Next tactic:
case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  case lie_self a' => 

Proof state:
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

Next tactic:
simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
  

Proof state:
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✝)

Next tactic:
case leibniz_lie a' b' c' =>
    simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
  

Proof state:
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'))

Next tactic:
case leibniz_lie a' b' c' =>
    simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
  case leibniz_lie a' b' c' =>
    

Proof state:
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'))

Next tactic:
simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
  case leibniz_lie a' b' c' =>
    simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
  

Proof state:
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✝)

Next tactic:
case smul t a' b' _ h₂ => simp only [liftAux_map_smul, h₂]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
  case leibniz_lie a' b' c' =>
    simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
  

Proof state:
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')

Next tactic:
case smul t a' b' _ h₂ => simp only [liftAux_map_smul, h₂]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
  case leibniz_lie a' b' c' =>
    simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
  case smul t a' b' _ h₂ => 

Proof state:
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')

Next tactic:
simp only [liftAux_map_smul, h₂]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
  case leibniz_lie a' b' c' =>
    simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
  case smul t a' b' _ h₂ => simp only [liftAux_map_smul, h₂]
  

Proof state:
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✝)

Next tactic:
case add_right a' b' c' _ h₂ => simp only [liftAux_map_add, h₂]
theorem liftAux_spec (f : X → L) (a b : lib R X) (h : FreeLieAlgebra.Rel R X a b) :
    liftAux R f a = liftAux R f b := by
  induction h
  case lie_self a' => simp only [liftAux_map_mul, NonUnitalAlgHom.map_zero, lie_self]
  case leibniz_lie a' b' c' =>
    simp only [liftAux_map_mul, liftAux_map_add, sub_add_cancel, lie_lie]
  case smul t a' b' _ h₂ => simp only [liftAux_map_smul, h₂]
  

Proof state:
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')

Next tactic:
case add_right a' b' c' _ h₂ => simp only [liftAux_map_add, h₂]