linear_algebra.clifford_algebra.conjugation

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

34020e53

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

fdc286cc

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2020 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
-import Mathbin.LinearAlgebra.CliffordAlgebra.Grading
-import Mathbin.Algebra.Module.Opposites
+import LinearAlgebra.CliffordAlgebra.Grading
+import Algebra.Module.Opposites
 
 #align_import linear_algebra.clifford_algebra.conjugation from "leanprover-community/mathlib"@"fdc286cc6967a012f41b87f76dcd2797b53152af"

fdc286cc

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module linear_algebra.clifford_algebra.conjugation
-! leanprover-community/mathlib commit fdc286cc6967a012f41b87f76dcd2797b53152af
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.LinearAlgebra.CliffordAlgebra.Grading
 import Mathbin.Algebra.Module.Opposites
 
+#align_import linear_algebra.clifford_algebra.conjugation from "leanprover-community/mathlib"@"fdc286cc6967a012f41b87f76dcd2797b53152af"
+
 /-!
 # Conjugations

fdc286cc

bump to nightly-2023-06-25-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/fdc286cc6967a012f41b87f76dcd2797b53152af

097db3c1

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 
 ! This file was ported from Lean 3 source module linear_algebra.clifford_algebra.conjugation
-! leanprover-community/mathlib commit 34020e531ebc4e8aac6d449d9eecbcd1508ea8d0
+! leanprover-community/mathlib commit fdc286cc6967a012f41b87f76dcd2797b53152af
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Algebra.Module.Opposites
 /-!
 # Conjugations
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file defines the grade reversal and grade involution functions on multivectors, `reverse` and
 `involute`.
 Together, these operations compose to form the "Clifford conjugate", hence the name of this file.

34020e53

bump to nightly-2023-06-23-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/d30d31261cdb4d2f5e612eabc3c4bf45556350d5

f333abb9

Diff

@@ -46,36 +46,48 @@ namespace CliffordAlgebra
 
 section Involute
 
+#print CliffordAlgebra.involute /-
 /-- Grade involution, inverting the sign of each basis vector. -/
 def involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q :=
   CliffordAlgebra.lift Q ⟨-ι Q, fun m => by simp⟩
 #align clifford_algebra.involute CliffordAlgebra.involute
+-/
 
+#print CliffordAlgebra.involute_ι /-
 @[simp]
 theorem involute_ι (m : M) : involute (ι Q m) = -ι Q m :=
   lift_ι_apply _ _ m
 #align clifford_algebra.involute_ι CliffordAlgebra.involute_ι
+-/
 
+#print CliffordAlgebra.involute_comp_involute /-
 @[simp]
 theorem involute_comp_involute : involute.comp involute = AlgHom.id R (CliffordAlgebra Q) := by ext;
   simp
 #align clifford_algebra.involute_comp_involute CliffordAlgebra.involute_comp_involute
+-/
 
+#print CliffordAlgebra.involute_involutive /-
 theorem involute_involutive : Function.Involutive (involute : _ → CliffordAlgebra Q) :=
   AlgHom.congr_fun involute_comp_involute
 #align clifford_algebra.involute_involutive CliffordAlgebra.involute_involutive
+-/
 
+#print CliffordAlgebra.involute_involute /-
 @[simp]
 theorem involute_involute : ∀ a : CliffordAlgebra Q, involute (involute a) = a :=
   involute_involutive
 #align clifford_algebra.involute_involute CliffordAlgebra.involute_involute
+-/
 
+#print CliffordAlgebra.involuteEquiv /-
 /-- `clifford_algebra.involute` as an `alg_equiv`. -/
 @[simps]
 def involuteEquiv : CliffordAlgebra Q ≃ₐ[R] CliffordAlgebra Q :=
   AlgEquiv.ofAlgHom involute involute (AlgHom.ext <| involute_involute)
     (AlgHom.ext <| involute_involute)
 #align clifford_algebra.involute_equiv CliffordAlgebra.involuteEquiv
+-/
 
 end Involute
 
@@ -83,6 +95,7 @@ section Reverse
 
 open MulOpposite
 
+#print CliffordAlgebra.reverse /-
 /-- Grade reversion, inverting the multiplication order of basis vectors.
 Also called *transpose* in some literature. -/
 def reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q :=
@@ -91,26 +104,36 @@ def reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q :=
         ⟨(MulOpposite.opLinearEquiv R).toLinearMap.comp (ι Q), fun m =>
           unop_injective <| by simp⟩).toLinearMap
 #align clifford_algebra.reverse CliffordAlgebra.reverse
+-/
 
+#print CliffordAlgebra.reverse_ι /-
 @[simp]
 theorem reverse_ι (m : M) : reverse (ι Q m) = ι Q m := by simp [reverse]
 #align clifford_algebra.reverse_ι CliffordAlgebra.reverse_ι
+-/
 
+#print CliffordAlgebra.reverse.commutes /-
 @[simp]
 theorem reverse.commutes (r : R) :
     reverse (algebraMap R (CliffordAlgebra Q) r) = algebraMap R _ r := by simp [reverse]
 #align clifford_algebra.reverse.commutes CliffordAlgebra.reverse.commutes
+-/
 
+#print CliffordAlgebra.reverse.map_one /-
 @[simp]
 theorem reverse.map_one : reverse (1 : CliffordAlgebra Q) = 1 := by
   convert reverse.commutes (1 : R) <;> simp
 #align clifford_algebra.reverse.map_one CliffordAlgebra.reverse.map_one
+-/
 
+#print CliffordAlgebra.reverse.map_mul /-
 @[simp]
 theorem reverse.map_mul (a b : CliffordAlgebra Q) : reverse (a * b) = reverse b * reverse a := by
   simp [reverse]
 #align clifford_algebra.reverse.map_mul CliffordAlgebra.reverse.map_mul
+-/
 
+#print CliffordAlgebra.reverse_comp_reverse /-
 @[simp]
 theorem reverse_comp_reverse : reverse.comp reverse = (LinearMap.id : _ →ₗ[R] CliffordAlgebra Q) :=
   by
@@ -123,23 +146,31 @@ theorem reverse_comp_reverse : reverse.comp reverse = (LinearMap.id : _ →ₗ[R
   case h_mul a b ha hb => rw [reverse.map_mul, reverse.map_mul, ha, hb]
   case h_add a b ha hb => rw [reverse.map_add, reverse.map_add, ha, hb]
 #align clifford_algebra.reverse_comp_reverse CliffordAlgebra.reverse_comp_reverse
+-/
 
+#print CliffordAlgebra.reverse_involutive /-
 @[simp]
 theorem reverse_involutive : Function.Involutive (reverse : _ → CliffordAlgebra Q) :=
   LinearMap.congr_fun reverse_comp_reverse
 #align clifford_algebra.reverse_involutive CliffordAlgebra.reverse_involutive
+-/
 
+#print CliffordAlgebra.reverse_reverse /-
 @[simp]
 theorem reverse_reverse : ∀ a : CliffordAlgebra Q, reverse (reverse a) = a :=
   reverse_involutive
 #align clifford_algebra.reverse_reverse CliffordAlgebra.reverse_reverse
+-/
 
+#print CliffordAlgebra.reverseEquiv /-
 /-- `clifford_algebra.reverse` as a `linear_equiv`. -/
 @[simps]
 def reverseEquiv : CliffordAlgebra Q ≃ₗ[R] CliffordAlgebra Q :=
   LinearEquiv.ofInvolutive reverse reverse_involutive
 #align clifford_algebra.reverse_equiv CliffordAlgebra.reverseEquiv
+-/
 
+#print CliffordAlgebra.reverse_comp_involute /-
 theorem reverse_comp_involute :
     reverse.comp involute.toLinearMap =
       (involute.toLinearMap.comp reverse : _ →ₗ[R] CliffordAlgebra Q) :=
@@ -152,16 +183,21 @@ theorem reverse_comp_involute :
   case h_mul a b ha hb => simp only [ha, hb, reverse.map_mul, AlgHom.map_mul]
   case h_add a b ha hb => simp only [ha, hb, reverse.map_add, AlgHom.map_add]
 #align clifford_algebra.reverse_comp_involute CliffordAlgebra.reverse_comp_involute
+-/
 
+#print CliffordAlgebra.reverse_involute_commute /-
 /-- `clifford_algebra.reverse` and `clifford_algebra.inverse` commute. Note that the composition
 is sometimes referred to as the "clifford conjugate". -/
 theorem reverse_involute_commute : Function.Commute (reverse : _ → CliffordAlgebra Q) involute :=
   LinearMap.congr_fun reverse_comp_involute
 #align clifford_algebra.reverse_involute_commute CliffordAlgebra.reverse_involute_commute
+-/
 
+#print CliffordAlgebra.reverse_involute /-
 theorem reverse_involute : ∀ a : CliffordAlgebra Q, reverse (involute a) = involute (reverse a) :=
   reverse_involute_commute
 #align clifford_algebra.reverse_involute CliffordAlgebra.reverse_involute
+-/
 
 end Reverse
 
@@ -173,14 +209,17 @@ end Reverse
 section List
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print CliffordAlgebra.reverse_prod_map_ι /-
 /-- 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
   | [] => by simp
   | x::xs => by simp [reverse_prod_map_ι xs]
 #align clifford_algebra.reverse_prod_map_ι CliffordAlgebra.reverse_prod_map_ι
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print CliffordAlgebra.involute_prod_map_ι /-
 /-- Taking the involute of the product a list of $n$ vectors lifted via `ι` is equivalent to
 premultiplying by ${-1}^n$. -/
 theorem involute_prod_map_ι :
@@ -188,6 +227,7 @@ theorem involute_prod_map_ι :
   | [] => by simp
   | x::xs => by simp [pow_add, involute_prod_map_ι xs]
 #align clifford_algebra.involute_prod_map_ι CliffordAlgebra.involute_prod_map_ι
+-/
 
 end List
 
@@ -202,50 +242,63 @@ variable (Q)
 
 section Involute
 
+#print CliffordAlgebra.submodule_map_involute_eq_comap /-
 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 :=
   Submodule.map_equiv_eq_comap_symm involuteEquiv.toLinearEquiv _
 #align clifford_algebra.submodule_map_involute_eq_comap CliffordAlgebra.submodule_map_involute_eq_comap
+-/
 
+#print CliffordAlgebra.ι_range_map_involute /-
 @[simp]
 theorem ι_range_map_involute :
     (ι Q).range.map (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
       (ι Q).range :=
   (ι_range_map_lift _ _).trans (LinearMap.range_neg _)
 #align clifford_algebra.ι_range_map_involute CliffordAlgebra.ι_range_map_involute
+-/
 
+#print CliffordAlgebra.ι_range_comap_involute /-
 @[simp]
 theorem ι_range_comap_involute :
     (ι Q).range.comap (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
       (ι Q).range :=
   by rw [← submodule_map_involute_eq_comap, ι_range_map_involute]
 #align clifford_algebra.ι_range_comap_involute CliffordAlgebra.ι_range_comap_involute
+-/
 
+#print CliffordAlgebra.evenOdd_map_involute /-
 @[simp]
 theorem evenOdd_map_involute (n : ZMod 2) :
     (evenOdd Q n).map (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
       evenOdd Q n :=
   by simp_rw [even_odd, Submodule.map_iSup, Submodule.map_pow, ι_range_map_involute]
 #align clifford_algebra.even_odd_map_involute CliffordAlgebra.evenOdd_map_involute
+-/
 
+#print CliffordAlgebra.evenOdd_comap_involute /-
 @[simp]
 theorem evenOdd_comap_involute (n : ZMod 2) :
     (evenOdd Q n).comap (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
       evenOdd Q n :=
   by rw [← submodule_map_involute_eq_comap, even_odd_map_involute]
 #align clifford_algebra.even_odd_comap_involute CliffordAlgebra.evenOdd_comap_involute
+-/
 
 end Involute
 
 section Reverse
 
+#print CliffordAlgebra.submodule_map_reverse_eq_comap /-
 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) :=
   Submodule.map_equiv_eq_comap_symm (reverseEquiv : _ ≃ₗ[R] _) _
 #align clifford_algebra.submodule_map_reverse_eq_comap CliffordAlgebra.submodule_map_reverse_eq_comap
+-/
 
+#print CliffordAlgebra.ι_range_map_reverse /-
 @[simp]
 theorem ι_range_map_reverse :
     (ι Q).range.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) = (ι Q).range :=
@@ -253,13 +306,17 @@ theorem ι_range_map_reverse :
   rw [reverse, Submodule.map_comp, ι_range_map_lift, LinearMap.range_comp, ← Submodule.map_comp]
   exact Submodule.map_id _
 #align clifford_algebra.ι_range_map_reverse CliffordAlgebra.ι_range_map_reverse
+-/
 
+#print CliffordAlgebra.ι_range_comap_reverse /-
 @[simp]
 theorem ι_range_comap_reverse :
     (ι Q).range.comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) = (ι Q).range := by
   rw [← submodule_map_reverse_eq_comap, ι_range_map_reverse]
 #align clifford_algebra.ι_range_comap_reverse CliffordAlgebra.ι_range_comap_reverse
+-/
 
+#print CliffordAlgebra.submodule_map_mul_reverse /-
 /-- 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) =
@@ -269,14 +326,18 @@ theorem submodule_map_mul_reverse (p q : Submodule R (CliffordAlgebra Q)) :
   simp_rw [reverse, Submodule.map_comp, LinearEquiv.toLinearMap_eq_coe, Submodule.map_mul,
     Submodule.map_unop_mul]
 #align clifford_algebra.submodule_map_mul_reverse CliffordAlgebra.submodule_map_mul_reverse
+-/
 
+#print CliffordAlgebra.submodule_comap_mul_reverse /-
 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) :=
   by simp_rw [← submodule_map_reverse_eq_comap, submodule_map_mul_reverse]
 #align clifford_algebra.submodule_comap_mul_reverse CliffordAlgebra.submodule_comap_mul_reverse
+-/
 
+#print CliffordAlgebra.submodule_map_pow_reverse /-
 /-- Like `submodule.map_pow` -/
 theorem submodule_map_pow_reverse (p : Submodule R (CliffordAlgebra Q)) (n : ℕ) :
     (p ^ n).map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) =
@@ -285,38 +346,49 @@ theorem submodule_map_pow_reverse (p : Submodule R (CliffordAlgebra Q)) (n : ℕ
   simp_rw [reverse, Submodule.map_comp, LinearEquiv.toLinearMap_eq_coe, Submodule.map_pow,
     Submodule.map_unop_pow]
 #align clifford_algebra.submodule_map_pow_reverse CliffordAlgebra.submodule_map_pow_reverse
+-/
 
+#print CliffordAlgebra.submodule_comap_pow_reverse /-
 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 :=
   by simp_rw [← submodule_map_reverse_eq_comap, submodule_map_pow_reverse]
 #align clifford_algebra.submodule_comap_pow_reverse CliffordAlgebra.submodule_comap_pow_reverse
+-/
 
+#print CliffordAlgebra.evenOdd_map_reverse /-
 @[simp]
 theorem evenOdd_map_reverse (n : ZMod 2) :
     (evenOdd Q n).map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) = evenOdd Q n := by
   simp_rw [even_odd, Submodule.map_iSup, submodule_map_pow_reverse, ι_range_map_reverse]
 #align clifford_algebra.even_odd_map_reverse CliffordAlgebra.evenOdd_map_reverse
+-/
 
+#print CliffordAlgebra.evenOdd_comap_reverse /-
 @[simp]
 theorem evenOdd_comap_reverse (n : ZMod 2) :
     (evenOdd Q n).comap (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) = evenOdd Q n := by
   rw [← submodule_map_reverse_eq_comap, even_odd_map_reverse]
 #align clifford_algebra.even_odd_comap_reverse CliffordAlgebra.evenOdd_comap_reverse
+-/
 
 end Reverse
 
+#print CliffordAlgebra.involute_mem_evenOdd_iff /-
 @[simp]
 theorem involute_mem_evenOdd_iff {x : CliffordAlgebra Q} {n : ZMod 2} :
     involute x ∈ evenOdd Q n ↔ x ∈ evenOdd Q n :=
   SetLike.ext_iff.mp (evenOdd_comap_involute Q n) x
 #align clifford_algebra.involute_mem_even_odd_iff CliffordAlgebra.involute_mem_evenOdd_iff
+-/
 
+#print CliffordAlgebra.reverse_mem_evenOdd_iff /-
 @[simp]
 theorem reverse_mem_evenOdd_iff {x : CliffordAlgebra Q} {n : ZMod 2} :
     reverse x ∈ evenOdd Q n ↔ x ∈ evenOdd Q n :=
   SetLike.ext_iff.mp (evenOdd_comap_reverse Q n) x
 #align clifford_algebra.reverse_mem_even_odd_iff CliffordAlgebra.reverse_mem_evenOdd_iff
+-/
 
 end Submodule
 
@@ -327,6 +399,7 @@ TODO: show that these are `iff`s when `invertible (2 : R)`.
 -/
 
 
+#print CliffordAlgebra.involute_eq_of_mem_even /-
 theorem involute_eq_of_mem_even {x : CliffordAlgebra Q} (h : x ∈ evenOdd Q 0) : involute x = x :=
   by
   refine' even_induction Q (AlgHom.commutes _) _ _ x h
@@ -335,7 +408,9 @@ theorem involute_eq_of_mem_even {x : CliffordAlgebra Q} (h : x ∈ evenOdd Q 0)
   · intro m₁ m₂ x hx ihx
     rw [map_mul, map_mul, involute_ι, involute_ι, ihx, neg_mul_neg]
 #align clifford_algebra.involute_eq_of_mem_even CliffordAlgebra.involute_eq_of_mem_even
+-/
 
+#print CliffordAlgebra.involute_eq_of_mem_odd /-
 theorem involute_eq_of_mem_odd {x : CliffordAlgebra Q} (h : x ∈ evenOdd Q 1) : involute x = -x :=
   by
   refine' odd_induction Q involute_ι _ _ x h
@@ -344,6 +419,7 @@ theorem involute_eq_of_mem_odd {x : CliffordAlgebra Q} (h : x ∈ evenOdd Q 1) :
   · intro m₁ m₂ x hx ihx
     rw [map_mul, map_mul, involute_ι, involute_ι, ihx, neg_mul_neg, mul_neg]
 #align clifford_algebra.involute_eq_of_mem_odd CliffordAlgebra.involute_eq_of_mem_odd
+-/
 
 end CliffordAlgebra

34020e53

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -57,9 +57,7 @@ theorem involute_ι (m : M) : involute (ι Q m) = -ι Q m :=
 #align clifford_algebra.involute_ι CliffordAlgebra.involute_ι
 
 @[simp]
-theorem involute_comp_involute : involute.comp involute = AlgHom.id R (CliffordAlgebra Q) :=
-  by
-  ext
+theorem involute_comp_involute : involute.comp involute = AlgHom.id R (CliffordAlgebra Q) := by ext;
   simp
 #align clifford_algebra.involute_comp_involute CliffordAlgebra.involute_comp_involute

34020e53

bump to nightly-2023-05-14-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

d31da313

Diff

@@ -228,7 +228,7 @@ theorem ι_range_comap_involute :
 theorem evenOdd_map_involute (n : ZMod 2) :
     (evenOdd Q n).map (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
       evenOdd Q n :=
-  by simp_rw [even_odd, Submodule.map_supᵢ, Submodule.map_pow, ι_range_map_involute]
+  by simp_rw [even_odd, Submodule.map_iSup, Submodule.map_pow, ι_range_map_involute]
 #align clifford_algebra.even_odd_map_involute CliffordAlgebra.evenOdd_map_involute
 
 @[simp]
@@ -297,7 +297,7 @@ theorem submodule_comap_pow_reverse (p : Submodule R (CliffordAlgebra Q)) (n : 
 @[simp]
 theorem evenOdd_map_reverse (n : ZMod 2) :
     (evenOdd Q n).map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) = evenOdd Q n := by
-  simp_rw [even_odd, Submodule.map_supᵢ, submodule_map_pow_reverse, ι_range_map_reverse]
+  simp_rw [even_odd, Submodule.map_iSup, submodule_map_pow_reverse, ι_range_map_reverse]
 #align clifford_algebra.even_odd_map_reverse CliffordAlgebra.evenOdd_map_reverse
 
 @[simp]

34020e53

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

34020e53

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -34,9 +34,7 @@ https://en.wikipedia.org/wiki/Clifford_algebra#Antiautomorphisms
 
 
 variable {R : Type*} [CommRing R]
-
 variable {M : Type*} [AddCommGroup M] [Module R M]
-
 variable {Q : QuadraticForm R M}
 
 namespace CliffordAlgebra

34020e53

chore: rename induction principle arguments around CliffordAlgebra (#10908)

In order to improve the ergonomics of the induction tactic, this renames the arguments of:

ExteriorAlgebra.induction
TensorAlgebra.induction
CliffordAlgebra.induction
CliffordAlgebra.left_induction
CliffordAlgebra.right_induction
CliffordAlgebra.even_induction
CliffordAlgebra.odd_induction
Submodule.iSup_induction'
Submodule.pow_induction_on_left'
Submodule.pow_induction_on_right'

This is slightly awkward for name-resolution within these induction principles, as the argument names end up clashing with the function they are about. Thankfully, this pain is not transferred to the caller using induction _ using _.

0257770c

Diff

@@ -157,10 +157,10 @@ theorem reverse_comp_involute :
   ext x
   simp only [LinearMap.comp_apply, AlgHom.toLinearMap_apply]
   induction x using CliffordAlgebra.induction with
-  | h_grade0 => simp
-  | h_grade1 => simp
-  | h_mul a b ha hb => simp only [ha, hb, reverse.map_mul, AlgHom.map_mul]
-  | h_add a b ha hb => simp only [ha, hb, reverse.map_add, AlgHom.map_add]
+  | algebraMap => simp
+  | ι => simp
+  | mul a b ha hb => simp only [ha, hb, reverse.map_mul, AlgHom.map_mul]
+  | add a b ha hb => simp only [ha, hb, reverse.map_add, AlgHom.map_add]
 #align clifford_algebra.reverse_comp_involute CliffordAlgebra.reverse_comp_involute
 
 /-- `CliffordAlgebra.reverse` and `CliffordAlgebra.involute` commute. Note that the composition
@@ -336,18 +336,20 @@ TODO: show that these are `iff`s when `Invertible (2 : R)`.
 
 
 theorem involute_eq_of_mem_even {x : CliffordAlgebra Q} (h : x ∈ evenOdd Q 0) : involute x = x := by
-  refine' even_induction Q (AlgHom.commutes _) _ _ x h
-  · rintro x y _hx _hy ihx ihy
+  induction x, h using even_induction with
+  | algebraMap r => exact AlgHom.commutes _ _
+  | add x y _hx _hy ihx ihy =>
     rw [map_add, ihx, ihy]
-  · intro m₁ m₂ x _hx ihx
+  | ι_mul_ι_mul m₁ m₂ x _hx ihx =>
     rw [map_mul, map_mul, involute_ι, involute_ι, ihx, neg_mul_neg]
 #align clifford_algebra.involute_eq_of_mem_even CliffordAlgebra.involute_eq_of_mem_even
 
 theorem involute_eq_of_mem_odd {x : CliffordAlgebra Q} (h : x ∈ evenOdd Q 1) : involute x = -x := by
-  refine' odd_induction Q involute_ι _ _ x h
-  · rintro x y _hx _hy ihx ihy
+  induction x, h using odd_induction with
+  | ι m => exact involute_ι _
+  | add x y _hx _hy ihx ihy =>
     rw [map_add, ihx, ihy, neg_add]
-  · intro m₁ m₂ x _hx ihx
+  | ι_mul_ι_mul m₁ m₂ x _hx ihx =>
     rw [map_mul, map_mul, involute_ι, involute_ι, ihx, neg_mul_neg, mul_neg]
 #align clifford_algebra.involute_eq_of_mem_odd CliffordAlgebra.involute_eq_of_mem_odd

34020e53

chore(*): drop $/<| before fun (#9361)

Subset of #9319

3694e27d

Diff

@@ -92,8 +92,8 @@ theorem reverseOp_ι (m : M) : reverseOp (ι Q m) = op (ι Q m) := lift_ι_apply
 @[simps! apply]
 def reverseOpEquiv : CliffordAlgebra Q ≃ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ :=
   AlgEquiv.ofAlgHom reverseOp (AlgHom.opComm reverseOp)
-    (AlgHom.unop.injective <| hom_ext <| LinearMap.ext <| fun _ => by simp)
-    (hom_ext <| LinearMap.ext <| fun _ => by simp)
+    (AlgHom.unop.injective <| hom_ext <| LinearMap.ext fun _ => by simp)
+    (hom_ext <| LinearMap.ext fun _ => by simp)
 
 @[simp]
 theorem reverseOpEquiv_opComm :

34020e53

style: use cases x with | ... instead of cases x; case => ... (#9321)

This converts usages of the pattern

cases h
case inl h' => ...
case inr h' => ...

which derive from mathported code, to the "structured cases" syntax:

cases h with
| inl h' => ...
| inr h' => ...

The case where the subgoals are handled with · instead of case is more contentious (and much more numerous) so I left those alone. This pattern also appears with cases', induction, induction', and rcases. Furthermore, there is a similar transformation for by_cases:

by_cases h : cond
case pos => ...
case neg => ...

is replaced by:

if h : cond then
  ...
else
  ...

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

e04a464d

Diff

@@ -156,11 +156,11 @@ theorem reverse_comp_involute :
       (involute.toLinearMap.comp reverse : _ →ₗ[R] CliffordAlgebra Q) := by
   ext x
   simp only [LinearMap.comp_apply, AlgHom.toLinearMap_apply]
-  induction x using CliffordAlgebra.induction
-  case h_grade0 => simp
-  case h_grade1 => simp
-  case h_mul a b ha hb => simp only [ha, hb, reverse.map_mul, AlgHom.map_mul]
-  case h_add a b ha hb => simp only [ha, hb, reverse.map_add, AlgHom.map_add]
+  induction x using CliffordAlgebra.induction with
+  | h_grade0 => simp
+  | h_grade1 => simp
+  | h_mul a b ha hb => simp only [ha, hb, reverse.map_mul, AlgHom.map_mul]
+  | h_add a b ha hb => simp only [ha, hb, reverse.map_add, AlgHom.map_add]
 #align clifford_algebra.reverse_comp_involute CliffordAlgebra.reverse_comp_involute
 
 /-- `CliffordAlgebra.reverse` and `CliffordAlgebra.involute` commute. Note that the composition

34020e53

chore: fix some cases in names (#7469)

And fix some names in comments where this revealed issues

be0d066c

Diff

@@ -163,7 +163,7 @@ theorem reverse_comp_involute :
   case h_add a b ha hb => simp only [ha, hb, reverse.map_add, AlgHom.map_add]
 #align clifford_algebra.reverse_comp_involute CliffordAlgebra.reverse_comp_involute
 
-/-- `CliffordAlgebra.reverse` and `clifford_algebra.inverse` commute. Note that the composition
+/-- `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 :=
   LinearMap.congr_fun reverse_comp_involute

34020e53

chore: only four spaces for subsequent lines (#7286)

Co-authored-by: Moritz Firsching <firsching@google.com>

0c7d6fa5

Diff

@@ -97,7 +97,7 @@ def reverseOpEquiv : CliffordAlgebra Q ≃ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ :=
 
 @[simp]
 theorem reverseOpEquiv_opComm :
-  AlgEquiv.opComm (reverseOpEquiv (Q := Q)) = reverseOpEquiv.symm := rfl
+    AlgEquiv.opComm (reverseOpEquiv (Q := Q)) = reverseOpEquiv.symm := rfl
 
 /-- Grade reversion, inverting the multiplication order of basis vectors.
 Also called *transpose* in some literature. -/

34020e53

refactor(LinearAlgebra/CliffordAlgebra/Conjugation): expose implementation details of 'reverse' (#6783)

Having the fully-bundled AlgHom (to MulOpposite) is occasionally useful for building larger AlgHoms, especially if the MulOpposite can be cancelled out later.

686be169

Diff

@@ -80,54 +80,66 @@ section Reverse
 
 open MulOpposite
 
+/-- `CliffordAlgebra.reverse` as an `AlgHom` to the opposite algebra -/
+def reverseOp : CliffordAlgebra Q →ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ :=
+  CliffordAlgebra.lift Q
+    ⟨(MulOpposite.opLinearEquiv R).toLinearMap ∘ₗ ι Q, fun m => unop_injective <| by simp⟩
+
+@[simp]
+theorem reverseOp_ι (m : M) : reverseOp (ι Q m) = op (ι Q m) := lift_ι_apply _ _ _
+
+/-- `CliffordAlgebra.reverseEquiv` as an `AlgEquiv` to the opposite algebra -/
+@[simps! apply]
+def reverseOpEquiv : CliffordAlgebra Q ≃ₐ[R] (CliffordAlgebra Q)ᵐᵒᵖ :=
+  AlgEquiv.ofAlgHom reverseOp (AlgHom.opComm reverseOp)
+    (AlgHom.unop.injective <| hom_ext <| LinearMap.ext <| fun _ => by simp)
+    (hom_ext <| LinearMap.ext <| fun _ => by simp)
+
+@[simp]
+theorem reverseOpEquiv_opComm :
+  AlgEquiv.opComm (reverseOpEquiv (Q := Q)) = reverseOpEquiv.symm := rfl
+
 /-- Grade reversion, inverting the multiplication order of basis vectors.
 Also called *transpose* in some literature. -/
 def reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q :=
-  (opLinearEquiv R).symm.toLinearMap.comp
-    (CliffordAlgebra.lift Q
-        ⟨(MulOpposite.opLinearEquiv R).toLinearMap.comp (ι Q), fun m =>
-          unop_injective <| by simp⟩).toLinearMap
+  (opLinearEquiv R).symm.toLinearMap.comp reverseOp.toLinearMap
 #align clifford_algebra.reverse CliffordAlgebra.reverse
 
+@[simp] theorem unop_reverseOp (x : CliffordAlgebra Q) : (reverseOp x).unop = reverse x := rfl
+
+@[simp] theorem op_reverse (x : CliffordAlgebra Q) : op (reverse x) = reverseOp x := rfl
+
 @[simp]
 theorem reverse_ι (m : M) : reverse (ι Q m) = ι Q m := by simp [reverse]
 #align clifford_algebra.reverse_ι CliffordAlgebra.reverse_ι
 
 @[simp]
 theorem reverse.commutes (r : R) :
-    reverse (algebraMap R (CliffordAlgebra Q) r) = algebraMap R _ r := by simp [reverse]
+    reverse (algebraMap R (CliffordAlgebra Q) r) = algebraMap R _ r :=
+  op_injective <| reverseOp.commutes r
 #align clifford_algebra.reverse.commutes CliffordAlgebra.reverse.commutes
 
 @[simp]
-theorem reverse.map_one : reverse (1 : CliffordAlgebra Q) = 1 := by
-  convert reverse.commutes (Q := Q) (1 : R) <;> simp
+theorem reverse.map_one : reverse (1 : CliffordAlgebra Q) = 1 :=
+  op_injective reverseOp.map_one
 #align clifford_algebra.reverse.map_one CliffordAlgebra.reverse.map_one
 
 @[simp]
 theorem reverse.map_mul (a b : CliffordAlgebra Q) :
-  -- porting note: can't infer `Q`
-  reverse (a * b) = reverse b * reverse a := by
-  simp [reverse]
+    reverse (a * b) = reverse b * reverse a :=
+  op_injective (reverseOp.map_mul a b)
 #align clifford_algebra.reverse.map_mul CliffordAlgebra.reverse.map_mul
 
-@[simp]
-theorem reverse_comp_reverse :
-    reverse.comp reverse = (LinearMap.id : _ →ₗ[R] CliffordAlgebra Q) := by
-  ext m
-  simp only [LinearMap.id_apply, LinearMap.comp_apply]
-  induction m using CliffordAlgebra.induction
-  -- simp can close these goals, but is slow
-  case h_grade0 => rw [reverse.commutes, reverse.commutes]
-  case h_grade1 => rw [reverse_ι, reverse_ι]
-  case h_mul a b ha hb => rw [reverse.map_mul, reverse.map_mul, ha, hb]
-  case h_add a b ha hb => rw [reverse.map_add, reverse.map_add, ha, hb]
-#align clifford_algebra.reverse_comp_reverse CliffordAlgebra.reverse_comp_reverse
-
 @[simp]
 theorem reverse_involutive : Function.Involutive (reverse (Q := Q)) :=
-  LinearMap.congr_fun reverse_comp_reverse
+  AlgHom.congr_fun reverseOpEquiv.symm_comp
 #align clifford_algebra.reverse_involutive CliffordAlgebra.reverse_involutive
 
+@[simp]
+theorem reverse_comp_reverse :
+    reverse.comp reverse = (LinearMap.id : _ →ₗ[R] CliffordAlgebra Q) :=
+  LinearMap.ext reverse_involutive
+
 @[simp]
 theorem reverse_reverse : ∀ a : CliffordAlgebra Q, reverse (reverse a) = a :=
   reverse_involutive
@@ -174,7 +186,6 @@ section List
 /-- 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_ι :
-  -- porting note: can't infer `Q`
     ∀ l : List M, reverse (l.map <| ι Q).prod = (l.map <| ι Q).reverse.prod
   | [] => by simp
   | x::xs => by simp [reverse_prod_map_ι xs]
@@ -249,7 +260,8 @@ theorem submodule_map_reverse_eq_comap (p : Submodule R (CliffordAlgebra Q)) :
 theorem ι_range_map_reverse :
     (ι Q).range.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q)
       = LinearMap.range (ι Q) := by
-  rw [reverse, Submodule.map_comp, ι_range_map_lift, LinearMap.range_comp, ← Submodule.map_comp]
+  rw [reverse, reverseOp, Submodule.map_comp, ι_range_map_lift, LinearMap.range_comp,
+    ← Submodule.map_comp]
   exact Submodule.map_id _
 #align clifford_algebra.ι_range_map_reverse CliffordAlgebra.ι_range_map_reverse
 
@@ -310,7 +322,6 @@ theorem involute_mem_evenOdd_iff {x : CliffordAlgebra Q} {n : ZMod 2} :
 
 @[simp]
 theorem reverse_mem_evenOdd_iff {x : CliffordAlgebra Q} {n : ZMod 2} :
-    -- porting note: cannot infer `Q`
     reverse x ∈ evenOdd Q n ↔ x ∈ evenOdd Q n :=
   SetLike.ext_iff.mp (evenOdd_comap_reverse Q n) x
 #align clifford_algebra.reverse_mem_even_odd_iff CliffordAlgebra.reverse_mem_evenOdd_iff

34020e53

chore(LinearAlgebra/CliffordAlgebra): remove Q := Q (#6780)

The removal of a FunLike instance for Module.Dual made these unnecessary.

ed9d5590

Diff

@@ -89,27 +89,24 @@ def reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q :=
           unop_injective <| by simp⟩).toLinearMap
 #align clifford_algebra.reverse CliffordAlgebra.reverse
 
--- porting note: can't infer `Q`
 @[simp]
-theorem reverse_ι (m : M) : reverse (Q := Q) (ι Q m) = ι Q m := by simp [reverse]
+theorem reverse_ι (m : M) : reverse (ι Q m) = ι Q m := by simp [reverse]
 #align clifford_algebra.reverse_ι CliffordAlgebra.reverse_ι
 
 @[simp]
 theorem reverse.commutes (r : R) :
-    -- porting note: can't infer `Q`
-    reverse (Q := Q) (algebraMap R (CliffordAlgebra Q) r) = algebraMap R _ r := by simp [reverse]
+    reverse (algebraMap R (CliffordAlgebra Q) r) = algebraMap R _ r := by simp [reverse]
 #align clifford_algebra.reverse.commutes CliffordAlgebra.reverse.commutes
 
--- porting note: can't infer `Q`
 @[simp]
-theorem reverse.map_one : reverse (Q := Q) (1 : CliffordAlgebra Q) = 1 := by
+theorem reverse.map_one : reverse (1 : CliffordAlgebra Q) = 1 := by
   convert reverse.commutes (Q := Q) (1 : R) <;> simp
 #align clifford_algebra.reverse.map_one CliffordAlgebra.reverse.map_one
 
 @[simp]
 theorem reverse.map_mul (a b : CliffordAlgebra Q) :
   -- porting note: can't infer `Q`
-  reverse (Q := Q) (a * b) = reverse (Q := Q) b * reverse (Q := Q) a := by
+  reverse (a * b) = reverse b * reverse a := by
   simp [reverse]
 #align clifford_algebra.reverse.map_mul CliffordAlgebra.reverse.map_mul
 
@@ -131,9 +128,8 @@ theorem reverse_involutive : Function.Involutive (reverse (Q := Q)) :=
   LinearMap.congr_fun reverse_comp_reverse
 #align clifford_algebra.reverse_involutive CliffordAlgebra.reverse_involutive
 
--- porting note: can't infer `Q`
 @[simp]
-theorem reverse_reverse : ∀ a : CliffordAlgebra Q, reverse (Q := Q) (reverse (Q := Q) a) = a :=
+theorem reverse_reverse : ∀ a : CliffordAlgebra Q, reverse (reverse a) = a :=
   reverse_involutive
 #align clifford_algebra.reverse_reverse CliffordAlgebra.reverse_reverse
 
@@ -162,8 +158,7 @@ theorem reverse_involute_commute : Function.Commute (reverse (Q := Q)) involute
 #align clifford_algebra.reverse_involute_commute CliffordAlgebra.reverse_involute_commute
 
 theorem reverse_involute :
-    -- porting note: can't infer `Q`
-    ∀ a : CliffordAlgebra Q, reverse (Q := Q) (involute a) = involute (reverse (Q := Q) a) :=
+    ∀ a : CliffordAlgebra Q, reverse (involute a) = involute (reverse a) :=
   reverse_involute_commute
 #align clifford_algebra.reverse_involute CliffordAlgebra.reverse_involute
 
@@ -180,7 +175,7 @@ section List
 taking the product of the reverse of that list. -/
 theorem reverse_prod_map_ι :
   -- porting note: can't infer `Q`
-    ∀ l : List M, reverse (Q := Q) (l.map <| ι Q).prod = (l.map <| ι Q).reverse.prod
+    ∀ l : List M, reverse (l.map <| ι Q).prod = (l.map <| ι Q).reverse.prod
   | [] => by simp
   | x::xs => by simp [reverse_prod_map_ι xs]
 #align clifford_algebra.reverse_prod_map_ι CliffordAlgebra.reverse_prod_map_ι
@@ -316,7 +311,7 @@ theorem involute_mem_evenOdd_iff {x : CliffordAlgebra Q} {n : ZMod 2} :
 @[simp]
 theorem reverse_mem_evenOdd_iff {x : CliffordAlgebra Q} {n : ZMod 2} :
     -- porting note: cannot infer `Q`
-    reverse (Q := Q) x ∈ evenOdd Q n ↔ x ∈ evenOdd Q n :=
+    reverse x ∈ evenOdd Q n ↔ x ∈ evenOdd Q n :=
   SetLike.ext_iff.mp (evenOdd_comap_reverse Q n) x
 #align clifford_algebra.reverse_mem_even_odd_iff CliffordAlgebra.reverse_mem_evenOdd_iff

34020e53

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -33,9 +33,9 @@ https://en.wikipedia.org/wiki/Clifford_algebra#Antiautomorphisms
 -/
 
 
-variable {R : Type _} [CommRing R]
+variable {R : Type*} [CommRing R]
 
-variable {M : Type _} [AddCommGroup M] [Module R M]
+variable {M : Type*} [AddCommGroup M] [Module R M]
 
 variable {Q : QuadraticForm R M}

34020e53

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2020 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module linear_algebra.clifford_algebra.conjugation
-! leanprover-community/mathlib commit 34020e531ebc4e8aac6d449d9eecbcd1508ea8d0
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.LinearAlgebra.CliffordAlgebra.Grading
 import Mathlib.Algebra.Module.Opposites
 
+#align_import linear_algebra.clifford_algebra.conjugation from "leanprover-community/mathlib"@"34020e531ebc4e8aac6d449d9eecbcd1508ea8d0"
+
 /-!
 # Conjugations

34020e53

feat: port LinearAlgebra.CliffordAlgebra.Conjugation (#5404)

Annoyingly, Lean 4 cannot work out that reverse x where x : clifford_algebra Q is referring to reverse (Q := Q) x, even though that's the only thing that type checks.

Otherwise the only difficulty when porting was the standard LinearMap.range dot notation failing thing.

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

ef690afb

`linear_algebra.clifford_algebra.conjugation` ⟷ `Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 640

linear_algebra.clifford_algebra.conjugation ⟷ Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 640

`linear_algebra.clifford_algebra.conjugation` ⟷ `Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation`