ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- QuaternionAlgebra.mk_add_mk
@[simp]
theorem mk_add_mk (a₁ a₂ a₃ a₄ b₁ b₂ b₃ b₄ : R) :
    (mk a₁ a₂ a₃ a₄ : ℍ[R,c₁,c₂]) + mk b₁ b₂ b₃ b₄ = mk (a₁ + b₁) (a₂ + b₂) (a₃ + b₃) (a₄ + b₄) 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a₁ a₂ a₃ a₄ b₁ b₂ b₃ b₄ : R)
Goal: { re := a₁, imI := a₂, imJ := a₃, imK := a₄ } + { re := b₁, imI := b₂, imJ := b₃, imK := b₄ } =
  { re := a₁ + b₁, imI := a₂ + b₂, imJ := a₃ + b₃, imK := a₄ + b₄ }
-- QuaternionAlgebra.coe_add
@[simp, norm_cast]
theorem coe_add : ((x + y : R) : ℍ[R,c₁,c₂]) = x + y 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (x y : R)
Goal: ↑(x + y) = ↑x + ↑y
-- QuaternionAlgebra.neg_re
@[simp] theorem neg_re : (-a).re = -a.re 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: (-a).re = -a.re
-- QuaternionAlgebra.neg_imI
@[simp] theorem neg_imI : (-a).imI = -a.imI 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: (-a).imI = -a.imI
-- QuaternionAlgebra.neg_imJ
@[simp] theorem neg_imJ : (-a).imJ = -a.imJ 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: (-a).imJ = -a.imJ
-- QuaternionAlgebra.neg_imK
@[simp] theorem neg_imK : (-a).imK = -a.imK 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: (-a).imK = -a.imK
-- QuaternionAlgebra.neg_im
@[simp] theorem neg_im : (-a).im = -a.im 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: (-a).im = -a.im
-- QuaternionAlgebra.neg_mk
@[simp]
theorem neg_mk (a₁ a₂ a₃ a₄ : R) : -(mk a₁ a₂ a₃ a₄ : ℍ[R,c₁,c₂]) = ⟨-a₁, -a₂, -a₃, -a₄⟩ 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a₁ a₂ a₃ a₄ : R)
Goal: -{ re := a₁, imI := a₂, imJ := a₃, imK := a₄ } = { re := -a₁, imI := -a₂, imJ := -a₃, imK := -a₄ }
-- QuaternionAlgebra.coe_neg
@[simp, norm_cast]
theorem coe_neg : ((-x : R) : ℍ[R,c₁,c₂]) = -x 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (x : R)
Goal: ↑(-x) = -↑x
-- QuaternionAlgebra.sub_re
@[simp] theorem sub_re : (a - b).re = a.re - b.re 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a b : ℍ[R,c₁,c₂])
Goal: (a - b).re = a.re - b.re
-- QuaternionAlgebra.sub_imI
@[simp] theorem sub_imI : (a - b).imI = a.imI - b.imI 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a b : ℍ[R,c₁,c₂])
Goal: (a - b).imI = a.imI - b.imI
-- QuaternionAlgebra.sub_imJ
@[simp] theorem sub_imJ : (a - b).imJ = a.imJ - b.imJ 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a b : ℍ[R,c₁,c₂])
Goal: (a - b).imJ = a.imJ - b.imJ
-- QuaternionAlgebra.sub_imK
@[simp] theorem sub_imK : (a - b).imK = a.imK - b.imK 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a b : ℍ[R,c₁,c₂])
Goal: (a - b).imK = a.imK - b.imK
-- QuaternionAlgebra.sub_im
@[simp] theorem sub_im : (a - b).im = a.im - b.im 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a b : ℍ[R,c₁,c₂])
Goal: (a - b).im = a.im - b.im
-- QuaternionAlgebra.mk_sub_mk
@[simp]
theorem mk_sub_mk (a₁ a₂ a₃ a₄ b₁ b₂ b₃ b₄ : R) :
    (mk a₁ a₂ a₃ a₄ : ℍ[R,c₁,c₂]) - mk b₁ b₂ b₃ b₄ = mk (a₁ - b₁) (a₂ - b₂) (a₃ - b₃) (a₄ - b₄) 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a₁ a₂ a₃ a₄ b₁ b₂ b₃ b₄ : R)
Goal: { re := a₁, imI := a₂, imJ := a₃, imK := a₄ } - { re := b₁, imI := b₂, imJ := b₃, imK := b₄ } =
  { re := a₁ - b₁, imI := a₂ - b₂, imJ := a₃ - b₃, imK := a₄ - b₄ }
-- QuaternionAlgebra.coe_im
@[simp, norm_cast]
theorem coe_im : (x : ℍ[R,c₁,c₂]).im = 0 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (x : R)
Goal: (↑x).im = 0
-- QuaternionAlgebra.re_add_im
@[simp]
theorem re_add_im : ↑a.re + a.im = a 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: ↑a.re + a.im = a
-- QuaternionAlgebra.sub_self_im
@[simp]
theorem sub_self_im : a - a.im = a.re 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: a - a.im = ↑a.re
-- QuaternionAlgebra.sub_self_re
@[simp]
theorem sub_self_re : a - a.re = a.im 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: a - ↑a.re = a.im
-- QuaternionAlgebra.mul_re
@[simp]
theorem mul_re : (a * b).re = a.1 * b.1 + c₁ * a.2 * b.2 + c₂ * a.3 * b.3 - c₁ * c₂ * a.4 * b.4 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a b : ℍ[R,c₁,c₂])
Goal: (a * b).re = a.re * b.re + c₁ * a.imI * b.imI + c₂ * a.imJ * b.imJ - c₁ * c₂ * a.imK * b.imK
-- QuaternionAlgebra.mul_imI
@[simp]
theorem mul_imI : (a * b).imI = a.1 * b.2 + a.2 * b.1 - c₂ * a.3 * b.4 + c₂ * a.4 * b.3 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a b : ℍ[R,c₁,c₂])
Goal: (a * b).imI = a.re * b.imI + a.imI * b.re - c₂ * a.imJ * b.imK + c₂ * a.imK * b.imJ
-- QuaternionAlgebra.mul_imJ
@[simp]
theorem mul_imJ : (a * b).imJ = a.1 * b.3 + c₁ * a.2 * b.4 + a.3 * b.1 - c₁ * a.4 * b.2 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a b : ℍ[R,c₁,c₂])
Goal: (a * b).imJ = a.re * b.imJ + c₁ * a.imI * b.imK + a.imJ * b.re - c₁ * a.imK * b.imI
-- QuaternionAlgebra.mul_imK
@[simp] theorem mul_imK : (a * b).imK = a.1 * b.4 + a.2 * b.3 - a.3 * b.2 + a.4 * b.1 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a b : ℍ[R,c₁,c₂])
Goal: (a * b).imK = a.re * b.imK + a.imI * b.imJ - a.imJ * b.imI + a.imK * b.re
-- QuaternionAlgebra.mk_mul_mk
@[simp]
theorem mk_mul_mk (a₁ a₂ a₃ a₄ b₁ b₂ b₃ b₄ : R) :
    (mk a₁ a₂ a₃ a₄ : ℍ[R,c₁,c₂]) * mk b₁ b₂ b₃ b₄ =
      ⟨a₁ * b₁ + c₁ * a₂ * b₂ + c₂ * a₃ * b₃ - c₁ * c₂ * a₄ * b₄,
        a₁ * b₂ + a₂ * b₁ - c₂ * a₃ * b₄ + c₂ * a₄ * b₃,
        a₁ * b₃ + c₁ * a₂ * b₄ + a₃ * b₁ - c₁ * a₄ * b₂, a₁ * b₄ + a₂ * b₃ - a₃ * b₂ + a₄ * b₁⟩ 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a₁ a₂ a₃ a₄ b₁ b₂ b₃ b₄ : R)
Goal: { re := a₁, imI := a₂, imJ := a₃, imK := a₄ } * { re := b₁, imI := b₂, imJ := b₃, imK := b₄ } =
  { re := a₁ * b₁ + c₁ * a₂ * b₂ + c₂ * a₃ * b₃ - c₁ * c₂ * a₄ * b₄,
    imI := a₁ * b₂ + a₂ * b₁ - c₂ * a₃ * b₄ + c₂ * a₄ * b₃, imJ := a₁ * b₃ + c₁ * a₂ * b₄ + a₃ * b₁ - c₁ * a₄ * b₂,
    imK := a₁ * b₄ + a₂ * b₃ - a₃ * b₂ + a₄ * b₁ }
-- QuaternionAlgebra.smul_re
@[simp] theorem smul_re : (s • a).re = s • a.re 
Arguments: {S : Type u_1} {R : Type u_3} {c₁ c₂ : R} (a : ℍ[R,c₁,c₂]) [SMul S R] (s : S)
Goal: (s • a).re = s • a.re
-- QuaternionAlgebra.smul_imI
@[simp] theorem smul_imI : (s • a).imI = s • a.imI 
Arguments: {S : Type u_1} {R : Type u_3} {c₁ c₂ : R} (a : ℍ[R,c₁,c₂]) [SMul S R] (s : S)
Goal: (s • a).imI = s • a.imI
-- QuaternionAlgebra.smul_imJ
@[simp] theorem smul_imJ : (s • a).imJ = s • a.imJ 
Arguments: {S : Type u_1} {R : Type u_3} {c₁ c₂ : R} (a : ℍ[R,c₁,c₂]) [SMul S R] (s : S)
Goal: (s • a).imJ = s • a.imJ
-- QuaternionAlgebra.smul_imK
@[simp] theorem smul_imK : (s • a).imK = s • a.imK 
Arguments: {S : Type u_1} {R : Type u_3} {c₁ c₂ : R} (a : ℍ[R,c₁,c₂]) [SMul S R] (s : S)
Goal: (s • a).imK = s • a.imK
-- QuaternionAlgebra.smul_im
@[simp] theorem smul_im {S} [SMulZeroClass S R] (s : S) : (s • a).im = s • a.im 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂]) {S : Type u_4} [SMulZeroClass S R] (s : S)
Goal: (s • a).im = s • a.im
-- QuaternionAlgebra.smul_mk
@[simp]
theorem smul_mk (re im_i im_j im_k : R) :
    s • (⟨re, im_i, im_j, im_k⟩ : ℍ[R,c₁,c₂]) = ⟨s • re, s • im_i, s • im_j, s • im_k⟩ 
Arguments: {S : Type u_1} {R : Type u_3} {c₁ c₂ : R} [SMul S R] (s : S) (re im_i im_j im_k : R)
Goal: s • { re := re, imI := im_i, imJ := im_j, imK := im_k } =
  { re := s • re, imI := s • im_i, imJ := s • im_j, imK := s • im_k }
-- QuaternionAlgebra.coe_smul
@[simp, norm_cast]
theorem coe_smul [SMulZeroClass S R] (s : S) (r : R) :
    (↑(s • r) : ℍ[R,c₁,c₂]) = s • (r : ℍ[R,c₁,c₂]) 
Arguments: {S : Type u_1} {R : Type u_3} [CommRing R] {c₁ c₂ : R} [SMulZeroClass S R] (s : S) (r : R)
Goal: ↑(s • r) = s • ↑r
-- QuaternionAlgebra.natCast_re
@[simp, norm_cast]
theorem natCast_re (n : ℕ) : (n : ℍ[R,c₁,c₂]).re = n 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (n : ℕ)
Goal: (↑n).re = ↑n
-- QuaternionAlgebra.natCast_imI
@[simp, norm_cast]
theorem natCast_imI (n : ℕ) : (n : ℍ[R,c₁,c₂]).imI = 0 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (n : ℕ)
Goal: (↑n).imI = 0
-- QuaternionAlgebra.natCast_imJ
@[simp, norm_cast]
theorem natCast_imJ (n : ℕ) : (n : ℍ[R,c₁,c₂]).imJ = 0 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (n : ℕ)
Goal: (↑n).imJ = 0
-- QuaternionAlgebra.natCast_imK
@[simp, norm_cast]
theorem natCast_imK (n : ℕ) : (n : ℍ[R,c₁,c₂]).imK = 0 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (n : ℕ)
Goal: (↑n).imK = 0
-- QuaternionAlgebra.natCast_im
@[simp, norm_cast]
theorem natCast_im (n : ℕ) : (n : ℍ[R,c₁,c₂]).im = 0 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (n : ℕ)
Goal: (↑n).im = 0
-- QuaternionAlgebra.coe_natCast
@[norm_cast]
theorem coe_natCast (n : ℕ) : ↑(n : R) = (n : ℍ[R,c₁,c₂]) 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (n : ℕ)
Goal: ↑↑n = ↑n
-- QuaternionAlgebra.intCast_re
@[simp, norm_cast]
theorem intCast_re (z : ℤ) : (z : ℍ[R,c₁,c₂]).re = z 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (z : ℤ)
Goal: (↑z).re = ↑z
-- QuaternionAlgebra.intCast_imI
@[simp, norm_cast]
theorem intCast_imI (z : ℤ) : (z : ℍ[R,c₁,c₂]).imI = 0 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (z : ℤ)
Goal: (↑z).imI = 0
-- QuaternionAlgebra.intCast_imJ
@[simp, norm_cast]
theorem intCast_imJ (z : ℤ) : (z : ℍ[R,c₁,c₂]).imJ = 0 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (z : ℤ)
Goal: (↑z).imJ = 0
-- QuaternionAlgebra.intCast_imK
@[simp, norm_cast]
theorem intCast_imK (z : ℤ) : (z : ℍ[R,c₁,c₂]).imK = 0 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (z : ℤ)
Goal: (↑z).imK = 0
-- QuaternionAlgebra.intCast_im
@[simp, norm_cast]
theorem intCast_im (z : ℤ) : (z : ℍ[R,c₁,c₂]).im = 0 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (z : ℤ)
Goal: (↑z).im = 0
-- QuaternionAlgebra.coe_intCast
@[norm_cast]
theorem coe_intCast (z : ℤ) : ↑(z : R) = (z : ℍ[R,c₁,c₂]) 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (z : ℤ)
Goal: ↑↑z = ↑z
-- QuaternionAlgebra.coe_mul
@[norm_cast, simp]
theorem coe_mul : ((x * y : R) : ℍ[R,c₁,c₂]) = x * y 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (x y : R)
Goal: ↑(x * y) = ↑x * ↑y
-- QuaternionAlgebra.algebraMap_eq
theorem algebraMap_eq (r : R) : algebraMap R ℍ[R,c₁,c₂] r = ⟨r, 0, 0, 0⟩ 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (r : R)
Goal: (algebraMap R ℍ[R,c₁,c₂]) r = { re := r, imI := 0, imJ := 0, imK := 0 }
-- QuaternionAlgebra.algebraMap_injective
theorem algebraMap_injective : (algebraMap R ℍ[R,c₁,c₂] : _ → _).Injective 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R}
Goal: Function.Injective ⇑(algebraMap R ℍ[R,c₁,c₂])
-- QuaternionAlgebra.reₗ_apply
@[simps]
def reₗ : ℍ[R,c₁,c₂] →ₗ[R] R 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (self : ℍ[R,c₁,c₂])
Goal: (QuaternionAlgebra.reₗ c₁ c₂) self = self.re
-- QuaternionAlgebra.imIₗ_apply
@[simps]
def imIₗ : ℍ[R,c₁,c₂] →ₗ[R] R 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (self : ℍ[R,c₁,c₂])
Goal: (QuaternionAlgebra.imIₗ c₁ c₂) self = self.imI
-- QuaternionAlgebra.imJₗ_apply
@[simps]
def imJₗ : ℍ[R,c₁,c₂] →ₗ[R] R 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (self : ℍ[R,c₁,c₂])
Goal: (QuaternionAlgebra.imJₗ c₁ c₂) self = self.imJ
-- QuaternionAlgebra.imKₗ_apply
@[simps]
def imKₗ : ℍ[R,c₁,c₂] →ₗ[R] R 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (self : ℍ[R,c₁,c₂])
Goal: (QuaternionAlgebra.imKₗ c₁ c₂) self = self.imK
-- QuaternionAlgebra.coe_linearEquivTuple
@[simp]
theorem coe_linearEquivTuple : ⇑(linearEquivTuple c₁ c₂) = equivTuple c₁ c₂ 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R)
Goal: ⇑(QuaternionAlgebra.linearEquivTuple c₁ c₂) = ⇑(QuaternionAlgebra.equivTuple c₁ c₂)
-- QuaternionAlgebra.coe_linearEquivTuple_symm
@[simp]
theorem coe_linearEquivTuple_symm : ⇑(linearEquivTuple c₁ c₂).symm = (equivTuple c₁ c₂).symm 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R)
Goal: ⇑(QuaternionAlgebra.linearEquivTuple c₁ c₂).symm = ⇑(QuaternionAlgebra.equivTuple c₁ c₂).symm
-- QuaternionAlgebra.coe_basisOneIJK_repr
@[simp]
theorem coe_basisOneIJK_repr (q : ℍ[R,c₁,c₂]) :
    ⇑((basisOneIJK c₁ c₂).repr q) = ![q.re, q.imI, q.imJ, q.imK] 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (q : ℍ[R,c₁,c₂])
Goal: ⇑((QuaternionAlgebra.basisOneIJK c₁ c₂).repr q) = ![q.re, q.imI, q.imJ, q.imK]
-- QuaternionAlgebra.rank_eq_four
theorem rank_eq_four [StrongRankCondition R] : Module.rank R ℍ[R,c₁,c₂] = 4 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) [StrongRankCondition R]
Goal: Module.rank R ℍ[R,c₁,c₂] = 4
-- QuaternionAlgebra.finrank_eq_four
theorem finrank_eq_four [StrongRankCondition R] : FiniteDimensional.finrank R ℍ[R,c₁,c₂] = 4 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) [StrongRankCondition R]
Goal: FiniteDimensional.finrank R ℍ[R,c₁,c₂] = 4
-- QuaternionAlgebra.swapEquiv_symm_apply_imJ
@[simps]
def swapEquiv : ℍ[R,c₁,c₂] ≃ₐ[R] ℍ[R, c₂, c₁] 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (t : ℍ[R,c₂,c₁])
Goal: ((QuaternionAlgebra.swapEquiv c₁ c₂).symm t).imJ = t.imI
-- QuaternionAlgebra.swapEquiv_apply_imI
@[simps]
def swapEquiv : ℍ[R,c₁,c₂] ≃ₐ[R] ℍ[R, c₂, c₁] 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (t : ℍ[R,c₁,c₂])
Goal: ((QuaternionAlgebra.swapEquiv c₁ c₂) t).imI = t.imJ
-- QuaternionAlgebra.swapEquiv_apply_imK
@[simps]
def swapEquiv : ℍ[R,c₁,c₂] ≃ₐ[R] ℍ[R, c₂, c₁] 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (t : ℍ[R,c₁,c₂])
Goal: ((QuaternionAlgebra.swapEquiv c₁ c₂) t).imK = -t.imK
-- QuaternionAlgebra.swapEquiv_apply_re
@[simps]
def swapEquiv : ℍ[R,c₁,c₂] ≃ₐ[R] ℍ[R, c₂, c₁] 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (t : ℍ[R,c₁,c₂])
Goal: ((QuaternionAlgebra.swapEquiv c₁ c₂) t).re = t.re
-- QuaternionAlgebra.swapEquiv_symm_apply_imI
@[simps]
def swapEquiv : ℍ[R,c₁,c₂] ≃ₐ[R] ℍ[R, c₂, c₁] 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (t : ℍ[R,c₂,c₁])
Goal: ((QuaternionAlgebra.swapEquiv c₁ c₂).symm t).imI = t.imJ
-- QuaternionAlgebra.swapEquiv_apply_imJ
@[simps]
def swapEquiv : ℍ[R,c₁,c₂] ≃ₐ[R] ℍ[R, c₂, c₁] 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (t : ℍ[R,c₁,c₂])
Goal: ((QuaternionAlgebra.swapEquiv c₁ c₂) t).imJ = t.imI
-- QuaternionAlgebra.swapEquiv_symm_apply_re
@[simps]
def swapEquiv : ℍ[R,c₁,c₂] ≃ₐ[R] ℍ[R, c₂, c₁] 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (t : ℍ[R,c₂,c₁])
Goal: ((QuaternionAlgebra.swapEquiv c₁ c₂).symm t).re = t.re
-- QuaternionAlgebra.swapEquiv_symm_apply_imK
@[simps]
def swapEquiv : ℍ[R,c₁,c₂] ≃ₐ[R] ℍ[R, c₂, c₁] 
Arguments: {R : Type u_3} [CommRing R] (c₁ c₂ : R) (t : ℍ[R,c₂,c₁])
Goal: ((QuaternionAlgebra.swapEquiv c₁ c₂).symm t).imK = -t.imK
-- QuaternionAlgebra.coe_sub
@[norm_cast, simp]
theorem coe_sub : ((x - y : R) : ℍ[R,c₁,c₂]) = x - y 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (x y : R)
Goal: ↑(x - y) = ↑x - ↑y
-- QuaternionAlgebra.coe_pow
@[norm_cast, simp]
theorem coe_pow (n : ℕ) : (↑(x ^ n) : ℍ[R,c₁,c₂]) = (x : ℍ[R,c₁,c₂]) ^ n 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (x : R) (n : ℕ)
Goal: ↑(x ^ n) = ↑x ^ n
-- QuaternionAlgebra.coe_commutes
theorem coe_commutes : ↑r * a = a * r 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (r : R) (a : ℍ[R,c₁,c₂])
Goal: ↑r * a = a * ↑r
-- QuaternionAlgebra.coe_commute
theorem coe_commute : Commute (↑r) a 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (r : R) (a : ℍ[R,c₁,c₂])
Goal: Commute (↑r) a
-- QuaternionAlgebra.coe_mul_eq_smul
theorem coe_mul_eq_smul : ↑r * a = r • a 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (r : R) (a : ℍ[R,c₁,c₂])
Goal: ↑r * a = r • a
-- QuaternionAlgebra.mul_coe_eq_smul
theorem mul_coe_eq_smul : a * r = r • a 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (r : R) (a : ℍ[R,c₁,c₂])
Goal: a * ↑r = r • a
-- QuaternionAlgebra.coe_algebraMap
@[norm_cast, simp]
theorem coe_algebraMap : ⇑(algebraMap R ℍ[R,c₁,c₂]) = coe 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R}
Goal: ⇑(algebraMap R ℍ[R,c₁,c₂]) = QuaternionAlgebra.coe
-- QuaternionAlgebra.smul_coe
theorem smul_coe : x • (y : ℍ[R,c₁,c₂]) = ↑(x * y) 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (x y : R)
Goal: x • ↑y = ↑(x * y)
-- QuaternionAlgebra.re_star
@[simp] theorem re_star : (star a).re = a.re 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: (star a).re = a.re
-- QuaternionAlgebra.imI_star
@[simp]
theorem imI_star : (star a).imI = -a.imI 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: (star a).imI = -a.imI
-- QuaternionAlgebra.imJ_star
@[simp]
theorem imJ_star : (star a).imJ = -a.imJ 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: (star a).imJ = -a.imJ
-- QuaternionAlgebra.imK_star
@[simp]
theorem imK_star : (star a).imK = -a.imK 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: (star a).imK = -a.imK
-- QuaternionAlgebra.im_star
@[simp]
theorem im_star : (star a).im = -a.im 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: (star a).im = -a.im
-- QuaternionAlgebra.star_mk
@[simp]
theorem star_mk (a₁ a₂ a₃ a₄ : R) : star (mk a₁ a₂ a₃ a₄ : ℍ[R,c₁,c₂]) = ⟨a₁, -a₂, -a₃, -a₄⟩ 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a₁ a₂ a₃ a₄ : R)
Goal: star { re := a₁, imI := a₂, imJ := a₃, imK := a₄ } = { re := a₁, imI := -a₂, imJ := -a₃, imK := -a₄ }
-- QuaternionAlgebra.self_add_star'
theorem self_add_star' : a + star a = ↑(2 * a.re) 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: a + star a = ↑(2 * a.re)
-- QuaternionAlgebra.self_add_star
theorem self_add_star : a + star a = 2 * a.re 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: a + star a = 2 * ↑a.re
-- QuaternionAlgebra.star_add_self'
theorem star_add_self' : star a + a = ↑(2 * a.re) 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: star a + a = ↑(2 * a.re)
-- QuaternionAlgebra.star_add_self
theorem star_add_self : star a + a = 2 * a.re 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: star a + a = 2 * ↑a.re
-- QuaternionAlgebra.star_eq_two_re_sub
theorem star_eq_two_re_sub : star a = ↑(2 * a.re) - a 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: star a = ↑(2 * a.re) - a
-- QuaternionAlgebra.star_coe
@[simp, norm_cast]
theorem star_coe : star (x : ℍ[R,c₁,c₂]) = x 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (x : R)
Goal: star ↑x = ↑x
-- QuaternionAlgebra.star_im
@[simp] theorem star_im : star a.im = -a.im 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: star a.im = -a.im
-- QuaternionAlgebra.star_smul
@[simp]
theorem star_smul [Monoid S] [DistribMulAction S R] (s : S) (a : ℍ[R,c₁,c₂]) :
    star (s • a) = s • star a 
Arguments: {S : Type u_1} {R : Type u_3} [CommRing R] {c₁ c₂ : R} [Monoid S] [DistribMulAction S R] (s : S) (a : ℍ[R,c₁,c₂])
Goal: star (s • a) = s • star a
-- QuaternionAlgebra.eq_re_of_eq_coe
theorem eq_re_of_eq_coe {a : ℍ[R,c₁,c₂]} {x : R} (h : a = x) : a = a.re 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} {a : ℍ[R,c₁,c₂]} {x : R} (h : a = ↑x)
Goal: a = ↑a.re
-- QuaternionAlgebra.eq_re_iff_mem_range_coe
theorem eq_re_iff_mem_range_coe {a : ℍ[R,c₁,c₂]} :
    a = a.re ↔ a ∈ Set.range (coe : R → ℍ[R,c₁,c₂]) 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} {a : ℍ[R,c₁,c₂]}
Goal: a = ↑a.re ↔ a ∈ Set.range QuaternionAlgebra.coe
-- QuaternionAlgebra.star_eq_self
@[simp]
theorem star_eq_self {c₁ c₂ : R} {a : ℍ[R,c₁,c₂]} : star a = a ↔ a = a.re 
Arguments: {R : Type u_3} [CommRing R] [NoZeroDivisors R] [CharZero R] {c₁ c₂ : R} {a : ℍ[R,c₁,c₂]}
Goal: star a = a ↔ a = ↑a.re
-- QuaternionAlgebra.star_eq_neg
theorem star_eq_neg {c₁ c₂ : R} {a : ℍ[R,c₁,c₂]} : star a = -a ↔ a.re = 0 
Arguments: {R : Type u_3} [CommRing R] [NoZeroDivisors R] [CharZero R] {c₁ c₂ : R} {a : ℍ[R,c₁,c₂]}
Goal: star a = -a ↔ a.re = 0
-- QuaternionAlgebra.star_mul_eq_coe
theorem star_mul_eq_coe : star a * a = (star a * a).re 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: star a * a = ↑(star a * a).re
-- QuaternionAlgebra.mul_star_eq_coe
theorem mul_star_eq_coe : a * star a = (a * star a).re 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R} (a : ℍ[R,c₁,c₂])
Goal: a * star a = ↑(a * star a).re
-- QuaternionAlgebra.coe_starAe
@[simp]
theorem coe_starAe : ⇑(starAe : ℍ[R,c₁,c₂] ≃ₐ[R] _) = op ∘ star 
Arguments: {R : Type u_3} [CommRing R] {c₁ c₂ : R}
Goal: ⇑QuaternionAlgebra.starAe = MulOpposite.op ∘ star
-- Quaternion.equivProd_symm_apply_imI
@[simps!]
def Quaternion.equivProd (R : Type*) [One R] [Neg R] : ℍ[R] ≃ R × R × R × R 
Arguments: (R : Type u_1) [One R] [Neg R] (a : R × R × R × R)
Goal: ((Quaternion.equivProd R).symm a).imI = a.2.1
-- Quaternion.equivProd_symm_apply_imJ
@[simps!]
def Quaternion.equivProd (R : Type*) [One R] [Neg R] : ℍ[R] ≃ R × R × R × R 
Arguments: (R : Type u_1) [One R] [Neg R] (a : R × R × R × R)
Goal: ((Quaternion.equivProd R).symm a).imJ = a.2.2.1
-- Quaternion.equivProd_symm_apply_re
@[simps!]
def Quaternion.equivProd (R : Type*) [One R] [Neg R] : ℍ[R] ≃ R × R × R × R 
Arguments: (R : Type u_1) [One R] [Neg R] (a : R × R × R × R)
Goal: ((Quaternion.equivProd R).symm a).re = a.1
-- Quaternion.equivProd_symm_apply_imK
@[simps!]
def Quaternion.equivProd (R : Type*) [One R] [Neg R] : ℍ[R] ≃ R × R × R × R 
Arguments: (R : Type u_1) [One R] [Neg R] (a : R × R × R × R)
Goal: ((Quaternion.equivProd R).symm a).imK = a.2.2.2
-- Quaternion.equivProd_apply
@[simps!]
def Quaternion.equivProd (R : Type*) [One R] [Neg R] : ℍ[R] ≃ R × R × R × R 
Arguments: (R : Type u_1) [One R] [Neg R] (a : ℍ[R,-1,-1])
Goal: (Quaternion.equivProd R) a = (a.re, a.imI, a.imJ, a.imK)
-- Quaternion.equivTuple_symm_apply
@[simps! symm_apply]
def Quaternion.equivTuple (R : Type*) [One R] [Neg R] : ℍ[R] ≃ (Fin 4 → R) 
Arguments: (R : Type u_1) [One R] [Neg R] (a : Fin 4 → R)
Goal: (Quaternion.equivTuple R).symm a = { re := a 0, imI := a 1, imJ := a 2, imK := a 3 }
-- Quaternion.equivTuple_apply
@[simp]
theorem Quaternion.equivTuple_apply (R : Type*) [One R] [Neg R] (x : ℍ[R]) :
    Quaternion.equivTuple R x = ![x.re, x.imI, x.imJ, x.imK] 
Arguments: (R : Type u_1) [One R] [Neg R] (x : ℍ[R])
Goal: (Quaternion.equivTuple R) x = ![x.re, x.imI, x.imJ, x.imK]
-- Quaternion.ext
@[ext]
theorem ext : a.re = b.re → a.imI = b.imI → a.imJ = b.imJ → a.imK = b.imK → a = b 
Arguments: {R : Type u_3} [CommRing R] (a b : ℍ[R])
Goal: a.re = b.re → a.imI = b.imI → a.imJ = b.imJ → a.imK = b.imK → a = b
-- Quaternion.ext_iff
theorem ext_iff {a b : ℍ[R]} :
    a = b ↔ 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 ↔ a.re = b.re ∧ a.imI = b.imI ∧ a.imJ = b.imJ ∧ a.imK = b.imK
-- Quaternion.im_re
@[simp] theorem im_re : a.im.re = 0 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a.im.re = 0
-- Quaternion.im_imI
@[simp] theorem im_imI : a.im.imI = a.imI 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a.im.imI = a.imI
-- Quaternion.im_imJ
@[simp] theorem im_imJ : a.im.imJ = a.imJ 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a.im.imJ = a.imJ
-- Quaternion.im_imK
@[simp] theorem im_imK : a.im.imK = a.imK 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a.im.imK = a.imK
-- Quaternion.im_idem
@[simp] theorem im_idem : a.im.im = a.im 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a.im.im = a.im
-- Quaternion.re_add_im
@[simp] nonrec theorem re_add_im : ↑a.re + a.im = a 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: ↑a.re + a.im = a
-- Quaternion.sub_self_im
@[simp] nonrec theorem sub_self_im : a - a.im = a.re 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a - a.im = ↑a.re
-- Quaternion.sub_self_re
@[simp] nonrec theorem sub_self_re : a - ↑a.re = a.im 
Arguments: {R : Type u_3} [CommRing R] (a : ℍ[R])
Goal: a - ↑a.re = a.im
-- Quaternion.coe_re
@[simp, norm_cast]
theorem coe_re : (x : ℍ[R]).re = x 
Arguments: {R : Type u_3} [CommRing R] (x : R)
Goal: (↑x).re = x
-- Quaternion.coe_imI
@[simp, norm_cast]
theorem coe_imI : (x : ℍ[R]).imI = 0 
Arguments: {R : Type u_3} [CommRing R] (x : R)
Goal: (↑x).imI = 0
-- Quaternion.coe_imJ
@[simp, norm_cast]
theorem coe_imJ : (x : ℍ[R]).imJ = 0 
Arguments: {R : Type u_3} [CommRing R] (x : R)
Goal: (↑x).imJ = 0
-- Quaternion.coe_imK
@[simp, norm_cast]
theorem coe_imK : (x : ℍ[R]).imK = 0 
Arguments: {R : Type u_3} [CommRing R] (x : R)
Goal: (↑x).imK = 0
-- Quaternion.coe_im
@[simp, norm_cast]
theorem coe_im : (x : ℍ[R]).im = 0 
Arguments: {R : Type u_3} [CommRing R] (x : R)
Goal: (↑x).im = 0
-- Quaternion.zero_re
@[simp] theorem zero_re : (0 : ℍ[R]).re = 0 
Arguments: {R : Type u_3} [CommRing R]
Goal: Quaternion.re 0 = 0