l3lab/ntp-mathlib huggingface dataset:
instance : AddCommGroupWithOne ℍ[R,c₁,c₂] where
  natCast n := ((n : R) : ℍ[R,c₁,c₂])
  natCast_zero := by simp
  natCast_succ := by 

Proof state:
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ ∀ (n : ℕ), NatCast.natCast (n + 1) = NatCast.natCast n + 1

Next tactic:
simp
instance : AddCommGroupWithOne ℍ[R,c₁,c₂] where
  natCast n := ((n : R) : ℍ[R,c₁,c₂])
  natCast_zero := by simp
  natCast_succ := by simp
  intCast n := ((n : R) : ℍ[R,c₁,c₂])
  intCast_ofNat _ := congr_arg coe (Int.cast_ofNat _)
  intCast_negSucc n := by
    

Proof state:
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
n : ℕ
⊢ IntCast.intCast (Int.negSucc n) = -↑(n + 1)

Next tactic:
change coe _ = -coe _
instance : AddCommGroupWithOne ℍ[R,c₁,c₂] where
  natCast n := ((n : R) : ℍ[R,c₁,c₂])
  natCast_zero := by simp
  natCast_succ := by simp
  intCast n := ((n : R) : ℍ[R,c₁,c₂])
  intCast_ofNat _ := congr_arg coe (Int.cast_ofNat _)
  intCast_negSucc n := by
    change coe _ = -coe _
    

Proof state:
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
n : ℕ
⊢ ↑↑(Int.negSucc n) = -↑↑(n + 1)

Next tactic:
rw [Int.cast_negSucc, coe_neg]
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by 

Proof state:
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ x✝² * (x✝¹ + x✝) = x✝² * x✝¹ + x✝² * x✝

Next tactic:
ext
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> 

Proof state:
case re
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝² * (x✝¹ + x✝)).re = (x✝² * x✝¹ + x✝² * x✝).re

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> 

Proof state:
case imI
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝² * (x✝¹ + x✝)).imI = (x✝² * x✝¹ + x✝² * x✝).imI

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> 

Proof state:
case imJ
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝² * (x✝¹ + x✝)).imJ = (x✝² * x✝¹ + x✝² * x✝).imJ

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> 

Proof state:
case imK
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝² * (x✝¹ + x✝)).imK = (x✝² * x✝¹ + x✝² * x✝).imK

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> 

Proof state:
case re
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ x✝².re * (x✝¹.re + x✝.re) + c₁ * x✝².imI * (x✝¹.imI + x✝.imI) + c₂ * x✝².imJ * (x✝¹.imJ + x✝.imJ) -
      c₁ * c₂ * x✝².imK * (x✝¹.imK + x✝.imK) =
    x✝².re * x✝¹.re + c₁ * x✝².imI * x✝¹.imI + c₂ * x✝².imJ * x✝¹.imJ - c₁ * c₂ * x✝².imK * x✝¹.imK +
      (x✝².re * x✝.re + c₁ * x✝².imI * x✝.imI + c₂ * x✝².imJ * x✝.imJ - c₁ * c₂ * x✝².imK * x✝.imK)

Next tactic:
ring
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> 

Proof state:
case imI
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ x✝².re * (x✝¹.imI + x✝.imI) + x✝².imI * (x✝¹.re + x✝.re) - c₂ * x✝².imJ * (x✝¹.imK + x✝.imK) +
      c₂ * x✝².imK * (x✝¹.imJ + x✝.imJ) =
    x✝².re * x✝¹.imI + x✝².imI * x✝¹.re - c₂ * x✝².imJ * x✝¹.imK + c₂ * x✝².imK * x✝¹.imJ +
      (x✝².re * x✝.imI + x✝².imI * x✝.re - c₂ * x✝².imJ * x✝.imK + c₂ * x✝².imK * x✝.imJ)

Next tactic:
ring
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> 

Proof state:
case imJ
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ x✝².re * (x✝¹.imJ + x✝.imJ) + c₁ * x✝².imI * (x✝¹.imK + x✝.imK) + x✝².imJ * (x✝¹.re + x✝.re) -
      c₁ * x✝².imK * (x✝¹.imI + x✝.imI) =
    x✝².re * x✝¹.imJ + c₁ * x✝².imI * x✝¹.imK + x✝².imJ * x✝¹.re - c₁ * x✝².imK * x✝¹.imI +
      (x✝².re * x✝.imJ + c₁ * x✝².imI * x✝.imK + x✝².imJ * x✝.re - c₁ * x✝².imK * x✝.imI)

Next tactic:
ring
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> 

Proof state:
case imK
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ x✝².re * (x✝¹.imK + x✝.imK) + x✝².imI * (x✝¹.imJ + x✝.imJ) - x✝².imJ * (x✝¹.imI + x✝.imI) +
      x✝².imK * (x✝¹.re + x✝.re) =
    x✝².re * x✝¹.imK + x✝².imI * x✝¹.imJ - x✝².imJ * x✝¹.imI + x✝².imK * x✝¹.re +
      (x✝².re * x✝.imK + x✝².imI * x✝.imJ - x✝².imJ * x✝.imI + x✝².imK * x✝.re)

Next tactic:
ring
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by 

Proof state:
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝² + x✝¹) * x✝ = x✝² * x✝ + x✝¹ * x✝

Next tactic:
ext
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> 

Proof state:
case re
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ ((x✝² + x✝¹) * x✝).re = (x✝² * x✝ + x✝¹ * x✝).re

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> 

Proof state:
case imI
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ ((x✝² + x✝¹) * x✝).imI = (x✝² * x✝ + x✝¹ * x✝).imI

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> 

Proof state:
case imJ
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ ((x✝² + x✝¹) * x✝).imJ = (x✝² * x✝ + x✝¹ * x✝).imJ

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> 

Proof state:
case imK
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ ((x✝² + x✝¹) * x✝).imK = (x✝² * x✝ + x✝¹ * x✝).imK

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> 

Proof state:
case re
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝².re + x✝¹.re) * x✝.re + c₁ * (x✝².imI + x✝¹.imI) * x✝.imI + c₂ * (x✝².imJ + x✝¹.imJ) * x✝.imJ -
      c₁ * c₂ * (x✝².imK + x✝¹.imK) * x✝.imK =
    x✝².re * x✝.re + c₁ * x✝².imI * x✝.imI + c₂ * x✝².imJ * x✝.imJ - c₁ * c₂ * x✝².imK * x✝.imK +
      (x✝¹.re * x✝.re + c₁ * x✝¹.imI * x✝.imI + c₂ * x✝¹.imJ * x✝.imJ - c₁ * c₂ * x✝¹.imK * x✝.imK)

Next tactic:
ring
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> 

Proof state:
case imI
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝².re + x✝¹.re) * x✝.imI + (x✝².imI + x✝¹.imI) * x✝.re - c₂ * (x✝².imJ + x✝¹.imJ) * x✝.imK +
      c₂ * (x✝².imK + x✝¹.imK) * x✝.imJ =
    x✝².re * x✝.imI + x✝².imI * x✝.re - c₂ * x✝².imJ * x✝.imK + c₂ * x✝².imK * x✝.imJ +
      (x✝¹.re * x✝.imI + x✝¹.imI * x✝.re - c₂ * x✝¹.imJ * x✝.imK + c₂ * x✝¹.imK * x✝.imJ)

Next tactic:
ring
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> 

Proof state:
case imJ
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝².re + x✝¹.re) * x✝.imJ + c₁ * (x✝².imI + x✝¹.imI) * x✝.imK + (x✝².imJ + x✝¹.imJ) * x✝.re -
      c₁ * (x✝².imK + x✝¹.imK) * x✝.imI =
    x✝².re * x✝.imJ + c₁ * x✝².imI * x✝.imK + x✝².imJ * x✝.re - c₁ * x✝².imK * x✝.imI +
      (x✝¹.re * x✝.imJ + c₁ * x✝¹.imI * x✝.imK + x✝¹.imJ * x✝.re - c₁ * x✝¹.imK * x✝.imI)

Next tactic:
ring
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> 

Proof state:
case imK
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝².re + x✝¹.re) * x✝.imK + (x✝².imI + x✝¹.imI) * x✝.imJ - (x✝².imJ + x✝¹.imJ) * x✝.imI +
      (x✝².imK + x✝¹.imK) * x✝.re =
    x✝².re * x✝.imK + x✝².imI * x✝.imJ - x✝².imJ * x✝.imI + x✝².imK * x✝.re +
      (x✝¹.re * x✝.imK + x✝¹.imI * x✝.imJ - x✝¹.imJ * x✝.imI + x✝¹.imK * x✝.re)

Next tactic:
ring
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by 

Proof state:
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝ : ℍ[R,c₁,c₂]
⊢ 0 * x✝ = 0

Next tactic:
ext
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> 

Proof state:
case re
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝ : ℍ[R,c₁,c₂]
⊢ (0 * x✝).re = 0.re

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> 

Proof state:
case imI
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝ : ℍ[R,c₁,c₂]
⊢ (0 * x✝).imI = 0.imI

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> 

Proof state:
case imJ
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝ : ℍ[R,c₁,c₂]
⊢ (0 * x✝).imJ = 0.imJ

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> 

Proof state:
case imK
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝ : ℍ[R,c₁,c₂]
⊢ (0 * x✝).imK = 0.imK

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by 

Proof state:
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝ : ℍ[R,c₁,c₂]
⊢ x✝ * 0 = 0

Next tactic:
ext
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> 

Proof state:
case re
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝ : ℍ[R,c₁,c₂]
⊢ (x✝ * 0).re = 0.re

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> 

Proof state:
case imI
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝ : ℍ[R,c₁,c₂]
⊢ (x✝ * 0).imI = 0.imI

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> 

Proof state:
case imJ
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝ : ℍ[R,c₁,c₂]
⊢ (x✝ * 0).imJ = 0.imJ

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> 

Proof state:
case imK
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝ : ℍ[R,c₁,c₂]
⊢ (x✝ * 0).imK = 0.imK

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> simp
  mul_assoc _ _ _ := by 

Proof state:
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ x✝² * x✝¹ * x✝ = x✝² * (x✝¹ * x✝)

Next tactic:
ext
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> simp
  mul_assoc _ _ _ := by ext <;> 

Proof state:
case re
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝² * x✝¹ * x✝).re = (x✝² * (x✝¹ * x✝)).re

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> simp
  mul_assoc _ _ _ := by ext <;> 

Proof state:
case imI
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝² * x✝¹ * x✝).imI = (x✝² * (x✝¹ * x✝)).imI

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> simp
  mul_assoc _ _ _ := by ext <;> 

Proof state:
case imJ
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝² * x✝¹ * x✝).imJ = (x✝² * (x✝¹ * x✝)).imJ

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> simp
  mul_assoc _ _ _ := by ext <;> 

Proof state:
case imK
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝² * x✝¹ * x✝).imK = (x✝² * (x✝¹ * x✝)).imK

Next tactic:
simp
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> simp
  mul_assoc _ _ _ := by ext <;> simp <;> 

Proof state:
case re
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝².re * x✝¹.re + c₁ * x✝².imI * x✝¹.imI + c₂ * x✝².imJ * x✝¹.imJ - c₁ * c₂ * x✝².imK * x✝¹.imK) * x✝.re +
          c₁ * (x✝².re * x✝¹.imI + x✝².imI * x✝¹.re - c₂ * x✝².imJ * x✝¹.imK + c₂ * x✝².imK * x✝¹.imJ) * x✝.imI +
        c₂ * (x✝².re * x✝¹.imJ + c₁ * x✝².imI * x✝¹.imK + x✝².imJ * x✝¹.re - c₁ * x✝².imK * x✝¹.imI) * x✝.imJ -
      c₁ * c₂ * (x✝².re * x✝¹.imK + x✝².imI * x✝¹.imJ - x✝².imJ * x✝¹.imI + x✝².imK * x✝¹.re) * x✝.imK =
    x✝².re * (x✝¹.re * x✝.re + c₁ * x✝¹.imI * x✝.imI + c₂ * x✝¹.imJ * x✝.imJ - c₁ * c₂ * x✝¹.imK * x✝.imK) +
          c₁ * x✝².imI * (x✝¹.re * x✝.imI + x✝¹.imI * x✝.re - c₂ * x✝¹.imJ * x✝.imK + c₂ * x✝¹.imK * x✝.imJ) +
        c₂ * x✝².imJ * (x✝¹.re * x✝.imJ + c₁ * x✝¹.imI * x✝.imK + x✝¹.imJ * x✝.re - c₁ * x✝¹.imK * x✝.imI) -
      c₁ * c₂ * x✝².imK * (x✝¹.re * x✝.imK + x✝¹.imI * x✝.imJ - x✝¹.imJ * x✝.imI + x✝¹.imK * x✝.re)

Next tactic:
ring
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> simp
  mul_assoc _ _ _ := by ext <;> simp <;> 

Proof state:
case imI
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝².re * x✝¹.re + c₁ * x✝².imI * x✝¹.imI + c₂ * x✝².imJ * x✝¹.imJ - c₁ * c₂ * x✝².imK * x✝¹.imK) * x✝.imI +
          (x✝².re * x✝¹.imI + x✝².imI * x✝¹.re - c₂ * x✝².imJ * x✝¹.imK + c₂ * x✝².imK * x✝¹.imJ) * x✝.re -
        c₂ * (x✝².re * x✝¹.imJ + c₁ * x✝².imI * x✝¹.imK + x✝².imJ * x✝¹.re - c₁ * x✝².imK * x✝¹.imI) * x✝.imK +
      c₂ * (x✝².re * x✝¹.imK + x✝².imI * x✝¹.imJ - x✝².imJ * x✝¹.imI + x✝².imK * x✝¹.re) * x✝.imJ =
    x✝².re * (x✝¹.re * x✝.imI + x✝¹.imI * x✝.re - c₂ * x✝¹.imJ * x✝.imK + c₂ * x✝¹.imK * x✝.imJ) +
          x✝².imI * (x✝¹.re * x✝.re + c₁ * x✝¹.imI * x✝.imI + c₂ * x✝¹.imJ * x✝.imJ - c₁ * c₂ * x✝¹.imK * x✝.imK) -
        c₂ * x✝².imJ * (x✝¹.re * x✝.imK + x✝¹.imI * x✝.imJ - x✝¹.imJ * x✝.imI + x✝¹.imK * x✝.re) +
      c₂ * x✝².imK * (x✝¹.re * x✝.imJ + c₁ * x✝¹.imI * x✝.imK + x✝¹.imJ * x✝.re - c₁ * x✝¹.imK * x✝.imI)

Next tactic:
ring
instance instRing : Ring ℍ[R,c₁,c₂] where
  __ := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
  left_distrib _ _ _ := by ext <;> simp <;> ring
  right_distrib _ _ _ := by ext <;> simp <;> ring
  zero_mul _ := by ext <;> simp
  mul_zero _ := by ext <;> simp
  mul_assoc _ _ _ := by ext <;> simp <;> 

Proof state:
case imJ
S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
src✝ : AddCommGroupWithOne ℍ[R,c₁,c₂] := inferInstanceAs (AddCommGroupWithOne ℍ[R,c₁,c₂])
x✝² x✝¹ x✝ : ℍ[R,c₁,c₂]
⊢ (x✝².re * x✝¹.re + c₁ * x✝².imI * x✝¹.imI + c₂ * x✝².imJ * x✝¹.imJ - c₁ * c₂ * x✝².imK * x✝¹.imK) * x✝.imJ +
          c₁ * (x✝².re * x✝¹.imI + x✝².imI * x✝¹.re - c₂ * x✝².imJ * x✝¹.imK + c₂ * x✝².imK * x✝¹.imJ) * x✝.imK +
        (x✝².re * x✝¹.imJ + c₁ * x✝².imI * x✝¹.imK + x✝².imJ * x✝¹.re - c₁ * x✝².imK * x✝¹.imI) * x✝.re -
      c₁ * (x✝².re * x✝¹.imK + x✝².imI * x✝¹.imJ - x✝².imJ * x✝¹.imI + x✝².imK * x✝¹.re) * x✝.imI =
    x✝².re * (x✝¹.re * x✝.imJ + c₁ * x✝¹.imI * x✝.imK + x✝¹.imJ * x✝.re - c₁ * x✝¹.imK * x✝.imI) +
          c₁ * x✝².imI * (x✝¹.re * x✝.imK + x✝¹.imI * x✝.imJ - x✝¹.imJ * x✝.imI + x✝¹.imK * x✝.re) +
        x✝².imJ * (x✝¹.re * x✝.re + c₁ * x✝¹.imI * x✝.imI + c₂ * x✝¹.imJ * x✝.imJ - c₁ * c₂ * x✝¹.imK * x✝.imK) -
      c₁ * x✝².imK * (x✝¹.re * x✝.imI + x✝¹.imI * x✝.re - c₂ * x✝¹.imJ * x✝.imK + c₂ * x✝¹.imK * x✝.imJ)

Next tactic:
ring