linear_algebra.clifford_algebra.fold | Mathlib porting status

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

446eb51c

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

30faa0c3

bump to nightly-2024-03-17-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

22f01ce4

Diff

@@ -179,7 +179,7 @@ theorem right_induction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (alg
     `clifford_algebra.induction`, but going via the grading seems easier. -/
   intro x
   have : x ∈ ⊤ := Submodule.mem_top
-  rw [← supr_ι_range_eq_top] at this 
+  rw [← supr_ι_range_eq_top] at this
   apply Submodule.iSup_induction _ this (fun i x hx => _) _ h_add
   · refine' Submodule.pow_induction_on_right _ hr h_add (fun x px m => _) hx
     rintro ⟨m, rfl⟩

30faa0c3

bump to nightly-2024-01-19-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

33b57512

Diff

@@ -119,7 +119,7 @@ def foldl (f : M →ₗ[R] N →ₗ[R] N) (hf : ∀ m x, f m (f m x) = Q m • x
 @[simp]
 theorem foldl_reverse (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (x : CliffordAlgebra Q) :
     foldl Q f hf n (reverse x) = foldr Q f hf n x :=
-  FunLike.congr_arg (foldr Q f hf n) <| reverse_reverse _
+  DFunLike.congr_arg (foldr Q f hf n) <| reverse_reverse _
 #align clifford_algebra.foldl_reverse CliffordAlgebra.foldl_reverse
 -/

30faa0c3

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2022 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
-import Mathbin.LinearAlgebra.CliffordAlgebra.Conjugation
+import LinearAlgebra.CliffordAlgebra.Conjugation
 
 #align_import linear_algebra.clifford_algebra.fold from "leanprover-community/mathlib"@"30faa0c3618ce1472bf6305ae0e3fa56affa3f95"

30faa0c3

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2022 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.fold
-! leanprover-community/mathlib commit 30faa0c3618ce1472bf6305ae0e3fa56affa3f95
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.LinearAlgebra.CliffordAlgebra.Conjugation
 
+#align_import linear_algebra.clifford_algebra.fold from "leanprover-community/mathlib"@"30faa0c3618ce1472bf6305ae0e3fa56affa3f95"
+
 /-!
 # Recursive computation rules for the Clifford algebra

30faa0c3

bump to nightly-2023-06-27-03

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

b5e0c440

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.fold
-! leanprover-community/mathlib commit 446eb51ce0a90f8385f260d2b52e760e2004246b
+! leanprover-community/mathlib commit 30faa0c3618ce1472bf6305ae0e3fa56affa3f95
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.LinearAlgebra.CliffordAlgebra.Conjugation
 /-!
 # Recursive computation rules for the Clifford algebra
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 This file provides API for a special case `clifford_algebra.foldr` of the universal property
 `clifford_algebra.lift` with `A = module.End R N` for some arbitrary module `N`. This specialization
 resembles the `list.foldr` operation, allowing a bilinear map to be "folded" along the generators.

446eb51c

bump to nightly-2023-06-24-15

mathlib commit https://github.com/leanprover-community/mathlib/commit/93f880918cb51905fd51b76add8273cbc27718ab

c1f77b96

Diff

@@ -48,6 +48,7 @@ namespace CliffordAlgebra
 
 section Foldr
 
+#print CliffordAlgebra.foldr /-
 /-- Fold a bilinear map along the generators of a term of the clifford algebra, with the rule
 given by `foldr Q f hf n (ι Q m * x) = f m (foldr Q f hf n x)`.
 
@@ -56,29 +57,39 @@ def foldr (f : M →ₗ[R] N →ₗ[R] N) (hf : ∀ m x, f m (f m x) = Q m • x
     N →ₗ[R] CliffordAlgebra Q →ₗ[R] N :=
   (CliffordAlgebra.lift Q ⟨f, fun v => LinearMap.ext <| hf v⟩).toLinearMap.flip
 #align clifford_algebra.foldr CliffordAlgebra.foldr
+-/
 
+#print CliffordAlgebra.foldr_ι /-
 @[simp]
 theorem foldr_ι (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (m : M) : foldr Q f hf n (ι Q m) = f m n :=
   LinearMap.congr_fun (lift_ι_apply _ _ _) n
 #align clifford_algebra.foldr_ι CliffordAlgebra.foldr_ι
+-/
 
+#print CliffordAlgebra.foldr_algebraMap /-
 @[simp]
 theorem foldr_algebraMap (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (r : R) :
     foldr Q f hf n (algebraMap R _ r) = r • n :=
   LinearMap.congr_fun (AlgHom.commutes _ r) n
 #align clifford_algebra.foldr_algebra_map CliffordAlgebra.foldr_algebraMap
+-/
 
+#print CliffordAlgebra.foldr_one /-
 @[simp]
 theorem foldr_one (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) : foldr Q f hf n 1 = n :=
   LinearMap.congr_fun (AlgHom.map_one _) n
 #align clifford_algebra.foldr_one CliffordAlgebra.foldr_one
+-/
 
+#print CliffordAlgebra.foldr_mul /-
 @[simp]
 theorem foldr_mul (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (a b : CliffordAlgebra Q) :
     foldr Q f hf n (a * b) = foldr Q f hf (foldr Q f hf n b) a :=
   LinearMap.congr_fun (AlgHom.map_mul _ _ _) n
 #align clifford_algebra.foldr_mul CliffordAlgebra.foldr_mul
+-/
 
+#print CliffordAlgebra.foldr_prod_map_ι /-
 /-- This lemma demonstrates the origin of the `foldr` name. -/
 theorem foldr_prod_map_ι (l : List M) (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) :
     foldr Q f hf n (l.map <| ι Q).Prod = List.foldr (fun m n => f m n) n l :=
@@ -87,11 +98,13 @@ theorem foldr_prod_map_ι (l : List M) (f : M →ₗ[R] N →ₗ[R] N) (hf) (n :
   · rw [List.map_nil, List.prod_nil, List.foldr_nil, foldr_one]
   · rw [List.map_cons, List.prod_cons, List.foldr_cons, foldr_mul, foldr_ι, ih]
 #align clifford_algebra.foldr_prod_map_ι CliffordAlgebra.foldr_prod_map_ι
+-/
 
 end Foldr
 
 section Foldl
 
+#print CliffordAlgebra.foldl /-
 /-- Fold a bilinear map along the generators of a term of the clifford algebra, with the rule
 given by `foldl Q f hf n (ι Q m * x) = f m (foldl Q f hf n x)`.
 
@@ -100,49 +113,65 @@ def foldl (f : M →ₗ[R] N →ₗ[R] N) (hf : ∀ m x, f m (f m x) = Q m • x
     N →ₗ[R] CliffordAlgebra Q →ₗ[R] N :=
   LinearMap.compl₂ (foldr Q f hf) reverse
 #align clifford_algebra.foldl CliffordAlgebra.foldl
+-/
 
+#print CliffordAlgebra.foldl_reverse /-
 @[simp]
 theorem foldl_reverse (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (x : CliffordAlgebra Q) :
     foldl Q f hf n (reverse x) = foldr Q f hf n x :=
   FunLike.congr_arg (foldr Q f hf n) <| reverse_reverse _
 #align clifford_algebra.foldl_reverse CliffordAlgebra.foldl_reverse
+-/
 
+#print CliffordAlgebra.foldr_reverse /-
 @[simp]
 theorem foldr_reverse (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (x : CliffordAlgebra Q) :
     foldr Q f hf n (reverse x) = foldl Q f hf n x :=
   rfl
 #align clifford_algebra.foldr_reverse CliffordAlgebra.foldr_reverse
+-/
 
+#print CliffordAlgebra.foldl_ι /-
 @[simp]
 theorem foldl_ι (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (m : M) : foldl Q f hf n (ι Q m) = f m n := by
   rw [← foldr_reverse, reverse_ι, foldr_ι]
 #align clifford_algebra.foldl_ι CliffordAlgebra.foldl_ι
+-/
 
+#print CliffordAlgebra.foldl_algebraMap /-
 @[simp]
 theorem foldl_algebraMap (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (r : R) :
     foldl Q f hf n (algebraMap R _ r) = r • n := by
   rw [← foldr_reverse, reverse.commutes, foldr_algebra_map]
 #align clifford_algebra.foldl_algebra_map CliffordAlgebra.foldl_algebraMap
+-/
 
+#print CliffordAlgebra.foldl_one /-
 @[simp]
 theorem foldl_one (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) : foldl Q f hf n 1 = n := by
   rw [← foldr_reverse, reverse.map_one, foldr_one]
 #align clifford_algebra.foldl_one CliffordAlgebra.foldl_one
+-/
 
+#print CliffordAlgebra.foldl_mul /-
 @[simp]
 theorem foldl_mul (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (a b : CliffordAlgebra Q) :
     foldl Q f hf n (a * b) = foldl Q f hf (foldl Q f hf n a) b := by
   rw [← foldr_reverse, ← foldr_reverse, ← foldr_reverse, reverse.map_mul, foldr_mul]
 #align clifford_algebra.foldl_mul CliffordAlgebra.foldl_mul
+-/
 
+#print CliffordAlgebra.foldl_prod_map_ι /-
 /-- This lemma demonstrates the origin of the `foldl` name. -/
 theorem foldl_prod_map_ι (l : List M) (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) :
     foldl Q f hf n (l.map <| ι Q).Prod = List.foldl (fun m n => f n m) n l := by
   rw [← foldr_reverse, reverse_prod_map_ι, ← List.map_reverse, foldr_prod_map_ι, List.foldr_reverse]
 #align clifford_algebra.foldl_prod_map_ι CliffordAlgebra.foldl_prod_map_ι
+-/
 
 end Foldl
 
+#print CliffordAlgebra.right_induction /-
 theorem right_induction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (algebraMap _ _ r))
     (h_add : ∀ x y, P x → P y → P (x + y)) (h_ι_mul : ∀ m x, P x → P (x * ι Q m)) : ∀ x, P x :=
   by
@@ -157,7 +186,9 @@ theorem right_induction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (alg
     exact h_ι_mul _ _ px
   · simpa only [map_zero] using hr 0
 #align clifford_algebra.right_induction CliffordAlgebra.right_induction
+-/
 
+#print CliffordAlgebra.left_induction /-
 theorem left_induction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (algebraMap _ _ r))
     (h_add : ∀ x y, P x → P y → P (x + y)) (h_mul_ι : ∀ x m, P x → P (ι Q m * x)) : ∀ x, P x :=
   by
@@ -168,10 +199,12 @@ theorem left_induction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (alge
   · simpa only [map_add] using h_add _ _ hx hy
   · simpa only [reverse.map_mul, reverse_ι] using h_mul_ι _ _ hx
 #align clifford_algebra.left_induction CliffordAlgebra.left_induction
+-/
 
 /-! ### Versions with extra state -/
 
 
+#print CliffordAlgebra.foldr'Aux /-
 /-- Auxiliary definition for `clifford_algebra.foldr'` -/
 def foldr'Aux (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N) :
     M →ₗ[R] Module.End R (CliffordAlgebra Q × N) :=
@@ -188,12 +221,16 @@ def foldr'Aux (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N) :
           Prod.ext (LinearMap.congr_fun (l.map_smul _ _) x)
             (LinearMap.congr_fun (f.map_smul _ _) x) }
 #align clifford_algebra.foldr'_aux CliffordAlgebra.foldr'Aux
+-/
 
+#print CliffordAlgebra.foldr'Aux_apply_apply /-
 theorem foldr'Aux_apply_apply (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N) (m : M) (x_fx) :
     foldr'Aux Q f m x_fx = (ι Q m * x_fx.1, f m x_fx) :=
   rfl
 #align clifford_algebra.foldr'_aux_apply_apply CliffordAlgebra.foldr'Aux_apply_apply
+-/
 
+#print CliffordAlgebra.foldr'Aux_foldr'Aux /-
 theorem foldr'Aux_foldr'Aux (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
     (hf : ∀ m x fx, f m (ι Q m * x, f m (x, fx)) = Q m • fx) (v : M) (x_fx) :
     foldr'Aux Q f v (foldr'Aux Q f v x_fx) = Q v • x_fx :=
@@ -202,7 +239,9 @@ theorem foldr'Aux_foldr'Aux (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
   simp only [foldr'_aux_apply_apply]
   rw [← mul_assoc, ι_sq_scalar, ← Algebra.smul_def, hf, Prod.smul_mk]
 #align clifford_algebra.foldr'_aux_foldr'_aux CliffordAlgebra.foldr'Aux_foldr'Aux
+-/
 
+#print CliffordAlgebra.foldr' /-
 /-- Fold a bilinear map along the generators of a term of the clifford algebra, with the rule
 given by `foldr' Q f hf n (ι Q m * x) = f m (x, foldr' Q f hf n x)`.
 Note this is like `clifford_algebra.foldr`, but with an extra `x` argument.
@@ -211,19 +250,25 @@ def foldr' (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
     (hf : ∀ m x fx, f m (ι Q m * x, f m (x, fx)) = Q m • fx) (n : N) : CliffordAlgebra Q →ₗ[R] N :=
   LinearMap.snd _ _ _ ∘ₗ foldr Q (foldr'Aux Q f) (foldr'Aux_foldr'Aux Q _ hf) (1, n)
 #align clifford_algebra.foldr' CliffordAlgebra.foldr'
+-/
 
+#print CliffordAlgebra.foldr'_algebraMap /-
 theorem foldr'_algebraMap (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
     (hf : ∀ m x fx, f m (ι Q m * x, f m (x, fx)) = Q m • fx) (n r) :
     foldr' Q f hf n (algebraMap R _ r) = r • n :=
   congr_arg Prod.snd (foldr_algebraMap _ _ _ _ _)
 #align clifford_algebra.foldr'_algebra_map CliffordAlgebra.foldr'_algebraMap
+-/
 
+#print CliffordAlgebra.foldr'_ι /-
 theorem foldr'_ι (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
     (hf : ∀ m x fx, f m (ι Q m * x, f m (x, fx)) = Q m • fx) (n m) :
     foldr' Q f hf n (ι Q m) = f m (1, n) :=
   congr_arg Prod.snd (foldr_ι _ _ _ _ _)
 #align clifford_algebra.foldr'_ι CliffordAlgebra.foldr'_ι
+-/
 
+#print CliffordAlgebra.foldr'_ι_mul /-
 theorem foldr'_ι_mul (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
     (hf : ∀ m x fx, f m (ι Q m * x, f m (x, fx)) = Q m • fx) (n m) (x) :
     foldr' Q f hf n (ι Q m * x) = f m (x, foldr' Q f hf n x) :=
@@ -237,6 +282,7 @@ theorem foldr'_ι_mul (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
   · rw [map_add, Prod.fst_add, hx, hy]
   · rw [foldr_mul, foldr_ι, foldr'_aux_apply_apply, hx]
 #align clifford_algebra.foldr'_ι_mul CliffordAlgebra.foldr'_ι_mul
+-/
 
 end CliffordAlgebra

446eb51c

bump to nightly-2023-06-05-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/13361559d66b84f80b6d5a1c4a26aa5054766725

43f0fba3

Diff

@@ -143,7 +143,7 @@ theorem foldl_prod_map_ι (l : List M) (f : M →ₗ[R] N →ₗ[R] N) (hf) (n :
 
 end Foldl
 
-theorem rightInduction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (algebraMap _ _ r))
+theorem right_induction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (algebraMap _ _ r))
     (h_add : ∀ x y, P x → P y → P (x + y)) (h_ι_mul : ∀ m x, P x → P (x * ι Q m)) : ∀ x, P x :=
   by
   /- It would be neat if we could prove this via `foldr` like how we prove
@@ -156,18 +156,18 @@ theorem rightInduction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (alge
     rintro ⟨m, rfl⟩
     exact h_ι_mul _ _ px
   · simpa only [map_zero] using hr 0
-#align clifford_algebra.right_induction CliffordAlgebra.rightInduction
+#align clifford_algebra.right_induction CliffordAlgebra.right_induction
 
-theorem leftInduction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (algebraMap _ _ r))
+theorem left_induction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (algebraMap _ _ r))
     (h_add : ∀ x y, P x → P y → P (x + y)) (h_mul_ι : ∀ x m, P x → P (ι Q m * x)) : ∀ x, P x :=
   by
   refine' reverse_involutive.surjective.forall.2 _
   intro x
-  induction' x using CliffordAlgebra.rightInduction with r x y hx hy m x hx
+  induction' x using CliffordAlgebra.right_induction with r x y hx hy m x hx
   · simpa only [reverse.commutes] using hr r
   · simpa only [map_add] using h_add _ _ hx hy
   · simpa only [reverse.map_mul, reverse_ι] using h_mul_ι _ _ hx
-#align clifford_algebra.left_induction CliffordAlgebra.leftInduction
+#align clifford_algebra.left_induction CliffordAlgebra.left_induction
 
 /-! ### Versions with extra state -/
 
@@ -232,7 +232,7 @@ theorem foldr'_ι_mul (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
   rw [foldr_mul, foldr_ι, foldr'_aux_apply_apply]
   refine' congr_arg (f m) (prod.mk.eta.symm.trans _)
   congr 1
-  induction' x using CliffordAlgebra.leftInduction with r x y hx hy m x hx
+  induction' x using CliffordAlgebra.left_induction with r x y hx hy m x hx
   · simp_rw [foldr_algebra_map, Prod.smul_mk, Algebra.algebraMap_eq_smul_one]
   · rw [map_add, Prod.fst_add, hx, hy]
   · rw [foldr_mul, foldr_ι, foldr'_aux_apply_apply, hx]

446eb51c

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -150,7 +150,7 @@ theorem rightInduction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (alge
     `clifford_algebra.induction`, but going via the grading seems easier. -/
   intro x
   have : x ∈ ⊤ := Submodule.mem_top
-  rw [← supr_ι_range_eq_top] at this
+  rw [← supr_ι_range_eq_top] at this 
   apply Submodule.iSup_induction _ this (fun i x hx => _) _ h_add
   · refine' Submodule.pow_induction_on_right _ hr h_add (fun x px m => _) hx
     rintro ⟨m, rfl⟩

446eb51c

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -151,7 +151,7 @@ theorem rightInduction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (alge
   intro x
   have : x ∈ ⊤ := Submodule.mem_top
   rw [← supr_ι_range_eq_top] at this
-  apply Submodule.supᵢ_induction _ this (fun i x hx => _) _ h_add
+  apply Submodule.iSup_induction _ this (fun i x hx => _) _ h_add
   · refine' Submodule.pow_induction_on_right _ hr h_add (fun x px m => _) hx
     rintro ⟨m, rfl⟩
     exact h_ι_mul _ _ px

446eb51c

bump to nightly-2023-04-25-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/2651125b48fc5c170ab1111afd0817c903b1fc6c

ed327085

Diff

@@ -176,7 +176,7 @@ theorem leftInduction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (algeb
 def foldr'Aux (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N) :
     M →ₗ[R] Module.End R (CliffordAlgebra Q × N) :=
   by
-  have v_mul := (LinearMap.Algebra.lmul R (CliffordAlgebra Q)).toLinearMap ∘ₗ ι Q
+  have v_mul := (Algebra.lmul R (CliffordAlgebra Q)).toLinearMap ∘ₗ ι Q
   have l := v_mul.compl₂ (LinearMap.fst _ _ N)
   exact
     { toFun := fun m => (l m).Prod (f m)

446eb51c

bump to nightly-2023-03-01-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

20cadee0

Diff

@@ -176,7 +176,7 @@ theorem leftInduction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (algeb
 def foldr'Aux (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N) :
     M →ₗ[R] Module.End R (CliffordAlgebra Q × N) :=
   by
-  have v_mul := (Algebra.lmul R (CliffordAlgebra Q)).toLinearMap ∘ₗ ι Q
+  have v_mul := (LinearMap.Algebra.lmul R (CliffordAlgebra Q)).toLinearMap ∘ₗ ι Q
   have l := v_mul.compl₂ (LinearMap.fst _ _ N)
   exact
     { toFun := fun m => (l m).Prod (f m)

446eb51c

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

446eb51c

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,11 +34,8 @@ For convenience, this file also provides `CliffordAlgebra.foldl`, implemented vi
 universe u1 u2 u3
 
 variable {R M N : Type*}
-
 variable [CommRing R] [AddCommGroup M] [AddCommGroup N]
-
 variable [Module R M] [Module R N]
-
 variable (Q : QuadraticForm R M)
 
 namespace CliffordAlgebra

446eb51c

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

@@ -139,34 +139,36 @@ theorem foldl_prod_map_ι (l : List M) (f : M →ₗ[R] N →ₗ[R] N) (hf) (n :
 
 end Foldl
 
-theorem right_induction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (algebraMap _ _ r))
-    (h_add : ∀ x y, P x → P y → P (x + y)) (h_ι_mul : ∀ m x, P x → P (x * ι Q m)) : ∀ x, P x := by
+@[elab_as_elim]
+theorem right_induction {P : CliffordAlgebra Q → Prop} (algebraMap : ∀ r : R, P (algebraMap _ _ r))
+    (add : ∀ x y, P x → P y → P (x + y)) (mul_ι : ∀ m x, P x → P (x * ι Q m)) : ∀ x, P x := by
   /- It would be neat if we could prove this via `foldr` like how we prove
     `CliffordAlgebra.induction`, but going via the grading seems easier. -/
   intro x
   have : x ∈ ⊤ := Submodule.mem_top (R := R)
   rw [← iSup_ι_range_eq_top] at this
-  induction this using Submodule.iSup_induction' with -- _ this (fun i x hx => ?_) _ h_add
-  | hp i x hx =>
+  induction this using Submodule.iSup_induction' with
+  | mem i x hx =>
     induction hx using Submodule.pow_induction_on_right' with
-    | hr r => exact hr r
-    | hadd _x _y _i _ _ ihx ihy => exact h_add _ _ ihx ihy
-    | hmul _i x _hx px m hm =>
+    | algebraMap r => exact algebraMap r
+    | add _x _y _i _ _ ihx ihy => exact add _ _ ihx ihy
+    | mul_mem _i x _hx px m hm =>
       obtain ⟨m, rfl⟩ := hm
-      exact h_ι_mul _ _ px
-  | h0 => simpa only [map_zero] using hr 0
-  | hadd _x _y _ _ ihx ihy =>
-    exact h_add _ _ ihx ihy
+      exact mul_ι _ _ px
+  | zero => simpa only [map_zero] using algebraMap 0
+  | add _x _y _ _ ihx ihy =>
+    exact add _ _ ihx ihy
 #align clifford_algebra.right_induction CliffordAlgebra.right_induction
 
-theorem left_induction {P : CliffordAlgebra Q → Prop} (hr : ∀ r : R, P (algebraMap _ _ r))
-    (h_add : ∀ x y, P x → P y → P (x + y)) (h_mul_ι : ∀ x m, P x → P (ι Q m * x)) : ∀ x, P x := by
+@[elab_as_elim]
+theorem left_induction {P : CliffordAlgebra Q → Prop} (algebraMap : ∀ r : R, P (algebraMap _ _ r))
+    (add : ∀ x y, P x → P y → P (x + y)) (ι_mul : ∀ x m, P x → P (ι Q m * x)) : ∀ x, P x := by
   refine' reverse_involutive.surjective.forall.2 _
   intro x
   induction' x using CliffordAlgebra.right_induction with r x y hx hy m x hx
-  · simpa only [reverse.commutes] using hr r
-  · simpa only [map_add] using h_add _ _ hx hy
-  · simpa only [reverse.map_mul, reverse_ι] using h_mul_ι _ _ hx
+  · simpa only [reverse.commutes] using algebraMap r
+  · simpa only [map_add] using add _ _ hx hy
+  · simpa only [reverse.map_mul, reverse_ι] using ι_mul _ _ hx
 #align clifford_algebra.left_induction CliffordAlgebra.left_induction
 
 /-! ### Versions with extra state -/
@@ -229,10 +231,10 @@ theorem foldr'_ι_mul (f : M →ₗ[R] CliffordAlgebra Q × N →ₗ[R] N)
   rw [foldr_mul, foldr_ι, foldr'Aux_apply_apply]
   refine' congr_arg (f m) (Prod.mk.eta.symm.trans _)
   congr 1
-  induction' x using CliffordAlgebra.left_induction with r x y hx hy m x hx
-  · simp_rw [foldr_algebraMap, Prod.smul_mk, Algebra.algebraMap_eq_smul_one]
-  · rw [map_add, Prod.fst_add, hx, hy]
-  · rw [foldr_mul, foldr_ι, foldr'Aux_apply_apply, hx]
+  induction x using CliffordAlgebra.left_induction with
+  | algebraMap r => simp_rw [foldr_algebraMap, Prod.smul_mk, Algebra.algebraMap_eq_smul_one]
+  | add x y hx hy => rw [map_add, Prod.fst_add, hx, hy]
+  | ι_mul m x hx => rw [foldr_mul, foldr_ι, foldr'Aux_apply_apply, hx]
 #align clifford_algebra.foldr'_ι_mul CliffordAlgebra.foldr'_ι_mul
 
 end CliffordAlgebra

446eb51c

chore(*): rename FunLike to DFunLike (#9785)

This prepares for the introduction of a non-dependent synonym of FunLike, which helps a lot with keeping #8386 readable.

This is entirely search-and-replace in 680197f combined with manual fixes in 4145626, e900597 and b8428f8. The commands that generated this change:

sed -i 's/\bFunLike\b/DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoFunLike\b/toDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/import Mathlib.Data.DFunLike/import Mathlib.Data.FunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bHom_FunLike\b/Hom_DFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean     
sed -i 's/\binstFunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\bfunLike\b/instDFunLike/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean
sed -i 's/\btoo many metavariables to apply `fun_like.has_coe_to_fun`/too many metavariables to apply `DFunLike.hasCoeToFun`/g' {Archive,Counterexamples,Mathlib,test}/**/*.lean

Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

82656743

Diff

@@ -100,7 +100,7 @@ def foldl (f : M →ₗ[R] N →ₗ[R] N) (hf : ∀ m x, f m (f m x) = Q m • x
 @[simp]
 theorem foldl_reverse (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (x : CliffordAlgebra Q) :
     foldl Q f hf n (reverse x) = foldr Q f hf n x :=
-  FunLike.congr_arg (foldr Q f hf n) <| reverse_reverse _
+  DFunLike.congr_arg (foldr Q f hf n) <| reverse_reverse _
 #align clifford_algebra.foldl_reverse CliffordAlgebra.foldl_reverse
 
 @[simp]

446eb51c

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

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

ed9d5590

Diff

@@ -99,15 +99,13 @@ def foldl (f : M →ₗ[R] N →ₗ[R] N) (hf : ∀ m x, f m (f m x) = Q m • x
 
 @[simp]
 theorem foldl_reverse (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (x : CliffordAlgebra Q) :
-    -- porting note: cannot infer `Q`
-    foldl Q f hf n (reverse (Q := Q) x) = foldr Q f hf n x :=
+    foldl Q f hf n (reverse x) = foldr Q f hf n x :=
   FunLike.congr_arg (foldr Q f hf n) <| reverse_reverse _
 #align clifford_algebra.foldl_reverse CliffordAlgebra.foldl_reverse
 
 @[simp]
 theorem foldr_reverse (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (x : CliffordAlgebra Q) :
-    -- porting note: cannot infer `Q`
-    foldr Q f hf n (reverse (Q := Q) x) = foldl Q f hf n x :=
+    foldr Q f hf n (reverse x) = foldl Q f hf n x :=
   rfl
 #align clifford_algebra.foldr_reverse CliffordAlgebra.foldr_reverse

446eb51c

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,7 +33,7 @@ For convenience, this file also provides `CliffordAlgebra.foldl`, implemented vi
 
 universe u1 u2 u3
 
-variable {R M N : Type _}
+variable {R M N : Type*}
 
 variable [CommRing R] [AddCommGroup M] [AddCommGroup N]

446eb51c

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,14 +2,11 @@
 Copyright (c) 2022 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.fold
-! leanprover-community/mathlib commit 446eb51ce0a90f8385f260d2b52e760e2004246b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation
 
+#align_import linear_algebra.clifford_algebra.fold from "leanprover-community/mathlib"@"446eb51ce0a90f8385f260d2b52e760e2004246b"
+
 /-!
 # Recursive computation rules for the Clifford algebra

446eb51c

feat: port LinearAlgebra.CliffordAlgebra.Fold (#5406)

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

8b9210ba

`linear_algebra.clifford_algebra.fold` ⟷ `Mathlib.LinearAlgebra.CliffordAlgebra.Fold`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 641

linear_algebra.clifford_algebra.fold ⟷ Mathlib.LinearAlgebra.CliffordAlgebra.Fold

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 10 + 641

`linear_algebra.clifford_algebra.fold` ⟷ `Mathlib.LinearAlgebra.CliffordAlgebra.Fold`