File: Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean

full_name: CliffordAlgebraRing.ι_eq_zero
code: @[simp]
theorem ι_eq_zero : ι (0 : QuadraticForm R Unit) = 0 
goal: CliffordAlgebra.ι 0 = 0

full_name: CliffordAlgebraRing.instCommRingCliffordAlgebraUnitOfNatQuadraticForm
code: /-- Since the vector space is empty the ring is commutative. -/
instance : CommRing (CliffordAlgebra (0 : QuadraticForm R Unit)) 
goal: CommRing (CliffordAlgebra 0)

full_name: CliffordAlgebraRing.reverse_apply
code: theorem reverse_apply (x : CliffordAlgebra (0 : QuadraticForm R Unit)) :
    reverse (R := R) x = x 
goal: CliffordAlgebra.reverse x = x

full_name: CliffordAlgebraRing.reverse_eq_id
code: @[simp]
theorem reverse_eq_id :
    (reverse : CliffordAlgebra (0 : QuadraticForm R Unit) →ₗ[R] _) = LinearMap.id 
goal: CliffordAlgebra.reverse = LinearMap.id

full_name: CliffordAlgebraRing.involute_eq_id
code: @[simp]
theorem involute_eq_id :
    (involute : CliffordAlgebra (0 : QuadraticForm R Unit) →ₐ[R] _) = AlgHom.id R _ 
goal: CliffordAlgebra.involute = AlgHom.id R (CliffordAlgebra 0)

full_name: CliffordAlgebraRing.equiv
code: /-- The clifford algebra over a 0-dimensional vector space is isomorphic to its scalars. -/
protected def equiv : CliffordAlgebra (0 : QuadraticForm R Unit) ≃ₐ[R] R 
goal: CliffordAlgebra 0 ≃ₐ[R] R

full_name: CliffordAlgebraComplex.Q
code: /-- The quadratic form sending elements to the negation of their square. -/
def Q : QuadraticForm ℝ ℝ 
goal: QuadraticForm ℝ ℝ

full_name: CliffordAlgebraComplex.Q_apply
code: @[simp]
theorem Q_apply (r : ℝ) : Q r = -(r * r) 
goal: CliffordAlgebraComplex.Q r = -(r * r)

full_name: CliffordAlgebraComplex.toComplex
code: /-- Intermediate result for `CliffordAlgebraComplex.equiv`: clifford algebras over
`CliffordAlgebraComplex.Q` above can be converted to `ℂ`. -/
def toComplex : CliffordAlgebra Q →ₐ[ℝ] ℂ 
goal: CliffordAlgebra CliffordAlgebraComplex.Q →ₐ[ℝ] ℂ

full_name: CliffordAlgebraComplex.toComplex_ι
code: @[simp]
theorem toComplex_ι (r : ℝ) : toComplex (ι Q r) = r • Complex.I 
goal: CliffordAlgebraComplex.toComplex ((CliffordAlgebra.ι CliffordAlgebraComplex.Q) r) = r • Complex.I

full_name: CliffordAlgebraComplex.toComplex_involute
code: /-- `CliffordAlgebra.involute` is analogous to `Complex.conj`. -/
@[simp]
theorem toComplex_involute (c : CliffordAlgebra Q) :
    toComplex (involute c) = conj (toComplex c) 
goal: CliffordAlgebraComplex.toComplex (CliffordAlgebra.involute c) = (starRingEnd ℂ) (CliffordAlgebraComplex.toComplex c)

full_name: CliffordAlgebraComplex.ofComplex
code: /-- Intermediate result for `CliffordAlgebraComplex.equiv`: `ℂ` can be converted to
`CliffordAlgebraComplex.Q` above can be converted to. -/
def ofComplex : ℂ →ₐ[ℝ] CliffordAlgebra Q 
goal: ℂ →ₐ[ℝ] CliffordAlgebra CliffordAlgebraComplex.Q

full_name: CliffordAlgebraComplex.ofComplex_I
code: @[simp]
theorem ofComplex_I : ofComplex Complex.I = ι Q 1 
goal: CliffordAlgebraComplex.ofComplex Complex.I = (CliffordAlgebra.ι CliffordAlgebraComplex.Q) 1

full_name: CliffordAlgebraComplex.toComplex_comp_ofComplex
code: @[simp]
theorem toComplex_comp_ofComplex : toComplex.comp ofComplex = AlgHom.id ℝ ℂ 
goal: CliffordAlgebraComplex.toComplex.comp CliffordAlgebraComplex.ofComplex = AlgHom.id ℝ ℂ

full_name: CliffordAlgebraComplex.toComplex_ofComplex
code: @[simp]
theorem toComplex_ofComplex (c : ℂ) : toComplex (ofComplex c) = c 
goal: CliffordAlgebraComplex.toComplex (CliffordAlgebraComplex.ofComplex c) = c

full_name: CliffordAlgebraComplex.ofComplex_comp_toComplex
code: @[simp]
theorem ofComplex_comp_toComplex : ofComplex.comp toComplex = AlgHom.id ℝ (CliffordAlgebra Q) 
goal: CliffordAlgebraComplex.ofComplex.comp CliffordAlgebraComplex.toComplex =
  AlgHom.id ℝ (CliffordAlgebra CliffordAlgebraComplex.Q)

full_name: CliffordAlgebraComplex.ofComplex_toComplex
code: @[simp]
theorem ofComplex_toComplex (c : CliffordAlgebra Q) : ofComplex (toComplex c) = c 
goal: CliffordAlgebraComplex.ofComplex (CliffordAlgebraComplex.toComplex c) = c

full_name: CliffordAlgebraComplex.equiv
code: /-- The clifford algebras over `CliffordAlgebraComplex.Q` is isomorphic as an `ℝ`-algebra to `ℂ`. -/
@[simps!]
protected def equiv : CliffordAlgebra Q ≃ₐ[ℝ] ℂ 
goal: CliffordAlgebra CliffordAlgebraComplex.Q ≃ₐ[ℝ] ℂ

full_name: CliffordAlgebraComplex.equiv_apply
code: /-- The clifford algebras over `CliffordAlgebraComplex.Q` is isomorphic as an `ℝ`-algebra to `ℂ`. -/
@[simps!]
protected def equiv : CliffordAlgebra Q ≃ₐ[ℝ] ℂ 
goal: CliffordAlgebraComplex.equiv a = CliffordAlgebraComplex.toComplex a

full_name: CliffordAlgebraComplex.equiv_symm_apply
code: /-- The clifford algebras over `CliffordAlgebraComplex.Q` is isomorphic as an `ℝ`-algebra to `ℂ`. -/
@[simps!]
protected def equiv : CliffordAlgebra Q ≃ₐ[ℝ] ℂ 
goal: CliffordAlgebraComplex.equiv.symm a = CliffordAlgebraComplex.ofComplex a

full_name: CliffordAlgebraComplex.instCommRingCliffordAlgebraRealQ
code: /-- The clifford algebra is commutative since it is isomorphic to the complex numbers.

TODO: prove this is true for all `CliffordAlgebra`s over a 1-dimensional vector space. -/
instance : CommRing (CliffordAlgebra Q) 
goal: CommRing (CliffordAlgebra CliffordAlgebraComplex.Q)

full_name: CliffordAlgebraComplex.reverse_apply
code: /-- `reverse` is a no-op over `CliffordAlgebraComplex.Q`. -/
theorem reverse_apply (x : CliffordAlgebra Q) : reverse (R := ℝ) x = x 
goal: CliffordAlgebra.reverse x = x

full_name: CliffordAlgebraComplex.reverse_eq_id
code: @[simp]
theorem reverse_eq_id : (reverse : CliffordAlgebra Q →ₗ[ℝ] _) = LinearMap.id 
goal: CliffordAlgebra.reverse = LinearMap.id

full_name: CliffordAlgebraComplex.ofComplex_conj
code: /-- `Complex.conj` is analogous to `CliffordAlgebra.involute`. -/
@[simp]
theorem ofComplex_conj (c : ℂ) : ofComplex (conj c) = involute (ofComplex c) 
goal: CliffordAlgebraComplex.ofComplex ((starRingEnd ℂ) c) = CliffordAlgebra.involute (CliffordAlgebraComplex.ofComplex c)

full_name: CliffordAlgebraQuaternion.Q
code: /-- `Q c₁ c₂` is a quadratic form over `R × R` such that `CliffordAlgebra (Q c₁ c₂)` is isomorphic
as an `R`-algebra to `ℍ[R,c₁,c₂]`. -/
def Q : QuadraticForm R (R × R) 
goal: QuadraticForm R (R × R)

full_name: CliffordAlgebraQuaternion.Q_apply
code: @[simp]
theorem Q_apply (v : R × R) : Q c₁ c₂ v = c₁ * (v.1 * v.1) + c₂ * (v.2 * v.2) 
goal: (CliffordAlgebraQuaternion.Q c₁ c₂) v = c₁ * (v.1 * v.1) + c₂ * (v.2 * v.2)

full_name: CliffordAlgebraQuaternion.quaternionBasis
code: /-- The quaternion basis vectors within the algebra. -/
@[simps i j k]
def quaternionBasis : QuaternionAlgebra.Basis (CliffordAlgebra (Q c₁ c₂)) c₁ c₂ 
goal: QuaternionAlgebra.Basis (CliffordAlgebra (CliffordAlgebraQuaternion.Q c₁ c₂)) c₁ c₂

full_name: CliffordAlgebraQuaternion.quaternionBasis_i
code: /-- The quaternion basis vectors within the algebra. -/
@[simps i j k]
def quaternionBasis : QuaternionAlgebra.Basis (CliffordAlgebra (Q c₁ c₂)) c₁ c₂ 
goal: (CliffordAlgebraQuaternion.quaternionBasis c₁ c₂).i = (CliffordAlgebra.ι (CliffordAlgebraQuaternion.Q c₁ c₂)) (1, 0)

full_name: CliffordAlgebraQuaternion.quaternionBasis_j
code: /-- The quaternion basis vectors within the algebra. -/
@[simps i j k]
def quaternionBasis : QuaternionAlgebra.Basis (CliffordAlgebra (Q c₁ c₂)) c₁ c₂ 
goal: (CliffordAlgebraQuaternion.quaternionBasis c₁ c₂).j = (CliffordAlgebra.ι (CliffordAlgebraQuaternion.Q c₁ c₂)) (0, 1)

full_name: CliffordAlgebraQuaternion.quaternionBasis_k
code: /-- The quaternion basis vectors within the algebra. -/
@[simps i j k]
def quaternionBasis : QuaternionAlgebra.Basis (CliffordAlgebra (Q c₁ c₂)) c₁ c₂ 
goal: (CliffordAlgebraQuaternion.quaternionBasis c₁ c₂).k =
  (CliffordAlgebra.ι (CliffordAlgebraQuaternion.Q c₁ c₂)) (1, 0) *
    (CliffordAlgebra.ι (CliffordAlgebraQuaternion.Q c₁ c₂)) (0, 1)

full_name: CliffordAlgebraQuaternion.toQuaternion
code: /-- Intermediate result of `CliffordAlgebraQuaternion.equiv`: clifford algebras over
`CliffordAlgebraQuaternion.Q` can be converted to `ℍ[R,c₁,c₂]`. -/
def toQuaternion : CliffordAlgebra (Q c₁ c₂) →ₐ[R] ℍ[R,c₁,c₂] 
goal: CliffordAlgebra (CliffordAlgebraQuaternion.Q c₁ c₂) →ₐ[R] QuaternionAlgebra R c₁ c₂

full_name: CliffordAlgebraQuaternion.toQuaternion_ι
code: @[simp]
theorem toQuaternion_ι (v : R × R) :
    toQuaternion (ι (Q c₁ c₂) v) = (⟨0, v.1, v.2, 0⟩ : ℍ[R,c₁,c₂]) 
goal: CliffordAlgebraQuaternion.toQuaternion ((CliffordAlgebra.ι (CliffordAlgebraQuaternion.Q c₁ c₂)) v) =
  { re := 0, imI := v.1, imJ := v.2, imK := 0 }

full_name: CliffordAlgebraQuaternion.toQuaternion_star
code: /-- The "clifford conjugate" maps to the quaternion conjugate. -/
theorem toQuaternion_star (c : CliffordAlgebra (Q c₁ c₂)) :
    toQuaternion (star c) = star (toQuaternion c) 
goal: CliffordAlgebraQuaternion.toQuaternion (star c) = star (CliffordAlgebraQuaternion.toQuaternion c)

full_name: CliffordAlgebraQuaternion.ofQuaternion
code: /-- Map a quaternion into the clifford algebra. -/
def ofQuaternion : ℍ[R,c₁,c₂] →ₐ[R] CliffordAlgebra (Q c₁ c₂) 
goal: QuaternionAlgebra R c₁ c₂ →ₐ[R] CliffordAlgebra (CliffordAlgebraQuaternion.Q c₁ c₂)

full_name: CliffordAlgebraQuaternion.ofQuaternion_mk
code: @[simp]
theorem ofQuaternion_mk (a₁ a₂ a₃ a₄ : R) :
    ofQuaternion (⟨a₁, a₂, a₃, a₄⟩ : ℍ[R,c₁,c₂]) =
      algebraMap R _ a₁ + a₂ • ι (Q c₁ c₂) (1, 0) + a₃ • ι (Q c₁ c₂) (0, 1) +
        a₄ • (ι (Q c₁ c₂) (1, 0) * ι (Q c₁ c₂) (0, 1)) 
goal: CliffordAlgebraQuaternion.ofQuaternion { re := a₁, imI := a₂, imJ := a₃, imK := a₄ } =
  (algebraMap R (CliffordAlgebra (CliffordAlgebraQuaternion.Q c₁ c₂))) a₁ +
        a₂ • (CliffordAlgebra.ι (CliffordAlgebraQuaternion.Q c₁ c₂)) (1, 0) +
      a₃ • (CliffordAlgebra.ι (CliffordAlgebraQuaternion.Q c₁ c₂)) (0, 1) +
    a₄ •
      ((CliffordAlgebra.ι (CliffordAlgebraQuaternion.Q c₁ c₂)) (1, 0) *
        (CliffordAlgebra.ι (CliffordAlgebraQuaternion.Q c₁ c₂)) (0, 1))

full_name: CliffordAlgebraQuaternion.ofQuaternion_comp_toQuaternion
code: @[simp]
theorem ofQuaternion_comp_toQuaternion :
    ofQuaternion.comp toQuaternion = AlgHom.id R (CliffordAlgebra (Q c₁ c₂)) 
goal: CliffordAlgebraQuaternion.ofQuaternion.comp CliffordAlgebraQuaternion.toQuaternion =
  AlgHom.id R (CliffordAlgebra (CliffordAlgebraQuaternion.Q c₁ c₂))

full_name: CliffordAlgebraQuaternion.ofQuaternion_toQuaternion
code: @[simp]
theorem ofQuaternion_toQuaternion (c : CliffordAlgebra (Q c₁ c₂)) :
    ofQuaternion (toQuaternion c) = c 
goal: CliffordAlgebraQuaternion.ofQuaternion (CliffordAlgebraQuaternion.toQuaternion c) = c

full_name: CliffordAlgebraQuaternion.toQuaternion_comp_ofQuaternion
code: @[simp]
theorem toQuaternion_comp_ofQuaternion :
    toQuaternion.comp ofQuaternion = AlgHom.id R ℍ[R,c₁,c₂] 
goal: CliffordAlgebraQuaternion.toQuaternion.comp CliffordAlgebraQuaternion.ofQuaternion =
  AlgHom.id R (QuaternionAlgebra R c₁ c₂)

full_name: CliffordAlgebraQuaternion.toQuaternion_ofQuaternion
code: @[simp]
theorem toQuaternion_ofQuaternion (q : ℍ[R,c₁,c₂]) : toQuaternion (ofQuaternion q) = q 
goal: CliffordAlgebraQuaternion.toQuaternion (CliffordAlgebraQuaternion.ofQuaternion q) = q

full_name: CliffordAlgebraQuaternion.equiv_apply
code: /-- The clifford algebra over `CliffordAlgebraQuaternion.Q c₁ c₂` is isomorphic as an `R`-algebra
to `ℍ[R,c₁,c₂]`. -/
@[simps!]
protected def equiv : CliffordAlgebra (Q c₁ c₂) ≃ₐ[R] ℍ[R,c₁,c₂] 
goal: CliffordAlgebraQuaternion.equiv a = CliffordAlgebraQuaternion.toQuaternion a

full_name: CliffordAlgebraQuaternion.equiv
code: /-- The clifford algebra over `CliffordAlgebraQuaternion.Q c₁ c₂` is isomorphic as an `R`-algebra
to `ℍ[R,c₁,c₂]`. -/
@[simps!]
protected def equiv : CliffordAlgebra (Q c₁ c₂) ≃ₐ[R] ℍ[R,c₁,c₂] 
goal: CliffordAlgebra (CliffordAlgebraQuaternion.Q c₁ c₂) ≃ₐ[R] QuaternionAlgebra R c₁ c₂

full_name: CliffordAlgebraQuaternion.equiv_symm_apply
code: /-- The clifford algebra over `CliffordAlgebraQuaternion.Q c₁ c₂` is isomorphic as an `R`-algebra
to `ℍ[R,c₁,c₂]`. -/
@[simps!]
protected def equiv : CliffordAlgebra (Q c₁ c₂) ≃ₐ[R] ℍ[R,c₁,c₂] 
goal: CliffordAlgebraQuaternion.equiv.symm a = CliffordAlgebraQuaternion.ofQuaternion a

full_name: CliffordAlgebraQuaternion.ofQuaternion_star
code: /-- The quaternion conjugate maps to the "clifford conjugate" (aka `star`). -/
@[simp]
theorem ofQuaternion_star (q : ℍ[R,c₁,c₂]) : ofQuaternion (star q) = star (ofQuaternion q) 
goal: CliffordAlgebraQuaternion.ofQuaternion (star q) = star (CliffordAlgebraQuaternion.ofQuaternion q)

full_name: CliffordAlgebraDualNumber.ι_mul_ι
code: theorem ι_mul_ι (r₁ r₂) : ι (0 : QuadraticForm R R) r₁ * ι (0 : QuadraticForm R R) r₂ = 0 
goal: (CliffordAlgebra.ι 0) r₁ * (CliffordAlgebra.ι 0) r₂ = 0

full_name: CliffordAlgebraDualNumber.equiv
code: /-- The clifford algebra over a 1-dimensional vector space with 0 quadratic form is isomorphic to
the dual numbers. -/
protected def equiv : CliffordAlgebra (0 : QuadraticForm R R) ≃ₐ[R] R[ε] 
goal: CliffordAlgebra 0 ≃ₐ[R] DualNumber R

full_name: CliffordAlgebraDualNumber.equiv_ι
code: @[simp]
theorem equiv_ι (r : R) : CliffordAlgebraDualNumber.equiv (ι (R := R) _ r) = r • ε 
goal: CliffordAlgebraDualNumber.equiv ((CliffordAlgebra.ι 0) r) = r • DualNumber.eps

full_name: CliffordAlgebraDualNumber.equiv_symm_eps
code: @[simp]
theorem equiv_symm_eps :
    CliffordAlgebraDualNumber.equiv.symm (eps : R[ε]) = ι (0 : QuadraticForm R R) 1 
goal: CliffordAlgebraDualNumber.equiv.symm DualNumber.eps = (CliffordAlgebra.ι 0) 1