File: Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean

full_name: CliffordAlgebra.involute
code: /-- Grade involution, inverting the sign of each basis vector. -/
def involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q 
goal: CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q

full_name: CliffordAlgebra.involute_ι
code: @[simp]
theorem involute_ι (m : M) : involute (ι Q m) = -ι Q m 
goal: CliffordAlgebra.involute ((CliffordAlgebra.ι Q) m) = -(CliffordAlgebra.ι Q) m

full_name: CliffordAlgebra.involute_comp_involute
code: @[simp]
theorem involute_comp_involute : involute.comp involute = AlgHom.id R (CliffordAlgebra Q) 
goal: CliffordAlgebra.involute.comp CliffordAlgebra.involute = AlgHom.id R (CliffordAlgebra Q)

full_name: CliffordAlgebra.involute_involutive
code: theorem involute_involutive : Function.Involutive (involute : _ → CliffordAlgebra Q) 
goal: Function.Involutive ⇑CliffordAlgebra.involute

full_name: CliffordAlgebra.involute_involute
code: @[simp]
theorem involute_involute : ∀ a : CliffordAlgebra Q, involute (involute a) = a 
goal: CliffordAlgebra.involute (CliffordAlgebra.involute a) = a

full_name: CliffordAlgebra.involuteEquiv_apply
code: /-- `CliffordAlgebra.involute` as an `AlgEquiv`. -/
@[simps!]
def involuteEquiv : CliffordAlgebra Q ≃ₐ[R] CliffordAlgebra Q 
goal: CliffordAlgebra.involuteEquiv a = CliffordAlgebra.involute a

full_name: CliffordAlgebra.involuteEquiv
code: /-- `CliffordAlgebra.involute` as an `AlgEquiv`. -/
@[simps!]
def involuteEquiv : CliffordAlgebra Q ≃ₐ[R] CliffordAlgebra Q 
goal: CliffordAlgebra Q ≃ₐ[R] CliffordAlgebra Q

full_name: CliffordAlgebra.involuteEquiv_symm_apply
code: /-- `CliffordAlgebra.involute` as an `AlgEquiv`. -/
@[simps!]
def involuteEquiv : CliffordAlgebra Q ≃ₐ[R] CliffordAlgebra Q 
goal: CliffordAlgebra.involuteEquiv.symm a = CliffordAlgebra.involute a

full_name: CliffordAlgebra.reverseOp
code: /-- `CliffordAlgebra.reverse` as an `AlgHom` to the opposite algebra -/
def reverseOp : CliffordAlgebra Q →ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ 
goal: CliffordAlgebra Q →ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ

full_name: CliffordAlgebra.reverseOp_ι
code: @[simp]
theorem reverseOp_ι (m : M) : reverseOp (ι Q m) = op (ι Q m) 
goal: CliffordAlgebra.reverseOp ((CliffordAlgebra.ι Q) m) = MulOpposite.op ((CliffordAlgebra.ι Q) m)

full_name: CliffordAlgebra.reverseOpEquiv
code: /-- `CliffordAlgebra.reverseEquiv` as an `AlgEquiv` to the opposite algebra -/
@[simps! apply]
def reverseOpEquiv : CliffordAlgebra Q ≃ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ 
goal: CliffordAlgebra Q ≃ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ

full_name: CliffordAlgebra.reverseOpEquiv_apply
code: /-- `CliffordAlgebra.reverseEquiv` as an `AlgEquiv` to the opposite algebra -/
@[simps! apply]
def reverseOpEquiv : CliffordAlgebra Q ≃ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ 
goal: CliffordAlgebra.reverseOpEquiv a = CliffordAlgebra.reverseOp a

full_name: CliffordAlgebra.reverseOpEquiv_opComm
code: @[simp]
theorem reverseOpEquiv_opComm :
    AlgEquiv.opComm (reverseOpEquiv (Q := Q)) = reverseOpEquiv.symm 
goal: AlgEquiv.opComm CliffordAlgebra.reverseOpEquiv = CliffordAlgebra.reverseOpEquiv.symm

full_name: CliffordAlgebra.reverse
code: /-- Grade reversion, inverting the multiplication order of basis vectors.
Also called *transpose* in some literature. -/
def reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q 
goal: CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q

full_name: CliffordAlgebra.unop_reverseOp
code: @[simp] theorem unop_reverseOp (x : CliffordAlgebra Q) : (reverseOp x).unop = reverse x 
goal: MulOpposite.unop (CliffordAlgebra.reverseOp x) = CliffordAlgebra.reverse x

full_name: CliffordAlgebra.op_reverse
code: @[simp] theorem op_reverse (x : CliffordAlgebra Q) : op (reverse x) = reverseOp x 
goal: MulOpposite.op (CliffordAlgebra.reverse x) = CliffordAlgebra.reverseOp x

full_name: CliffordAlgebra.reverse_ι
code: @[simp]
theorem reverse_ι (m : M) : reverse (ι Q m) = ι Q m 
goal: CliffordAlgebra.reverse ((CliffordAlgebra.ι Q) m) = (CliffordAlgebra.ι Q) m

full_name: CliffordAlgebra.reverse.commutes
code: @[simp]
theorem reverse.commutes (r : R) :
    reverse (algebraMap R (CliffordAlgebra Q) r) = algebraMap R _ r 
goal: CliffordAlgebra.reverse ((algebraMap R (CliffordAlgebra Q)) r) = (algebraMap R (CliffordAlgebra Q)) r

full_name: CliffordAlgebra.reverse.map_one
code: @[simp]
theorem reverse.map_one : reverse (1 : CliffordAlgebra Q) = 1 
goal: CliffordAlgebra.reverse 1 = 1

full_name: CliffordAlgebra.reverse.map_mul
code: @[simp]
theorem reverse.map_mul (a b : CliffordAlgebra Q) :
    reverse (a * b) = reverse b * reverse a 
goal: CliffordAlgebra.reverse (a * b) = CliffordAlgebra.reverse b * CliffordAlgebra.reverse a

full_name: CliffordAlgebra.reverse_involutive
code: @[simp]
theorem reverse_involutive : Function.Involutive (reverse (Q := Q)) 
goal: Function.Involutive ⇑CliffordAlgebra.reverse

full_name: CliffordAlgebra.reverse_comp_reverse
code: @[simp]
theorem reverse_comp_reverse :
    reverse.comp reverse = (LinearMap.id : _ →ₗ[R] CliffordAlgebra Q) 
goal: CliffordAlgebra.reverse ∘ₗ CliffordAlgebra.reverse = LinearMap.id

full_name: CliffordAlgebra.reverse_reverse
code: @[simp]
theorem reverse_reverse : ∀ a : CliffordAlgebra Q, reverse (reverse a) = a 
goal: CliffordAlgebra.reverse (CliffordAlgebra.reverse a) = a

full_name: CliffordAlgebra.reverseEquiv_apply
code: /-- `CliffordAlgebra.reverse` as a `LinearEquiv`. -/
@[simps!]
def reverseEquiv : CliffordAlgebra Q ≃ₗ[R] CliffordAlgebra Q 
goal: ∀ (a : CliffordAlgebra Q), CliffordAlgebra.reverseEquiv a = CliffordAlgebra.reverse a

full_name: CliffordAlgebra.reverseEquiv
code: /-- `CliffordAlgebra.reverse` as a `LinearEquiv`. -/
@[simps!]
def reverseEquiv : CliffordAlgebra Q ≃ₗ[R] CliffordAlgebra Q 
goal: CliffordAlgebra Q ≃ₗ[R] CliffordAlgebra Q

full_name: CliffordAlgebra.reverseEquiv_symm_apply
code: /-- `CliffordAlgebra.reverse` as a `LinearEquiv`. -/
@[simps!]
def reverseEquiv : CliffordAlgebra Q ≃ₗ[R] CliffordAlgebra Q 
goal: ∀ (a : CliffordAlgebra Q), CliffordAlgebra.reverseEquiv.symm a = CliffordAlgebra.reverse a

full_name: CliffordAlgebra.reverse_comp_involute
code: theorem reverse_comp_involute :
    reverse.comp involute.toLinearMap =
      (involute.toLinearMap.comp reverse : _ →ₗ[R] CliffordAlgebra Q) 
goal: CliffordAlgebra.reverse ∘ₗ CliffordAlgebra.involute.toLinearMap =
  CliffordAlgebra.involute.toLinearMap ∘ₗ CliffordAlgebra.reverse

full_name: CliffordAlgebra.reverse_involute_commute
code: /-- `CliffordAlgebra.reverse` and `CliffordAlgebra.involute` commute. Note that the composition
is sometimes referred to as the "clifford conjugate". -/
theorem reverse_involute_commute : Function.Commute (reverse (Q := Q)) involute 
goal: Function.Commute ⇑CliffordAlgebra.reverse ⇑CliffordAlgebra.involute

full_name: CliffordAlgebra.reverse_involute
code: theorem reverse_involute :
    ∀ a : CliffordAlgebra Q, reverse (involute a) = involute (reverse a) 
goal: CliffordAlgebra.reverse (CliffordAlgebra.involute a) = CliffordAlgebra.involute (CliffordAlgebra.reverse a)

full_name: CliffordAlgebra.reverse_prod_map_ι
code: /-- Taking the reverse of the product a list of $n$ vectors lifted via `ι` is equivalent to
taking the product of the reverse of that list. -/
theorem reverse_prod_map_ι :
    ∀ l : List M, reverse (l.map <| ι Q).prod = (l.map <| ι Q).reverse.prod
  
goal: CliffordAlgebra.reverse (List.map (⇑(CliffordAlgebra.ι Q)) l).prod = (List.map (⇑(CliffordAlgebra.ι Q)) l).reverse.prod

full_name: CliffordAlgebra.involute_prod_map_ι
code: /-- Taking the involute of the product a list of $n$ vectors lifted via `ι` is equivalent to
premultiplying by ${-1}^n$. -/
theorem involute_prod_map_ι :
    ∀ l : List M, involute (l.map <| ι Q).prod = (-1 : R) ^ l.length • (l.map <| ι Q).prod
  
goal: CliffordAlgebra.involute (List.map (⇑(CliffordAlgebra.ι Q)) l).prod =
  (-1) ^ l.length • (List.map (⇑(CliffordAlgebra.ι Q)) l).prod

full_name: CliffordAlgebra.submodule_map_involute_eq_comap
code: theorem submodule_map_involute_eq_comap (p : Submodule R (CliffordAlgebra Q)) :
    p.map (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
      p.comap (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap 
goal: Submodule.map CliffordAlgebra.involute.toLinearMap p = Submodule.comap CliffordAlgebra.involute.toLinearMap p

full_name: CliffordAlgebra.ι_range_map_involute
code: @[simp]
theorem ι_range_map_involute :
    (ι Q).range.map (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
      LinearMap.range (ι Q) 
goal: Submodule.map CliffordAlgebra.involute.toLinearMap (LinearMap.range (CliffordAlgebra.ι Q)) =
  LinearMap.range (CliffordAlgebra.ι Q)

full_name: CliffordAlgebra.ι_range_comap_involute
code: @[simp]
theorem ι_range_comap_involute :
    (ι Q).range.comap (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
      LinearMap.range (ι Q) 
goal: Submodule.comap CliffordAlgebra.involute.toLinearMap (LinearMap.range (CliffordAlgebra.ι Q)) =
  LinearMap.range (CliffordAlgebra.ι Q)

full_name: CliffordAlgebra.evenOdd_map_involute
code: @[simp]
theorem evenOdd_map_involute (n : ZMod 2) :
    (evenOdd Q n).map (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
      evenOdd Q n 
goal: Submodule.map CliffordAlgebra.involute.toLinearMap (CliffordAlgebra.evenOdd Q n) = CliffordAlgebra.evenOdd Q n

full_name: CliffordAlgebra.evenOdd_comap_involute
code: @[simp]
theorem evenOdd_comap_involute (n : ZMod 2) :
    (evenOdd Q n).comap (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
      evenOdd Q n 
goal: Submodule.comap CliffordAlgebra.involute.toLinearMap (CliffordAlgebra.evenOdd Q n) = CliffordAlgebra.evenOdd Q n

full_name: CliffordAlgebra.submodule_map_reverse_eq_comap
code: theorem submodule_map_reverse_eq_comap (p : Submodule R (CliffordAlgebra Q)) :
    p.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) =
      p.comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) 
goal: Submodule.map CliffordAlgebra.reverse p = Submodule.comap CliffordAlgebra.reverse p

full_name: CliffordAlgebra.ι_range_map_reverse
code: @[simp]
theorem ι_range_map_reverse :
    (ι Q).range.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q)
      = LinearMap.range (ι Q) 
goal: Submodule.map CliffordAlgebra.reverse (LinearMap.range (CliffordAlgebra.ι Q)) = LinearMap.range (CliffordAlgebra.ι Q)

full_name: CliffordAlgebra.ι_range_comap_reverse
code: @[simp]
theorem ι_range_comap_reverse :
    (ι Q).range.comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q)
      = LinearMap.range (ι Q) 
goal: Submodule.comap CliffordAlgebra.reverse (LinearMap.range (CliffordAlgebra.ι Q)) = LinearMap.range (CliffordAlgebra.ι Q)

full_name: CliffordAlgebra.submodule_map_mul_reverse
code: /-- Like `Submodule.map_mul`, but with the multiplication reversed. -/
theorem submodule_map_mul_reverse (p q : Submodule R (CliffordAlgebra Q)) :
    (p * q).map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) =
      q.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) *
        p.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) 
goal: Submodule.map CliffordAlgebra.reverse (p * q) =
  Submodule.map CliffordAlgebra.reverse q * Submodule.map CliffordAlgebra.reverse p

full_name: CliffordAlgebra.submodule_comap_mul_reverse
code: theorem submodule_comap_mul_reverse (p q : Submodule R (CliffordAlgebra Q)) :
    (p * q).comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) =
      q.comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) *
        p.comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) 
goal: Submodule.comap CliffordAlgebra.reverse (p * q) =
  Submodule.comap CliffordAlgebra.reverse q * Submodule.comap CliffordAlgebra.reverse p

full_name: CliffordAlgebra.submodule_map_pow_reverse
code: /-- Like `Submodule.map_pow` -/
theorem submodule_map_pow_reverse (p : Submodule R (CliffordAlgebra Q)) (n : ℕ) :
    (p ^ n).map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) =
      p.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) ^ n 
goal: Submodule.map CliffordAlgebra.reverse (p ^ n) = Submodule.map CliffordAlgebra.reverse p ^ n

full_name: CliffordAlgebra.submodule_comap_pow_reverse
code: theorem submodule_comap_pow_reverse (p : Submodule R (CliffordAlgebra Q)) (n : ℕ) :
    (p ^ n).comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) =
      p.comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) ^ n 
goal: Submodule.comap CliffordAlgebra.reverse (p ^ n) = Submodule.comap CliffordAlgebra.reverse p ^ n

full_name: CliffordAlgebra.evenOdd_map_reverse
code: @[simp]
theorem evenOdd_map_reverse (n : ZMod 2) :
    (evenOdd Q n).map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) = evenOdd Q n 
goal: Submodule.map CliffordAlgebra.reverse (CliffordAlgebra.evenOdd Q n) = CliffordAlgebra.evenOdd Q n

full_name: CliffordAlgebra.evenOdd_comap_reverse
code: @[simp]
theorem evenOdd_comap_reverse (n : ZMod 2) :
    (evenOdd Q n).comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) = evenOdd Q n 
goal: Submodule.comap CliffordAlgebra.reverse (CliffordAlgebra.evenOdd Q n) = CliffordAlgebra.evenOdd Q n

full_name: CliffordAlgebra.involute_mem_evenOdd_iff
code: @[simp]
theorem involute_mem_evenOdd_iff {x : CliffordAlgebra Q} {n : ZMod 2} :
    involute x ∈ evenOdd Q n ↔ x ∈ evenOdd Q n 
goal: CliffordAlgebra.involute x ∈ CliffordAlgebra.evenOdd Q n ↔ x ∈ CliffordAlgebra.evenOdd Q n

full_name: CliffordAlgebra.reverse_mem_evenOdd_iff
code: @[simp]
theorem reverse_mem_evenOdd_iff {x : CliffordAlgebra Q} {n : ZMod 2} :
    reverse x ∈ evenOdd Q n ↔ x ∈ evenOdd Q n 
goal: CliffordAlgebra.reverse x ∈ CliffordAlgebra.evenOdd Q n ↔ x ∈ CliffordAlgebra.evenOdd Q n

full_name: CliffordAlgebra.involute_eq_of_mem_even
code: theorem involute_eq_of_mem_even {x : CliffordAlgebra Q} (h : x ∈ evenOdd Q 0) : involute x = x 
goal: CliffordAlgebra.involute x = x

full_name: CliffordAlgebra.involute_eq_of_mem_odd
code: theorem involute_eq_of_mem_odd {x : CliffordAlgebra Q} (h : x ∈ evenOdd Q 1) : involute x = -x 
goal: CliffordAlgebra.involute x = -x