File: Mathlib/Analysis/Quaternion.lean

full_name: Quaternion._aux_Mathlib_Analysis_Quaternion___unexpand_Quaternion_1
code: @[inherit_doc] scoped[Quaternion] notation "ℍ" => Quaternion ℝ
goal: Lean.PrettyPrinter.Unexpander

full_name: Quaternion._aux_Mathlib_Analysis_Quaternion___macroRules_Quaternion_termℍ_1
code: @[inherit_doc] scoped[Quaternion] notation "ℍ" => Quaternion ℝ
goal: Lean.Macro

full_name: Quaternion.instInnerReal
code: instance : Inner ℝ ℍ 
goal: Inner ℝ (Quaternion ℝ)

full_name: Quaternion.inner_self
code: theorem inner_self (a : ℍ) : ⟪a, a⟫ = normSq a 
goal: ⟪a, a⟫_ℝ = Quaternion.normSq a

full_name: Quaternion.inner_def
code: theorem inner_def (a b : ℍ) : ⟪a, b⟫ = (a * star b).re 
goal: ⟪a, b⟫_ℝ = (a * star b).re

full_name: Quaternion.instNormedAddCommGroupReal
code: noncomputable instance : NormedAddCommGroup ℍ 
goal: NormedAddCommGroup (Quaternion ℝ)

full_name: Quaternion.instInnerProductSpaceReal
code: noncomputable instance : InnerProductSpace ℝ ℍ 
goal: InnerProductSpace ℝ (Quaternion ℝ)

full_name: Quaternion.normSq_eq_norm_mul_self
code: theorem normSq_eq_norm_mul_self (a : ℍ) : normSq a = ‖a‖ * ‖a‖ 
goal: Quaternion.normSq a = ‖a‖ * ‖a‖

full_name: Quaternion.instNormOneClassReal
code: instance : NormOneClass ℍ 
goal: NormOneClass (Quaternion ℝ)

full_name: Quaternion.norm_coe
code: @[simp, norm_cast]
theorem norm_coe (a : ℝ) : ‖(a : ℍ)‖ = ‖a‖ 
goal: ‖↑a‖ = ‖a‖

full_name: Quaternion.nnnorm_coe
code: @[simp, norm_cast]
theorem nnnorm_coe (a : ℝ) : ‖(a : ℍ)‖₊ = ‖a‖₊ 
goal: ‖↑a‖₊ = ‖a‖₊

full_name: Quaternion.norm_star
code: @[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove this
theorem norm_star (a : ℍ) : ‖star a‖ = ‖a‖ 
goal: ‖star a‖ = ‖a‖

full_name: Quaternion.nnnorm_star
code: @[simp, nolint simpNF] -- Porting note (#10959): simp cannot prove this
theorem nnnorm_star (a : ℍ) : ‖star a‖₊ = ‖a‖₊ 
goal: ‖star a‖₊ = ‖a‖₊

full_name: Quaternion.instNormedDivisionRingReal
code: noncomputable instance : NormedDivisionRing ℍ 
goal: NormedDivisionRing (Quaternion ℝ)

full_name: Quaternion.instNormedAlgebraReal
code: noncomputable instance : NormedAlgebra ℝ ℍ 
goal: NormedAlgebra ℝ (Quaternion ℝ)

full_name: Quaternion.instCstarRingReal
code: instance : CstarRing ℍ 
goal: CstarRing (Quaternion ℝ)

full_name: Quaternion.coeComplex
code: /-- Coercion from `ℂ` to `ℍ`. -/
@[coe] def coeComplex (z : ℂ) : ℍ 
goal: Quaternion ℝ

full_name: Quaternion.instCoeComplexReal
code: instance : Coe ℂ ℍ 
goal: Coe ℂ (Quaternion ℝ)

full_name: Quaternion.coeComplex_re
code: @[simp, norm_cast]
theorem coeComplex_re (z : ℂ) : (z : ℍ).re = z.re 
goal: (↑z).re = z.re

full_name: Quaternion.coeComplex_imI
code: @[simp, norm_cast]
theorem coeComplex_imI (z : ℂ) : (z : ℍ).imI = z.im 
goal: (↑z).imI = z.im

full_name: Quaternion.coeComplex_imJ
code: @[simp, norm_cast]
theorem coeComplex_imJ (z : ℂ) : (z : ℍ).imJ = 0 
goal: (↑z).imJ = 0

full_name: Quaternion.coeComplex_imK
code: @[simp, norm_cast]
theorem coeComplex_imK (z : ℂ) : (z : ℍ).imK = 0 
goal: (↑z).imK = 0

full_name: Quaternion.coeComplex_add
code: @[simp, norm_cast]
theorem coeComplex_add (z w : ℂ) : ↑(z + w) = (z + w : ℍ) 
goal: ↑(z + w) = ↑z + ↑w

full_name: Quaternion.coeComplex_mul
code: @[simp, norm_cast]
theorem coeComplex_mul (z w : ℂ) : ↑(z * w) = (z * w : ℍ) 
goal: ↑(z * w) = ↑z * ↑w

full_name: Quaternion.coeComplex_zero
code: @[simp, norm_cast]
theorem coeComplex_zero : ((0 : ℂ) : ℍ) = 0 
goal: ↑0 = 0

full_name: Quaternion.coeComplex_one
code: @[simp, norm_cast]
theorem coeComplex_one : ((1 : ℂ) : ℍ) = 1 
goal: ↑1 = 1

full_name: Quaternion.coe_real_complex_mul
code: @[simp, norm_cast]
theorem coe_real_complex_mul (r : ℝ) (z : ℂ) : (r • z : ℍ) = ↑r * ↑z 
goal: r • ↑z = ↑r * ↑z

full_name: Quaternion.coeComplex_coe
code: @[simp, norm_cast]
theorem coeComplex_coe (r : ℝ) : ((r : ℂ) : ℍ) = r 
goal: ↑↑r = ↑r

full_name: Quaternion.ofComplex
code: /-- Coercion `ℂ →ₐ[ℝ] ℍ` as an algebra homomorphism. -/
def ofComplex : ℂ →ₐ[ℝ] ℍ 
goal: ℂ →ₐ[ℝ] Quaternion ℝ

full_name: Quaternion.coe_ofComplex
code: @[simp]
theorem coe_ofComplex : ⇑ofComplex = coeComplex 
goal: ⇑Quaternion.ofComplex = Quaternion.coeComplex

full_name: Quaternion.norm_piLp_equiv_symm_equivTuple
code: /-- The norm of the components as a euclidean vector equals the norm of the quaternion. -/
theorem norm_piLp_equiv_symm_equivTuple (x : ℍ) :
    ‖(WithLp.equiv 2 (Fin 4 → _)).symm (equivTuple ℝ x)‖ = ‖x‖ 
goal: ‖(WithLp.equiv 2 (Fin 4 → ℝ)).symm ((Quaternion.equivTuple ℝ) x)‖ = ‖x‖

full_name: Quaternion.linearIsometryEquivTuple
code: /-- `QuaternionAlgebra.linearEquivTuple` as a `LinearIsometryEquiv`. -/
@[simps apply symm_apply]
noncomputable def linearIsometryEquivTuple : ℍ ≃ₗᵢ[ℝ] EuclideanSpace ℝ (Fin 4) 
goal: Quaternion ℝ ≃ₗᵢ[ℝ] EuclideanSpace ℝ (Fin 4)

full_name: Quaternion.linearIsometryEquivTuple_apply
code: /-- `QuaternionAlgebra.linearEquivTuple` as a `LinearIsometryEquiv`. -/
@[simps apply symm_apply]
noncomputable def linearIsometryEquivTuple : ℍ ≃ₗᵢ[ℝ] EuclideanSpace ℝ (Fin 4) 
goal: Quaternion.linearIsometryEquivTuple a = (WithLp.equiv 2 (Fin 4 → ℝ)).symm ![a.re, a.imI, a.imJ, a.imK]

full_name: Quaternion.linearIsometryEquivTuple_symm_apply
code: /-- `QuaternionAlgebra.linearEquivTuple` as a `LinearIsometryEquiv`. -/
@[simps apply symm_apply]
noncomputable def linearIsometryEquivTuple : ℍ ≃ₗᵢ[ℝ] EuclideanSpace ℝ (Fin 4) 
goal: Quaternion.linearIsometryEquivTuple.symm a = { re := a 0, imI := a 1, imJ := a 2, imK := a 3 }

full_name: Quaternion.continuous_coe
code: @[continuity]
theorem continuous_coe : Continuous (coe : ℝ → ℍ) 
goal: Continuous Quaternion.coe

full_name: Quaternion.continuous_normSq
code: @[continuity]
theorem continuous_normSq : Continuous (normSq : ℍ → ℝ) 
goal: Continuous ⇑Quaternion.normSq

full_name: Quaternion.continuous_re
code: @[continuity]
theorem continuous_re : Continuous fun q : ℍ => q.re 
goal: Continuous fun q => q.re

full_name: Quaternion.continuous_imI
code: @[continuity]
theorem continuous_imI : Continuous fun q : ℍ => q.imI 
goal: Continuous fun q => q.imI

full_name: Quaternion.continuous_imJ
code: @[continuity]
theorem continuous_imJ : Continuous fun q : ℍ => q.imJ 
goal: Continuous fun q => q.imJ

full_name: Quaternion.continuous_imK
code: @[continuity]
theorem continuous_imK : Continuous fun q : ℍ => q.imK 
goal: Continuous fun q => q.imK

full_name: Quaternion.continuous_im
code: @[continuity]
theorem continuous_im : Continuous fun q : ℍ => q.im 
goal: Continuous fun q => q.im

full_name: Quaternion.instCompleteSpaceReal
code: instance : CompleteSpace ℍ 
goal: CompleteSpace (Quaternion ℝ)

full_name: Quaternion.hasSum_coe
code: @[simp, norm_cast]
theorem hasSum_coe {f : α → ℝ} {r : ℝ} : HasSum (fun a => (f a : ℍ)) (↑r : ℍ) ↔ HasSum f r 
goal: HasSum (fun a => ↑(f a)) ↑r ↔ HasSum f r

full_name: Quaternion.summable_coe
code: @[simp, norm_cast]
theorem summable_coe {f : α → ℝ} : (Summable fun a => (f a : ℍ)) ↔ Summable f 
goal: (Summable fun a => ↑(f a)) ↔ Summable f

full_name: Quaternion.tsum_coe
code: @[norm_cast]
theorem tsum_coe (f : α → ℝ) : (∑' a, (f a : ℍ)) = ↑(∑' a, f a) 
goal: ∑' (a : α), ↑(f a) = ↑(∑' (a : α), f a)