ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Quaternion.zero_imI
@[simp] theorem zero_imI : (0 : ℍ[R]).imI = 0 
Arguments: {R : Type u_3} [CommRing R]
Goal: Quaternion.imI 0 = 0
-- Quaternion.zero_imJ
@[simp] theorem zero_imJ : (0 : ℍ[R]).imJ = 0 
Arguments: {R : Type u_3} [CommRing R]
Goal: Quaternion.imJ 0 = 0
-- Quaternion.zero_imK
@[simp] theorem zero_imK : (0 : ℍ[R]).imK = 0 
Arguments: {R : Type u_3} [CommRing R]
Goal: Quaternion.imK 0 = 0
-- Quaternion.zero_im
@[simp] theorem zero_im : (0 : ℍ[R]).im = 0 
Arguments: {R : Type u_3} [CommRing R]
Goal: Quaternion.im 0 = 0
-- Quaternion.coe_zero
@[simp, norm_cast]
theorem coe_zero : ((0 : R) : ℍ[R]) = 0 
Arguments: {R : Type u_3} [CommRing R]
Goal: ↑0 = 0
-- Quaternion.one_re
@[simp] theorem one_re : (1 : ℍ[R]).re = 1 
Arguments: {R : Type u_3} [CommRing R]
Goal: Quaternion.re 1 = 1
-- Quaternion.one_imI
@[simp] theorem one_imI : (1 : ℍ[R]).imI = 0 
Arguments: {R : Type u_3} [CommRing R]
Goal: Quaternion.imI 1 = 0
-- Quaternion.one_imJ
@[simp] theorem one_imJ : (1 : ℍ[R]).imJ = 0 
Arguments: {R : Type u_3} [CommRing R]
Goal: Quaternion.imJ 1 = 0
-- Quaternion.one_imK
@[simp] theorem one_imK : (1 : ℍ[R]).imK = 0 
Arguments: {R : Type u_3} [CommRing R]
Goal: Quaternion.imK 1 = 0
-- Quaternion.one_im
@[simp] theorem one_im : (1 : ℍ[R]).im = 0 
Arguments: {R : Type u_3} [CommRing R]
Goal: Quaternion.im 1 = 0
-- Quaternion.coe_one
@[simp, norm_cast]
theorem coe_one : ((1 : R) : ℍ[R]) = 1 
Arguments: {R : Type u_3} [CommRing R]
Goal: ↑1 = 1
-- Quaternion.add_re
@[simp] theorem add_re : (a + b).re = a.re + b.re 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a + b).re = a.re + b.re
-- Quaternion.add_imI
@[simp] theorem add_imI : (a + b).imI = a.imI + b.imI 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a + b).imI = a.imI + b.imI
-- Quaternion.add_imJ
@[simp] theorem add_imJ : (a + b).imJ = a.imJ + b.imJ 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a + b).imJ = a.imJ + b.imJ
-- Quaternion.add_imK
@[simp] theorem add_imK : (a + b).imK = a.imK + b.imK 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a + b).imK = a.imK + b.imK
-- Quaternion.add_im
@[simp] nonrec theorem add_im : (a + b).im = a.im + b.im 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a + b).im = a.im + b.im
-- Quaternion.coe_add
@[simp, norm_cast]
theorem coe_add : ((x + y : R) : ℍ[R]) = x + y 
Arguments: {R : Type u_3} [CommRing R] (x y : R)
Goal: ↑(x + y) = ↑x + ↑y
-- Quaternion.neg_re
@[simp] theorem neg_re : (-a).re = -a.re 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: (-a).re = -a.re
-- Quaternion.neg_imI
@[simp] theorem neg_imI : (-a).imI = -a.imI 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: (-a).imI = -a.imI
-- Quaternion.neg_imJ
@[simp] theorem neg_imJ : (-a).imJ = -a.imJ 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: (-a).imJ = -a.imJ
-- Quaternion.neg_imK
@[simp] theorem neg_imK : (-a).imK = -a.imK 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: (-a).imK = -a.imK
-- Quaternion.neg_im
@[simp] nonrec theorem neg_im : (-a).im = -a.im 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: (-a).im = -a.im
-- Quaternion.coe_neg
@[simp, norm_cast]
theorem coe_neg : ((-x : R) : ℍ[R]) = -x 
Arguments: {R : Type u_3} [CommRing R] (x : R)
Goal: ↑(-x) = -↑x
-- Quaternion.sub_re
@[simp] theorem sub_re : (a - b).re = a.re - b.re 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a - b).re = a.re - b.re
-- Quaternion.sub_imI
@[simp] theorem sub_imI : (a - b).imI = a.imI - b.imI 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a - b).imI = a.imI - b.imI
-- Quaternion.sub_imJ
@[simp] theorem sub_imJ : (a - b).imJ = a.imJ - b.imJ 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a - b).imJ = a.imJ - b.imJ
-- Quaternion.sub_imK
@[simp] theorem sub_imK : (a - b).imK = a.imK - b.imK 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a - b).imK = a.imK - b.imK
-- Quaternion.sub_im
@[simp] nonrec theorem sub_im : (a - b).im = a.im - b.im 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a - b).im = a.im - b.im
-- Quaternion.coe_sub
@[simp, norm_cast]
theorem coe_sub : ((x - y : R) : ℍ[R]) = x - y 
Arguments: {R : Type u_3} [CommRing R] (x y : R)
Goal: ↑(x - y) = ↑x - ↑y
-- Quaternion.mul_re
@[simp]
theorem mul_re : (a * b).re = a.re * b.re - a.imI * b.imI - a.imJ * b.imJ - a.imK * b.imK 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a * b).re = a.re * b.re - a.imI * b.imI - a.imJ * b.imJ - a.imK * b.imK
-- Quaternion.mul_imI
@[simp]
theorem mul_imI : (a * b).imI = a.re * b.imI + a.imI * b.re + a.imJ * b.imK - a.imK * b.imJ 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a * b).imI = a.re * b.imI + a.imI * b.re + a.imJ * b.imK - a.imK * b.imJ
-- Quaternion.mul_imJ
@[simp]
theorem mul_imJ : (a * b).imJ = a.re * b.imJ - a.imI * b.imK + a.imJ * b.re + a.imK * b.imI 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a * b).imJ = a.re * b.imJ - a.imI * b.imK + a.imJ * b.re + a.imK * b.imI
-- Quaternion.mul_imK
@[simp]
theorem mul_imK : (a * b).imK = a.re * b.imK + a.imI * b.imJ - a.imJ * b.imI + a.imK * b.re 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: (a * b).imK = a.re * b.imK + a.imI * b.imJ - a.imJ * b.imI + a.imK * b.re
-- Quaternion.coe_mul
@[simp, norm_cast]
theorem coe_mul : ((x * y : R) : ℍ[R]) = x * y 
Arguments: {R : Type u_3} [CommRing R] (x y : R)
Goal: ↑(x * y) = ↑x * ↑y
-- Quaternion.coe_pow
@[norm_cast, simp]
theorem coe_pow (n : ℕ) : (↑(x ^ n) : ℍ[R]) = (x : ℍ[R]) ^ n 
Arguments: {R : Type u_3} [CommRing R] (x : R) (n : ℕ)
Goal: ↑(x ^ n) = ↑x ^ n
-- Quaternion.natCast_re
@[simp, norm_cast]
theorem natCast_re (n : ℕ) : (n : ℍ[R]).re = n 
Arguments: {R : Type u_3} [CommRing R] (n : ℕ)
Goal: (↑n).re = ↑n
-- Quaternion.natCast_imI
@[simp, norm_cast]
theorem natCast_imI (n : ℕ) : (n : ℍ[R]).imI = 0 
Arguments: {R : Type u_3} [CommRing R] (n : ℕ)
Goal: (↑n).imI = 0
-- Quaternion.natCast_imJ
@[simp, norm_cast]
theorem natCast_imJ (n : ℕ) : (n : ℍ[R]).imJ = 0 
Arguments: {R : Type u_3} [CommRing R] (n : ℕ)
Goal: (↑n).imJ = 0
-- Quaternion.natCast_imK
@[simp, norm_cast]
theorem natCast_imK (n : ℕ) : (n : ℍ[R]).imK = 0 
Arguments: {R : Type u_3} [CommRing R] (n : ℕ)
Goal: (↑n).imK = 0
-- Quaternion.natCast_im
@[simp, norm_cast]
theorem natCast_im (n : ℕ) : (n : ℍ[R]).im = 0 
Arguments: {R : Type u_3} [CommRing R] (n : ℕ)
Goal: (↑n).im = 0
-- Quaternion.coe_natCast
@[norm_cast]
theorem coe_natCast (n : ℕ) : ↑(n : R) = (n : ℍ[R]) 
Arguments: {R : Type u_3} [CommRing R] (n : ℕ)
Goal: ↑↑n = ↑n
-- Quaternion.intCast_re
@[simp, norm_cast]
theorem intCast_re (z : ℤ) : (z : ℍ[R]).re = z 
Arguments: {R : Type u_3} [CommRing R] (z : ℤ)
Goal: (↑z).re = ↑z
-- Quaternion.intCast_imI
@[simp, norm_cast]
theorem intCast_imI (z : ℤ) : (z : ℍ[R]).imI = 0 
Arguments: {R : Type u_3} [CommRing R] (z : ℤ)
Goal: (↑z).imI = 0
-- Quaternion.intCast_imJ
@[simp, norm_cast]
theorem intCast_imJ (z : ℤ) : (z : ℍ[R]).imJ = 0 
Arguments: {R : Type u_3} [CommRing R] (z : ℤ)
Goal: (↑z).imJ = 0
-- Quaternion.intCast_imK
@[simp, norm_cast]
theorem intCast_imK (z : ℤ) : (z : ℍ[R]).imK = 0 
Arguments: {R : Type u_3} [CommRing R] (z : ℤ)
Goal: (↑z).imK = 0
-- Quaternion.intCast_im
@[simp, norm_cast]
theorem intCast_im (z : ℤ) : (z : ℍ[R]).im = 0 
Arguments: {R : Type u_3} [CommRing R] (z : ℤ)
Goal: (↑z).im = 0
-- Quaternion.coe_intCast
@[norm_cast]
theorem coe_intCast (z : ℤ) : ↑(z : R) = (z : ℍ[R]) 
Arguments: {R : Type u_3} [CommRing R] (z : ℤ)
Goal: ↑↑z = ↑z
-- Quaternion.coe_injective
theorem coe_injective : Function.Injective (coe : R → ℍ[R]) 
Arguments: {R : Type u_3} [CommRing R]
Goal: Function.Injective Quaternion.coe
-- Quaternion.coe_inj
@[simp]
theorem coe_inj {x y : R} : (x : ℍ[R]) = y ↔ x = y 
Arguments: {R : Type u_3} [CommRing R] {x y : R}
Goal: ↑x = ↑y ↔ x = y
-- Quaternion.smul_re
@[simp]
theorem smul_re [SMul S R] (s : S) : (s • a).re = s • a.re 
Arguments: {S : Type u_1} {R : Type u_3} [CommRing R] (a : ℍ[R]) [SMul S R] (s : S)
Goal: (s • a).re = s • a.re
-- Quaternion.smul_imI
@[simp] theorem smul_imI [SMul S R] (s : S) : (s • a).imI = s • a.imI 
Arguments: {S : Type u_1} {R : Type u_3} [CommRing R] (a : ℍ[R]) [SMul S R] (s : S)
Goal: (s • a).imI = s • a.imI
-- Quaternion.smul_imJ
@[simp] theorem smul_imJ [SMul S R] (s : S) : (s • a).imJ = s • a.imJ 
Arguments: {S : Type u_1} {R : Type u_3} [CommRing R] (a : ℍ[R]) [SMul S R] (s : S)
Goal: (s • a).imJ = s • a.imJ
-- Quaternion.smul_imK
@[simp] theorem smul_imK [SMul S R] (s : S) : (s • a).imK = s • a.imK 
Arguments: {S : Type u_1} {R : Type u_3} [CommRing R] (a : ℍ[R]) [SMul S R] (s : S)
Goal: (s • a).imK = s • a.imK
-- Quaternion.smul_im
@[simp]
nonrec theorem smul_im [SMulZeroClass S R] (s : S) : (s • a).im = s • a.im 
Arguments: {S : Type u_1} {R : Type u_3} [CommRing R] (a : ℍ[R]) [SMulZeroClass S R] (s : S)
Goal: (s • a).im = s • a.im
-- Quaternion.coe_smul
@[simp, norm_cast]
theorem coe_smul [SMulZeroClass S R] (s : S) (r : R) : (↑(s • r) : ℍ[R]) = s • (r : ℍ[R]) 
Arguments: {S : Type u_1} {R : Type u_3} [CommRing R] [SMulZeroClass S R] (s : S) (r : R)
Goal: ↑(s • r) = s • ↑r
-- Quaternion.coe_commutes
theorem coe_commutes : ↑r * a = a * r 
Arguments: {R : Type u_3} [CommRing R] (r : R) (a : ℍ[R])
Goal: ↑r * a = a * ↑r
-- Quaternion.coe_commute
theorem coe_commute : Commute (↑r) a 
Arguments: {R : Type u_3} [CommRing R] (r : R) (a : ℍ[R])
Goal: Commute (↑r) a
-- Quaternion.coe_mul_eq_smul
theorem coe_mul_eq_smul : ↑r * a = r • a 
Arguments: {R : Type u_3} [CommRing R] (r : R) (a : ℍ[R])
Goal: ↑r * a = r • a
-- Quaternion.mul_coe_eq_smul
theorem mul_coe_eq_smul : a * r = r • a 
Arguments: {R : Type u_3} [CommRing R] (r : R) (a : ℍ[R])
Goal: a * ↑r = r • a
-- Quaternion.algebraMap_def
@[simp]
theorem algebraMap_def : ⇑(algebraMap R ℍ[R]) = coe 
Arguments: {R : Type u_3} [CommRing R]
Goal: ⇑(algebraMap R ℍ[R]) = Quaternion.coe
-- Quaternion.algebraMap_injective
theorem algebraMap_injective : (algebraMap R ℍ[R] : _ → _).Injective 
Arguments: {R : Type u_3} [CommRing R]
Goal: Function.Injective ⇑(algebraMap R ℍ[R])
-- Quaternion.smul_coe
theorem smul_coe : x • (y : ℍ[R]) = ↑(x * y) 
Arguments: {R : Type u_3} [CommRing R] (x y : R)
Goal: x • ↑y = ↑(x * y)
-- Quaternion.rank_eq_four
theorem rank_eq_four [StrongRankCondition R] : Module.rank R ℍ[R] = 4 
Arguments: {R : Type u_3} [CommRing R] [StrongRankCondition R]
Goal: Module.rank R ℍ[R] = 4
-- Quaternion.finrank_eq_four
theorem finrank_eq_four [StrongRankCondition R] : FiniteDimensional.finrank R ℍ[R] = 4 
Arguments: {R : Type u_3} [CommRing R] [StrongRankCondition R]
Goal: FiniteDimensional.finrank R ℍ[R] = 4
-- Quaternion.star_re
@[simp] theorem star_re : (star a).re = a.re 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: (star a).re = a.re
-- Quaternion.star_imI
@[simp] theorem star_imI : (star a).imI = -a.imI 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: (star a).imI = -a.imI
-- Quaternion.star_imJ
@[simp] theorem star_imJ : (star a).imJ = -a.imJ 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: (star a).imJ = -a.imJ
-- Quaternion.star_imK
@[simp] theorem star_imK : (star a).imK = -a.imK 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: (star a).imK = -a.imK
-- Quaternion.star_im
@[simp] theorem star_im : (star a).im = -a.im 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: (star a).im = -a.im
-- Quaternion.self_add_star'
nonrec theorem self_add_star' : a + star a = ↑(2 * a.re) 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a + star a = ↑(2 * a.re)
-- Quaternion.self_add_star
nonrec theorem self_add_star : a + star a = 2 * a.re 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a + star a = 2 * ↑a.re
-- Quaternion.star_add_self'
nonrec theorem star_add_self' : star a + a = ↑(2 * a.re) 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: star a + a = ↑(2 * a.re)
-- Quaternion.star_add_self
nonrec theorem star_add_self : star a + a = 2 * a.re 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: star a + a = 2 * ↑a.re
-- Quaternion.star_eq_two_re_sub
nonrec theorem star_eq_two_re_sub : star a = ↑(2 * a.re) - a 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: star a = ↑(2 * a.re) - a
-- Quaternion.star_coe
@[simp, norm_cast]
theorem star_coe : star (x : ℍ[R]) = x 
Arguments: {R : Type u_3} [CommRing R] (x : R)
Goal: star ↑x = ↑x
-- Quaternion.im_star
@[simp]
theorem im_star : star a.im = -a.im 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: star a.im = -a.im
-- Quaternion.star_smul
@[simp]
theorem star_smul [Monoid S] [DistribMulAction S R] (s : S) (a : ℍ[R]) :
    star (s • a) = s • star a 
Arguments: {S : Type u_1} {R : Type u_3} [CommRing R] [Monoid S] [DistribMulAction S R] (s : S) (a : ℍ[R])
Goal: star (s • a) = s • star a
-- Quaternion.eq_re_of_eq_coe
theorem eq_re_of_eq_coe {a : ℍ[R]} {x : R} (h : a = x) : a = a.re 
Arguments: {R : Type u_3} [CommRing R] {a : ℍ[R]} {x : R} (h : a = ↑x)
Goal: a = ↑a.re
-- Quaternion.eq_re_iff_mem_range_coe
theorem eq_re_iff_mem_range_coe {a : ℍ[R]} : a = a.re ↔ a ∈ Set.range (coe : R → ℍ[R]) 
Arguments: {R : Type u_3} [CommRing R] {a : ℍ[R]}
Goal: a = ↑a.re ↔ a ∈ Set.range Quaternion.coe
-- Quaternion.star_eq_self
@[simp]
theorem star_eq_self {a : ℍ[R]} : star a = a ↔ a = a.re 
Arguments: {R : Type u_3} [CommRing R] [NoZeroDivisors R] [CharZero R] {a : ℍ[R]}
Goal: star a = a ↔ a = ↑a.re
-- Quaternion.star_eq_neg
@[simp]
theorem star_eq_neg {a : ℍ[R]} : star a = -a ↔ a.re = 0 
Arguments: {R : Type u_3} [CommRing R] [NoZeroDivisors R] [CharZero R] {a : ℍ[R]}
Goal: star a = -a ↔ a.re = 0
-- Quaternion.star_mul_eq_coe
nonrec theorem star_mul_eq_coe : star a * a = (star a * a).re 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: star a * a = ↑(star a * a).re
-- Quaternion.mul_star_eq_coe
nonrec theorem mul_star_eq_coe : a * star a = (a * star a).re 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a * star a = ↑(a * star a).re
-- Quaternion.coe_starAe
@[simp]
theorem coe_starAe : ⇑(starAe : ℍ[R] ≃ₐ[R] ℍ[R]ᵐᵒᵖ) = op ∘ star 
Arguments: {R : Type u_3} [CommRing R]
Goal: ⇑Quaternion.starAe = MulOpposite.op ∘ star
-- Quaternion.normSq_def
theorem normSq_def : normSq a = (a * star a).re 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: Quaternion.normSq a = (a * star a).re
-- Quaternion.normSq_def'
theorem normSq_def' : normSq a = a.1 ^ 2 + a.2 ^ 2 + a.3 ^ 2 + a.4 ^ 2 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: Quaternion.normSq a = a.re ^ 2 + a.imI ^ 2 + a.imJ ^ 2 + a.imK ^ 2
-- Quaternion.normSq_coe
theorem normSq_coe : normSq (x : ℍ[R]) = x ^ 2 
Arguments: {R : Type u_3} [CommRing R] (x : R)
Goal: Quaternion.normSq ↑x = x ^ 2
-- Quaternion.normSq_star
@[simp]
theorem normSq_star : normSq (star a) = normSq a 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: Quaternion.normSq (star a) = Quaternion.normSq a
-- Quaternion.normSq_natCast
@[norm_cast]
theorem normSq_natCast (n : ℕ) : normSq (n : ℍ[R]) = (n : R) ^ 2 
Arguments: {R : Type u_3} [CommRing R] (n : ℕ)
Goal: Quaternion.normSq ↑n = ↑n ^ 2
-- Quaternion.normSq_intCast
@[norm_cast]
theorem normSq_intCast (z : ℤ) : normSq (z : ℍ[R]) = (z : R) ^ 2 
Arguments: {R : Type u_3} [CommRing R] (z : ℤ)
Goal: Quaternion.normSq ↑z = ↑z ^ 2
-- Quaternion.normSq_neg
@[simp]
theorem normSq_neg : normSq (-a) = normSq a 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: Quaternion.normSq (-a) = Quaternion.normSq a
-- Quaternion.self_mul_star
theorem self_mul_star : a * star a = normSq a 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a * star a = ↑(Quaternion.normSq a)
-- Quaternion.star_mul_self
theorem star_mul_self : star a * a = normSq a 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: star a * a = ↑(Quaternion.normSq a)
-- Quaternion.im_sq
theorem im_sq : a.im ^ 2 = -normSq a.im 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a.im ^ 2 = -↑(Quaternion.normSq a.im)
-- Quaternion.coe_normSq_add
theorem coe_normSq_add : normSq (a + b) = normSq a + a * star b + b * star a + normSq b 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: ↑(Quaternion.normSq (a + b)) = ↑(Quaternion.normSq a) + a * star b + b * star a + ↑(Quaternion.normSq b)
-- Quaternion.normSq_smul
theorem normSq_smul (r : R) (q : ℍ[R]) : normSq (r • q) = r ^ 2 * normSq q 
Arguments: {R : Type u_3} [CommRing R] (r : R) (q : ℍ[R])
Goal: Quaternion.normSq (r • q) = r ^ 2 * Quaternion.normSq q
-- Quaternion.normSq_add
theorem normSq_add (a b : ℍ[R]) : normSq (a + b) = normSq a + normSq b + 2 * (a * star b).re 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: Quaternion.normSq (a + b) = Quaternion.normSq a + Quaternion.normSq b + 2 * (a * star b).re
-- Quaternion.normSq_eq_zero
@[simp]
theorem normSq_eq_zero : normSq a = 0 ↔ a = 0 
Arguments: {R : Type u_1} [LinearOrderedCommRing R] {a : ℍ[R]}
Goal: Quaternion.normSq a = 0 ↔ a = 0
-- Quaternion.normSq_ne_zero
theorem normSq_ne_zero : normSq a ≠ 0 ↔ a ≠ 0 
Arguments: {R : Type u_1} [LinearOrderedCommRing R] {a : ℍ[R]}
Goal: Quaternion.normSq a ≠ 0 ↔ a ≠ 0
-- Quaternion.normSq_nonneg
@[simp]
theorem normSq_nonneg : 0 ≤ normSq a 
Arguments: {R : Type u_1} [LinearOrderedCommRing R] {a : ℍ[R]}
Goal: 0 ≤ Quaternion.normSq a
-- Quaternion.normSq_le_zero
@[simp]
theorem normSq_le_zero : normSq a ≤ 0 ↔ a = 0 
Arguments: {R : Type u_1} [LinearOrderedCommRing R] {a : ℍ[R]}
Goal: Quaternion.normSq a ≤ 0 ↔ a = 0
-- Quaternion.sq_eq_normSq
theorem sq_eq_normSq : a ^ 2 = normSq a ↔ a = a.re 
Arguments: {R : Type u_1} [LinearOrderedCommRing R] {a : ℍ[R]}
Goal: a ^ 2 = ↑(Quaternion.normSq a) ↔ a = ↑a.re
-- Quaternion.sq_eq_neg_normSq
theorem sq_eq_neg_normSq : a ^ 2 = -normSq a ↔ a.re = 0 
Arguments: {R : Type u_1} [LinearOrderedCommRing R] {a : ℍ[R]}
Goal: a ^ 2 = -↑(Quaternion.normSq a) ↔ a.re = 0
-- Quaternion.instInv_inv
@[simps (config := .lemmasOnly)]
instance instInv : Inv ℍ[R] 
Arguments: {R : Type u_1} [LinearOrderedField R] (a : ℍ[R])
Goal: a⁻¹ = (Quaternion.normSq a)⁻¹ • star a
-- Quaternion.coe_inv
@[norm_cast, simp]
theorem coe_inv (x : R) : ((x⁻¹ : R) : ℍ[R]) = (↑x)⁻¹ 
Arguments: {R : Type u_1} [LinearOrderedField R] (x : R)
Goal: ↑x⁻¹ = (↑x)⁻¹
-- Quaternion.coe_div
@[norm_cast, simp]
theorem coe_div (x y : R) : ((x / y : R) : ℍ[R]) = x / y 
Arguments: {R : Type u_1} [LinearOrderedField R] (x y : R)
Goal: ↑(x / y) = ↑x / ↑y
-- Quaternion.coe_zpow
@[norm_cast, simp]
theorem coe_zpow (x : R) (z : ℤ) : ((x ^ z : R) : ℍ[R]) = (x : ℍ[R]) ^ z 
Arguments: {R : Type u_1} [LinearOrderedField R] (x : R) (z : ℤ)
Goal: ↑(x ^ z) = ↑x ^ z
-- Quaternion.re_nnratCast
@[simp, norm_cast] lemma re_nnratCast (q : ℚ≥0) : (q : ℍ[R]).re = q 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ≥0)
Goal: (↑q).re = ↑q
-- Quaternion.im_nnratCast
@[simp, norm_cast] lemma im_nnratCast (q : ℚ≥0) : (q : ℍ[R]).im = 0 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ≥0)
Goal: (↑q).im = 0
-- Quaternion.imI_nnratCast
@[simp, norm_cast] lemma imI_nnratCast (q : ℚ≥0) : (q : ℍ[R]).imI = 0 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ≥0)
Goal: (↑q).imI = 0
-- Quaternion.imJ_nnratCast
@[simp, norm_cast] lemma imJ_nnratCast (q : ℚ≥0) : (q : ℍ[R]).imJ = 0 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ≥0)
Goal: (↑q).imJ = 0
-- Quaternion.imK_nnratCast
@[simp, norm_cast] lemma imK_nnratCast (q : ℚ≥0) : (q : ℍ[R]).imK = 0 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ≥0)
Goal: (↑q).imK = 0
-- Quaternion.ratCast_re
@[simp, norm_cast] lemma ratCast_re (q : ℚ) : (q : ℍ[R]).re = q 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ)
Goal: (↑q).re = ↑q
-- Quaternion.ratCast_im
@[simp, norm_cast] lemma ratCast_im (q : ℚ) : (q : ℍ[R]).im = 0 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ)
Goal: (↑q).im = 0
-- Quaternion.ratCast_imI
@[simp, norm_cast] lemma ratCast_imI (q : ℚ) : (q : ℍ[R]).imI = 0 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ)
Goal: (↑q).imI = 0
-- Quaternion.ratCast_imJ
@[simp, norm_cast] lemma ratCast_imJ (q : ℚ) : (q : ℍ[R]).imJ = 0 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ)
Goal: (↑q).imJ = 0
-- Quaternion.ratCast_imK
@[simp, norm_cast] lemma ratCast_imK (q : ℚ) : (q : ℍ[R]).imK = 0 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ)
Goal: (↑q).imK = 0
-- Quaternion.coe_nnratCast
@[norm_cast] lemma coe_nnratCast (q : ℚ≥0) : ↑(q : R) = (q : ℍ[R]) 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ≥0)
Goal: ↑↑q = ↑q
-- Quaternion.coe_ratCast
@[norm_cast] lemma coe_ratCast (q : ℚ) : ↑(q : R) = (q : ℍ[R]) 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ)
Goal: ↑↑q = ↑q
-- Quaternion.normSq_inv
theorem normSq_inv : normSq a⁻¹ = (normSq a)⁻¹ 
Arguments: {R : Type u_1} [LinearOrderedField R] (a : ℍ[R])
Goal: Quaternion.normSq a⁻¹ = (Quaternion.normSq a)⁻¹
-- Quaternion.normSq_div
theorem normSq_div : normSq (a / b) = normSq a / normSq b 
Arguments: {R : Type u_1} [LinearOrderedField R] (a b : ℍ[R])
Goal: Quaternion.normSq (a / b) = Quaternion.normSq a / Quaternion.normSq b
-- Quaternion.normSq_zpow
theorem normSq_zpow (z : ℤ) : normSq (a ^ z) = normSq a ^ z 
Arguments: {R : Type u_1} [LinearOrderedField R] (a : ℍ[R]) (z : ℤ)
Goal: Quaternion.normSq (a ^ z) = Quaternion.normSq a ^ z
-- Quaternion.normSq_ratCast
@[norm_cast]
theorem normSq_ratCast (q : ℚ) : normSq (q : ℍ[R]) = (q : ℍ[R]) ^ 2 
Arguments: {R : Type u_1} [LinearOrderedField R] (q : ℚ)
Goal: ↑(Quaternion.normSq ↑q) = ↑q ^ 2
-- _private.Mathlib.Algebra.Quaternion.0.Cardinal.pow_four
private theorem pow_four [Infinite R] : #R ^ 4 = #R 
Arguments: {R : Type u_1} [Infinite R]
Goal: Cardinal.mk R ^ 4 = Cardinal.mk R
-- Cardinal.mk_quaternionAlgebra
theorem mk_quaternionAlgebra : #(ℍ[R,c₁,c₂]) = #R ^ 4 
Arguments: {R : Type u_1} (c₁ c₂ : R)
Goal: Cardinal.mk ℍ[R,c₁,c₂] = Cardinal.mk R ^ 4
-- Cardinal.mk_quaternionAlgebra_of_infinite
@[simp]
theorem mk_quaternionAlgebra_of_infinite [Infinite R] : #(ℍ[R,c₁,c₂]) = #R 
Arguments: {R : Type u_1} (c₁ c₂ : R) [Infinite R]
Goal: Cardinal.mk ℍ[R,c₁,c₂] = Cardinal.mk R
-- Cardinal.mk_univ_quaternionAlgebra
theorem mk_univ_quaternionAlgebra : #(Set.univ : Set ℍ[R,c₁,c₂]) = #R ^ 4 
Arguments: {R : Type u_1} (c₁ c₂ : R)
Goal: Cardinal.mk ↑Set.univ = Cardinal.mk R ^ 4
-- Cardinal.mk_univ_quaternionAlgebra_of_infinite
theorem mk_univ_quaternionAlgebra_of_infinite [Infinite R] :
    #(Set.univ : Set ℍ[R,c₁,c₂]) = #R 
Arguments: {R : Type u_1} (c₁ c₂ : R) [Infinite R]
Goal: Cardinal.mk ↑Set.univ = Cardinal.mk R
-- Cardinal.mk_quaternion
@[simp]
theorem mk_quaternion : #(ℍ[R]) = #R ^ 4 
Arguments: (R : Type u_1) [One R] [Neg R]
Goal: Cardinal.mk ℍ[R] = Cardinal.mk R ^ 4
-- Cardinal.mk_quaternion_of_infinite
theorem mk_quaternion_of_infinite [Infinite R] : #(ℍ[R]) = #R 
Arguments: (R : Type u_1) [One R] [Neg R] [Infinite R]
Goal: Cardinal.mk ℍ[R] = Cardinal.mk R
-- Cardinal.mk_univ_quaternion
--@[simp] Porting note (#10618): `simp` can prove it
theorem mk_univ_quaternion : #(Set.univ : Set ℍ[R]) = #R ^ 4 
Arguments: (R : Type u_1) [One R] [Neg R]
Goal: Cardinal.mk ↑Set.univ = Cardinal.mk R ^ 4
-- Cardinal.mk_univ_quaternion_of_infinite
theorem mk_univ_quaternion_of_infinite [Infinite R] : #(Set.univ : Set ℍ[R]) = #R 
Arguments: (R : Type u_1) [One R] [Neg R] [Infinite R]
Goal: Cardinal.mk ↑Set.univ = Cardinal.mk R
-- Setoid.ext
theorem ext {α : Sort*} : ∀ {s t : Setoid α},
    (∀ a b, @Setoid.r α s a b ↔ @Setoid.r α t a b) → s = t
  
Arguments: {α : Sort u_3} {s t : Setoid α}
Goal: (∀ (a b : α), Setoid.r a b ↔ Setoid.r a b) → s = t
-- Quot.induction_on
@[elab_as_elim]
protected theorem induction_on {α : Sort*} {r : α → α → Prop} {β : Quot r → Prop} (q : Quot r)
    (h : ∀ a, β (Quot.mk r a)) : β q 
Arguments: {α : Sort u_4} {r : α → α → Prop} {β : Quot r → Prop} (q : Quot r) (h : ∀ (a : α), β (Quot.mk r a))
Goal: β q
-- Quot.factor_mk_eq
theorem factor_mk_eq {α : Type*} (r s : α → α → Prop) (h : ∀ x y, r x y → s x y) :
    factor r s h ∘ Quot.mk _ = Quot.mk _ 
Arguments: {α : Type u_4} (r s : α → α → Prop) (h : ∀ (x y : α), r x y → s x y)
Goal: Quot.factor r s h ∘ Quot.mk r = Quot.mk s
-- Quot.lift_mk
theorem lift_mk (f : α → γ) (h : ∀ a₁ a₂, r a₁ a₂ → f a₁ = f a₂) (a : α) :
    Quot.lift f h (Quot.mk r a) = f a 
Arguments: {α : Sort u_1} {γ : Sort u_4} {r : α → α → Prop} (f : α → γ) (h : ∀ (a₁ a₂ : α), r a₁ a₂ → f a₁ = f a₂) (a : α)
Goal: Quot.lift f h (Quot.mk r a) = f a