l3lab/ntp-mathlib huggingface dataset:
private theorem bracket_lie_self (x : A ⊗[R] L) : ⁅x, x⁆ = 0 := by
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, eq_self_iff_true, LinearMap.zero_apply]
  · intro a l
    simp only [bracket'_tmul, TensorProduct.tmul_zero, eq_self_iff_true, lie_self]
  · intro z₁ z₂ h₁ h₂
    suffices bracket' R A L L z₁ z₂ + bracket' R A L L z₂ z₁ = 0 by
      rw [LinearMap.map_add, LinearMap.map_add, LinearMap.add_apply, LinearMap.add_apply, h₁, h₂,
        zero_add, add_zero, add_comm, this]
    refine' z₁.induction_on _ _ _
    · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
    · intro a₁ l₁; refine' z₂.induction_on _ _ _
      · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
      · intro a₂ l₂
        simp only [← lie_skew l₂ l₁, mul_comm a₁ a₂, TensorProduct.tmul_neg, bracket'_tmul,
          add_right_neg]
      · intro y₁ y₂ hy₁ hy₂
        simp only [hy₁, hy₂, add_add_add_comm, add_zero, LinearMap.add_apply, LinearMap.map_add]
    · 

Proof state:
case refine'_3.refine'_3
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x z₁ z₂ : A ⊗[R] L
h₁ : ((LieAlgebra.ExtendScalars.bracket' R A L L) z₁) z₁ = 0
h₂ : ((LieAlgebra.ExtendScalars.bracket' R A L L) z₂) z₂ = 0
⊢ ∀ (x y : A ⊗[R] L),
    ((LieAlgebra.ExtendScalars.bracket' R A L L) x) z₂ + ((LieAlgebra.ExtendScalars.bracket' R A L L) z₂) x = 0 →
      ((LieAlgebra.ExtendScalars.bracket' R A L L) y) z₂ + ((LieAlgebra.ExtendScalars.bracket' R A L L) z₂) y = 0 →
        ((LieAlgebra.ExtendScalars.bracket' R A L L) (x + y)) z₂ +
            ((LieAlgebra.ExtendScalars.bracket' R A L L) z₂) (x + y) =
          0

Next tactic:
intro y₁ y₂ hy₁ hy₂
private theorem bracket_lie_self (x : A ⊗[R] L) : ⁅x, x⁆ = 0 := by
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, eq_self_iff_true, LinearMap.zero_apply]
  · intro a l
    simp only [bracket'_tmul, TensorProduct.tmul_zero, eq_self_iff_true, lie_self]
  · intro z₁ z₂ h₁ h₂
    suffices bracket' R A L L z₁ z₂ + bracket' R A L L z₂ z₁ = 0 by
      rw [LinearMap.map_add, LinearMap.map_add, LinearMap.add_apply, LinearMap.add_apply, h₁, h₂,
        zero_add, add_zero, add_comm, this]
    refine' z₁.induction_on _ _ _
    · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
    · intro a₁ l₁; refine' z₂.induction_on _ _ _
      · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
      · intro a₂ l₂
        simp only [← lie_skew l₂ l₁, mul_comm a₁ a₂, TensorProduct.tmul_neg, bracket'_tmul,
          add_right_neg]
      · intro y₁ y₂ hy₁ hy₂
        simp only [hy₁, hy₂, add_add_add_comm, add_zero, LinearMap.add_apply, LinearMap.map_add]
    · intro y₁ y₂ hy₁ hy₂
      

Proof state:
case refine'_3.refine'_3
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x z₁ z₂ : A ⊗[R] L
h₁ : ((LieAlgebra.ExtendScalars.bracket' R A L L) z₁) z₁ = 0
h₂ : ((LieAlgebra.ExtendScalars.bracket' R A L L) z₂) z₂ = 0
y₁ y₂ : A ⊗[R] L
hy₁ : ((LieAlgebra.ExtendScalars.bracket' R A L L) y₁) z₂ + ((LieAlgebra.ExtendScalars.bracket' R A L L) z₂) y₁ = 0
hy₂ : ((LieAlgebra.ExtendScalars.bracket' R A L L) y₂) z₂ + ((LieAlgebra.ExtendScalars.bracket' R A L L) z₂) y₂ = 0
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L L) (y₁ + y₂)) z₂ +
      ((LieAlgebra.ExtendScalars.bracket' R A L L) z₂) (y₁ + y₂) =
    0

Next tactic:
simp only [add_add_add_comm, hy₁, hy₂, add_zero, LinearMap.add_apply, LinearMap.map_add]
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  

Proof state:
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
⊢ ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆

Next tactic:
simp only [bracket_def]
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  

Proof state:
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L M) x) (((LieAlgebra.ExtendScalars.bracket' R A L M) y) z) =
    ((LieAlgebra.ExtendScalars.bracket' R A L M) (((LieAlgebra.ExtendScalars.bracket' R A L L) x) y)) z +
      ((LieAlgebra.ExtendScalars.bracket' R A L M) y) (((LieAlgebra.ExtendScalars.bracket' R A L M) x) z)

Next tactic:
refine' x.induction_on _ _ _
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · 

Proof state:
case refine'_1
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L M) 0) (((LieAlgebra.ExtendScalars.bracket' R A L M) y) z) =
    ((LieAlgebra.ExtendScalars.bracket' R A L M) (((LieAlgebra.ExtendScalars.bracket' R A L L) 0) y)) z +
      ((LieAlgebra.ExtendScalars.bracket' R A L M) y) (((LieAlgebra.ExtendScalars.bracket' R A L M) 0) z)

Next tactic:
simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · 

Proof state:
case refine'_2
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
⊢ ∀ (x : A) (y_1 : L),
    ((LieAlgebra.ExtendScalars.bracket' R A L M) (x ⊗ₜ[R] y_1)) (((LieAlgebra.ExtendScalars.bracket' R A L M) y) z) =
      ((LieAlgebra.ExtendScalars.bracket' R A L M) (((LieAlgebra.ExtendScalars.bracket' R A L L) (x ⊗ₜ[R] y_1)) y)) z +
        ((LieAlgebra.ExtendScalars.bracket' R A L M) y) (((LieAlgebra.ExtendScalars.bracket' R A L M) (x ⊗ₜ[R] y_1)) z)

Next tactic:
intro a₁ l₁
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · intro a₁ l₁
    

Proof state:
case refine'_2
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
a₁ : A
l₁ : L
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) (((LieAlgebra.ExtendScalars.bracket' R A L M) y) z) =
    ((LieAlgebra.ExtendScalars.bracket' R A L M) (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) y)) z +
      ((LieAlgebra.ExtendScalars.bracket' R A L M) y) (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) z)

Next tactic:
refine' y.induction_on _ _ _
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · intro a₁ l₁
    refine' y.induction_on _ _ _
    · 

Proof state:
case refine'_2.refine'_1
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
a₁ : A
l₁ : L
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) (((LieAlgebra.ExtendScalars.bracket' R A L M) 0) z) =
    ((LieAlgebra.ExtendScalars.bracket' R A L M) (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) 0)) z +
      ((LieAlgebra.ExtendScalars.bracket' R A L M) 0) (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) z)

Next tactic:
simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · intro a₁ l₁
    refine' y.induction_on _ _ _
    · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
    · 

Proof state:
case refine'_2.refine'_2
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
a₁ : A
l₁ : L
⊢ ∀ (x : A) (y : L),
    ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
        (((LieAlgebra.ExtendScalars.bracket' R A L M) (x ⊗ₜ[R] y)) z) =
      ((LieAlgebra.ExtendScalars.bracket' R A L M)
            (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (x ⊗ₜ[R] y)))
          z +
        ((LieAlgebra.ExtendScalars.bracket' R A L M) (x ⊗ₜ[R] y))
          (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) z)

Next tactic:
intro a₂ l₂
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · intro a₁ l₁
    refine' y.induction_on _ _ _
    · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
    · intro a₂ l₂
      

Proof state:
case refine'_2.refine'_2
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
a₁ : A
l₁ : L
a₂ : A
l₂ : L
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
      (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂)) z) =
    ((LieAlgebra.ExtendScalars.bracket' R A L M)
          (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (a₂ ⊗ₜ[R] l₂)))
        z +
      ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂))
        (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) z)

Next tactic:
refine' z.induction_on _ _ _
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · intro a₁ l₁
    refine' y.induction_on _ _ _
    · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
    · intro a₂ l₂
      refine' z.induction_on _ _ _
      · 

Proof state:
case refine'_2.refine'_2.refine'_1
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
a₁ : A
l₁ : L
a₂ : A
l₂ : L
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
      (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂)) 0) =
    ((LieAlgebra.ExtendScalars.bracket' R A L M)
          (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (a₂ ⊗ₜ[R] l₂)))
        0 +
      ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂))
        (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) 0)

Next tactic:
rw [LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero,
          add_zero]
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · intro a₁ l₁
    refine' y.induction_on _ _ _
    · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
    · intro a₂ l₂
      refine' z.induction_on _ _ _
      · rw [LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero,
          add_zero]
      · 

Proof state:
case refine'_2.refine'_2.refine'_2
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
a₁ : A
l₁ : L
a₂ : A
l₂ : L
⊢ ∀ (x : A) (y : M),
    ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
        (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂)) (x ⊗ₜ[R] y)) =
      ((LieAlgebra.ExtendScalars.bracket' R A L M)
            (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (a₂ ⊗ₜ[R] l₂)))
          (x ⊗ₜ[R] y) +
        ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂))
          (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) (x ⊗ₜ[R] y))

Next tactic:
intro a₃ l₃
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · intro a₁ l₁
    refine' y.induction_on _ _ _
    · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
    · intro a₂ l₂
      refine' z.induction_on _ _ _
      · rw [LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero,
          add_zero]
      · intro a₃ l₃; 

Proof state:
case refine'_2.refine'_2.refine'_2
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
a₁ : A
l₁ : L
a₂ : A
l₂ : L
a₃ : A
l₃ : M
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
      (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂)) (a₃ ⊗ₜ[R] l₃)) =
    ((LieAlgebra.ExtendScalars.bracket' R A L M)
          (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (a₂ ⊗ₜ[R] l₂)))
        (a₃ ⊗ₜ[R] l₃) +
      ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂))
        (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) (a₃ ⊗ₜ[R] l₃))

Next tactic:
simp only [bracket'_tmul]
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · intro a₁ l₁
    refine' y.induction_on _ _ _
    · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
    · intro a₂ l₂
      refine' z.induction_on _ _ _
      · rw [LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero,
          add_zero]
      · intro a₃ l₃; simp only [bracket'_tmul]
        

Proof state:
case refine'_2.refine'_2.refine'_2
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
a₁ : A
l₁ : L
a₂ : A
l₂ : L
a₃ : A
l₃ : M
⊢ (a₁ * (a₂ * a₃)) ⊗ₜ[R] ⁅l₁, ⁅l₂, l₃⁆⁆ = (a₁ * a₂ * a₃) ⊗ₜ[R] ⁅⁅l₁, l₂⁆, l₃⁆ + (a₂ * (a₁ * a₃)) ⊗ₜ[R] ⁅l₂, ⁅l₁, l₃⁆⁆

Next tactic:
rw [mul_left_comm a₂ a₁ a₃, mul_assoc, leibniz_lie, TensorProduct.tmul_add]
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · intro a₁ l₁
    refine' y.induction_on _ _ _
    · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
    · intro a₂ l₂
      refine' z.induction_on _ _ _
      · rw [LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero,
          add_zero]
      · intro a₃ l₃; simp only [bracket'_tmul]
        rw [mul_left_comm a₂ a₁ a₃, mul_assoc, leibniz_lie, TensorProduct.tmul_add]
      · 

Proof state:
case refine'_2.refine'_2.refine'_3
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
a₁ : A
l₁ : L
a₂ : A
l₂ : L
⊢ ∀ (x y : A ⊗[R] M),
    ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
          (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂)) x) =
        ((LieAlgebra.ExtendScalars.bracket' R A L M)
              (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (a₂ ⊗ₜ[R] l₂)))
            x +
          ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂))
            (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) x) →
      ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
            (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂)) y) =
          ((LieAlgebra.ExtendScalars.bracket' R A L M)
                (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (a₂ ⊗ₜ[R] l₂)))
              y +
            ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂))
              (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) y) →
        ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
            (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂)) (x + y)) =
          ((LieAlgebra.ExtendScalars.bracket' R A L M)
                (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (a₂ ⊗ₜ[R] l₂)))
              (x + y) +
            ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂))
              (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) (x + y))

Next tactic:
intro u₁ u₂ h₁ h₂
private theorem bracket_leibniz_lie (x y : A ⊗[R] L) (z : A ⊗[R] M) :
    ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ := by
  -- Porting note: replaced some `simp`s by `rw`s to avoid raising heartbeats
  simp only [bracket_def]
  refine' x.induction_on _ _ _
  · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
  · intro a₁ l₁
    refine' y.induction_on _ _ _
    · simp only [LinearMap.map_zero, add_zero, LinearMap.zero_apply]
    · intro a₂ l₂
      refine' z.induction_on _ _ _
      · rw [LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero, LinearMap.map_zero,
          add_zero]
      · intro a₃ l₃; simp only [bracket'_tmul]
        rw [mul_left_comm a₂ a₁ a₃, mul_assoc, leibniz_lie, TensorProduct.tmul_add]
      · intro u₁ u₂ h₁ h₂
        

Proof state:
case refine'_2.refine'_2.refine'_3
R : Type u_1
A : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : A ⊗[R] L
z : A ⊗[R] M
a₁ : A
l₁ : L
a₂ : A
l₂ : L
u₁ u₂ : A ⊗[R] M
h₁ :
  ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
      (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂)) u₁) =
    ((LieAlgebra.ExtendScalars.bracket' R A L M)
          (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (a₂ ⊗ₜ[R] l₂)))
        u₁ +
      ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂))
        (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) u₁)
h₂ :
  ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
      (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂)) u₂) =
    ((LieAlgebra.ExtendScalars.bracket' R A L M)
          (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (a₂ ⊗ₜ[R] l₂)))
        u₂ +
      ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂))
        (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) u₂)
⊢ ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁))
      (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂)) (u₁ + u₂)) =
    ((LieAlgebra.ExtendScalars.bracket' R A L M)
          (((LieAlgebra.ExtendScalars.bracket' R A L L) (a₁ ⊗ₜ[R] l₁)) (a₂ ⊗ₜ[R] l₂)))
        (u₁ + u₂) +
      ((LieAlgebra.ExtendScalars.bracket' R A L M) (a₂ ⊗ₜ[R] l₂))
        (((LieAlgebra.ExtendScalars.bracket' R A L M) (a₁ ⊗ₜ[R] l₁)) (u₁ + u₂))

Next tactic:
rw [map_add, map_add, map_add, map_add, map_add, h₁, h₂, add_add_add_comm]