algebra.symmetrized | 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

93354783

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

36938f77

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) 2021 Christopher Hoskin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
 -/
-import Mathbin.Algebra.Jordan.Basic
-import Mathbin.Algebra.Module.Basic
+import Algebra.Jordan.Basic
+import Algebra.Module.Basic
 
 #align_import algebra.symmetrized from "leanprover-community/mathlib"@"36938f775671ff28bea1c0310f1608e4afbb22e0"

36938f77

bump to nightly-2023-08-17-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

60285dcc

Diff

@@ -351,9 +351,9 @@ instance {R : Type _} [Semiring R] [AddCommMonoid α] [Module R α] : Module R 
 instance [Mul α] [Add α] [One α] [Invertible (2 : α)] (a : α) [Invertible a] : Invertible (sym a)
     where
   invOf := sym (⅟ a)
-  invOf_mul_self := by
+  invOf_hMul_self := by
     rw [sym_mul_sym, mul_invOf_self, invOf_mul_self, ← bit0, invOf_mul_self, sym_one]
-  mul_invOf_self := by
+  hMul_invOf_self := by
     rw [sym_mul_sym, mul_invOf_self, invOf_mul_self, ← bit0, invOf_mul_self, sym_one]
 
 #print SymAlg.invOf_sym /-

36938f77

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) 2021 Christopher Hoskin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
-
-! This file was ported from Lean 3 source module algebra.symmetrized
-! leanprover-community/mathlib commit 36938f775671ff28bea1c0310f1608e4afbb22e0
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Jordan.Basic
 import Mathbin.Algebra.Module.Basic
 
+#align_import algebra.symmetrized from "leanprover-community/mathlib"@"36938f775671ff28bea1c0310f1608e4afbb22e0"
+
 /-!
 # Symmetrized algebra

36938f77

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -46,7 +46,6 @@ def SymAlg (α : Type _) : Type _ :=
 #align sym_alg SymAlg
 -/
 
--- mathport name: «expr ˢʸᵐ»
 postfix:max "ˢʸᵐ" => SymAlg
 
 namespace SymAlg
@@ -252,18 +251,24 @@ theorem unsym_neg [Neg α] (a : αˢʸᵐ) : unsym (-a) = -unsym a :=
 #align sym_alg.unsym_neg SymAlg.unsym_neg
 -/
 
+#print SymAlg.mul_def /-
 theorem mul_def [Add α] [Mul α] [One α] [Invertible (2 : α)] (a b : αˢʸᵐ) :
     a * b = sym (⅟ 2 * (unsym a * unsym b + unsym b * unsym a)) := by rfl
 #align sym_alg.mul_def SymAlg.mul_def
+-/
 
+#print SymAlg.unsym_mul /-
 theorem unsym_mul [Mul α] [Add α] [One α] [Invertible (2 : α)] (a b : αˢʸᵐ) :
     unsym (a * b) = ⅟ 2 * (unsym a * unsym b + unsym b * unsym a) := by rfl
 #align sym_alg.unsym_mul SymAlg.unsym_mul
+-/
 
+#print SymAlg.sym_mul_sym /-
 theorem sym_mul_sym [Mul α] [Add α] [One α] [Invertible (2 : α)] (a b : α) :
     sym a * sym b = sym (⅟ 2 * (a * b + b * a)) :=
   rfl
 #align sym_alg.sym_mul_sym SymAlg.sym_mul_sym
+-/
 
 #print SymAlg.sym_inv /-
 @[simp, to_additive]
@@ -354,11 +359,13 @@ instance [Mul α] [Add α] [One α] [Invertible (2 : α)] (a : α) [Invertible a
   mul_invOf_self := by
     rw [sym_mul_sym, mul_invOf_self, invOf_mul_self, ← bit0, invOf_mul_self, sym_one]
 
+#print SymAlg.invOf_sym /-
 @[simp]
 theorem invOf_sym [Mul α] [Add α] [One α] [Invertible (2 : α)] (a : α) [Invertible a] :
     ⅟ (sym a) = sym (⅟ a) :=
   rfl
 #align sym_alg.inv_of_sym SymAlg.invOf_sym
+-/
 
 instance [Semiring α] [Invertible (2 : α)] : NonAssocSemiring αˢʸᵐ :=
   { SymAlg.addCommMonoid with
@@ -393,17 +400,23 @@ instance [Ring α] [Invertible (2 : α)] : NonAssocRing αˢʸᵐ :=
 /-! The squaring operation coincides for both multiplications -/
 
 
+#print SymAlg.unsym_mul_self /-
 theorem unsym_mul_self [Semiring α] [Invertible (2 : α)] (a : αˢʸᵐ) :
     unsym (a * a) = unsym a * unsym a := by rw [mul_def, unsym_sym, ← two_mul, invOf_mul_self_assoc]
 #align sym_alg.unsym_mul_self SymAlg.unsym_mul_self
+-/
 
+#print SymAlg.sym_mul_self /-
 theorem sym_mul_self [Semiring α] [Invertible (2 : α)] (a : α) : sym (a * a) = sym a * sym a := by
   rw [sym_mul_sym, ← two_mul, invOf_mul_self_assoc]
 #align sym_alg.sym_mul_self SymAlg.sym_mul_self
+-/
 
+#print SymAlg.mul_comm /-
 theorem mul_comm [Mul α] [AddCommSemigroup α] [One α] [Invertible (2 : α)] (a b : αˢʸᵐ) :
     a * b = b * a := by rw [mul_def, mul_def, add_comm]
 #align sym_alg.mul_comm SymAlg.mul_comm
+-/
 
 instance [Ring α] [Invertible (2 : α)] : IsCommJordan αˢʸᵐ
     where

36938f77

bump to nightly-2023-06-07-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/58a272265b5e05f258161260dd2c5d247213cbd3

831e78ce

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
 
 ! This file was ported from Lean 3 source module algebra.symmetrized
-! leanprover-community/mathlib commit 933547832736be61a5de6576e22db351c6c2fbfd
+! leanprover-community/mathlib commit 36938f775671ff28bea1c0310f1608e4afbb22e0
 ! 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.Basic
 /-!
 # Symmetrized algebra
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 A commutative multiplication on a real or complex space can be constructed from any multiplication
 by "symmetrization" i.e
 $$

93354783

bump to nightly-2023-06-05-06

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

62cd60d3

Diff

@@ -35,11 +35,13 @@ The approach taken here is inspired by algebra.opposites. We use Oxford Spelling
 
 open Function
 
+#print SymAlg /-
 /-- The symmetrized algebra has the same underlying space as the original algebra.
 -/
 def SymAlg (α : Type _) : Type _ :=
   α
 #align sym_alg SymAlg
+-/
 
 -- mathport name: «expr ˢʸᵐ»
 postfix:max "ˢʸᵐ" => SymAlg
@@ -48,81 +50,113 @@ namespace SymAlg
 
 variable {α : Type _}
 
+#print SymAlg.sym /-
 /-- The element of `sym_alg α` that represents `a : α`. -/
 @[match_pattern, pp_nodot]
 def sym : α ≃ αˢʸᵐ :=
   Equiv.refl _
 #align sym_alg.sym SymAlg.sym
+-/
 
+#print SymAlg.unsym /-
 /-- The element of `α` represented by `x : αˢʸᵐ`. -/
 @[pp_nodot]
 def unsym : αˢʸᵐ ≃ α :=
   Equiv.refl _
 #align sym_alg.unsym SymAlg.unsym
+-/
 
+#print SymAlg.unsym_sym /-
 @[simp]
 theorem unsym_sym (a : α) : unsym (sym a) = a :=
   rfl
 #align sym_alg.unsym_sym SymAlg.unsym_sym
+-/
 
+#print SymAlg.sym_unsym /-
 @[simp]
 theorem sym_unsym (a : α) : sym (unsym a) = a :=
   rfl
 #align sym_alg.sym_unsym SymAlg.sym_unsym
+-/
 
+#print SymAlg.sym_comp_unsym /-
 @[simp]
 theorem sym_comp_unsym : (sym : α → αˢʸᵐ) ∘ unsym = id :=
   rfl
 #align sym_alg.sym_comp_unsym SymAlg.sym_comp_unsym
+-/
 
+#print SymAlg.unsym_comp_sym /-
 @[simp]
 theorem unsym_comp_sym : (unsym : αˢʸᵐ → α) ∘ sym = id :=
   rfl
 #align sym_alg.unsym_comp_sym SymAlg.unsym_comp_sym
+-/
 
+#print SymAlg.sym_symm /-
 @[simp]
 theorem sym_symm : (@sym α).symm = unsym :=
   rfl
 #align sym_alg.sym_symm SymAlg.sym_symm
+-/
 
+#print SymAlg.unsym_symm /-
 @[simp]
 theorem unsym_symm : (@unsym α).symm = sym :=
   rfl
 #align sym_alg.unsym_symm SymAlg.unsym_symm
+-/
 
+#print SymAlg.sym_bijective /-
 theorem sym_bijective : Bijective (sym : α → αˢʸᵐ) :=
   sym.Bijective
 #align sym_alg.sym_bijective SymAlg.sym_bijective
+-/
 
+#print SymAlg.unsym_bijective /-
 theorem unsym_bijective : Bijective (unsym : αˢʸᵐ → α) :=
   unsym.symm.Bijective
 #align sym_alg.unsym_bijective SymAlg.unsym_bijective
+-/
 
+#print SymAlg.sym_injective /-
 theorem sym_injective : Injective (sym : α → αˢʸᵐ) :=
   sym.Injective
 #align sym_alg.sym_injective SymAlg.sym_injective
+-/
 
+#print SymAlg.sym_surjective /-
 theorem sym_surjective : Surjective (sym : α → αˢʸᵐ) :=
   sym.Surjective
 #align sym_alg.sym_surjective SymAlg.sym_surjective
+-/
 
+#print SymAlg.unsym_injective /-
 theorem unsym_injective : Injective (unsym : αˢʸᵐ → α) :=
   unsym.Injective
 #align sym_alg.unsym_injective SymAlg.unsym_injective
+-/
 
+#print SymAlg.unsym_surjective /-
 theorem unsym_surjective : Surjective (unsym : αˢʸᵐ → α) :=
   unsym.Surjective
 #align sym_alg.unsym_surjective SymAlg.unsym_surjective
+-/
 
+#print SymAlg.sym_inj /-
 @[simp]
 theorem sym_inj {a b : α} : sym a = sym b ↔ a = b :=
   sym_injective.eq_iff
 #align sym_alg.sym_inj SymAlg.sym_inj
+-/
 
+#print SymAlg.unsym_inj /-
 @[simp]
 theorem unsym_inj {a b : αˢʸᵐ} : unsym a = unsym b ↔ a = b :=
   unsym_injective.eq_iff
 #align sym_alg.unsym_inj SymAlg.unsym_inj
+-/
 
 instance [Nontrivial α] : Nontrivial αˢʸᵐ :=
   sym_injective.Nontrivial
@@ -157,47 +191,63 @@ instance [Inv α] : Inv αˢʸᵐ where inv a := sym <| (unsym a)⁻¹
 
 instance (R : Type _) [SMul R α] : SMul R αˢʸᵐ where smul r a := sym (r • unsym a)
 
+#print SymAlg.sym_one /-
 @[simp, to_additive]
 theorem sym_one [One α] : sym (1 : α) = 1 :=
   rfl
 #align sym_alg.sym_one SymAlg.sym_one
 #align sym_alg.sym_zero SymAlg.sym_zero
+-/
 
+#print SymAlg.unsym_one /-
 @[simp, to_additive]
 theorem unsym_one [One α] : unsym (1 : αˢʸᵐ) = 1 :=
   rfl
 #align sym_alg.unsym_one SymAlg.unsym_one
 #align sym_alg.unsym_zero SymAlg.unsym_zero
+-/
 
+#print SymAlg.sym_add /-
 @[simp]
 theorem sym_add [Add α] (a b : α) : sym (a + b) = sym a + sym b :=
   rfl
 #align sym_alg.sym_add SymAlg.sym_add
+-/
 
+#print SymAlg.unsym_add /-
 @[simp]
 theorem unsym_add [Add α] (a b : αˢʸᵐ) : unsym (a + b) = unsym a + unsym b :=
   rfl
 #align sym_alg.unsym_add SymAlg.unsym_add
+-/
 
+#print SymAlg.sym_sub /-
 @[simp]
 theorem sym_sub [Sub α] (a b : α) : sym (a - b) = sym a - sym b :=
   rfl
 #align sym_alg.sym_sub SymAlg.sym_sub
+-/
 
+#print SymAlg.unsym_sub /-
 @[simp]
 theorem unsym_sub [Sub α] (a b : αˢʸᵐ) : unsym (a - b) = unsym a - unsym b :=
   rfl
 #align sym_alg.unsym_sub SymAlg.unsym_sub
+-/
 
+#print SymAlg.sym_neg /-
 @[simp]
 theorem sym_neg [Neg α] (a : α) : sym (-a) = -sym a :=
   rfl
 #align sym_alg.sym_neg SymAlg.sym_neg
+-/
 
+#print SymAlg.unsym_neg /-
 @[simp]
 theorem unsym_neg [Neg α] (a : αˢʸᵐ) : unsym (-a) = -unsym a :=
   rfl
 #align sym_alg.unsym_neg SymAlg.unsym_neg
+-/
 
 theorem mul_def [Add α] [Mul α] [One α] [Invertible (2 : α)] (a b : αˢʸᵐ) :
     a * b = sym (⅟ 2 * (unsym a * unsym b + unsym b * unsym a)) := by rfl
@@ -212,51 +262,67 @@ theorem sym_mul_sym [Mul α] [Add α] [One α] [Invertible (2 : α)] (a b : α)
   rfl
 #align sym_alg.sym_mul_sym SymAlg.sym_mul_sym
 
+#print SymAlg.sym_inv /-
 @[simp, to_additive]
 theorem sym_inv [Inv α] (a : α) : sym a⁻¹ = (sym a)⁻¹ :=
   rfl
 #align sym_alg.sym_inv SymAlg.sym_inv
 #align sym_alg.sym_neg SymAlg.sym_neg
+-/
 
+#print SymAlg.unsym_inv /-
 @[simp, to_additive]
 theorem unsym_inv [Inv α] (a : αˢʸᵐ) : unsym a⁻¹ = (unsym a)⁻¹ :=
   rfl
 #align sym_alg.unsym_inv SymAlg.unsym_inv
 #align sym_alg.unsym_neg SymAlg.unsym_neg
+-/
 
+#print SymAlg.sym_smul /-
 @[simp]
 theorem sym_smul {R : Type _} [SMul R α] (c : R) (a : α) : sym (c • a) = c • sym a :=
   rfl
 #align sym_alg.sym_smul SymAlg.sym_smul
+-/
 
+#print SymAlg.unsym_smul /-
 @[simp]
 theorem unsym_smul {R : Type _} [SMul R α] (c : R) (a : αˢʸᵐ) : unsym (c • a) = c • unsym a :=
   rfl
 #align sym_alg.unsym_smul SymAlg.unsym_smul
+-/
 
+#print SymAlg.unsym_eq_one_iff /-
 @[simp, to_additive]
 theorem unsym_eq_one_iff [One α] (a : αˢʸᵐ) : a.unsym = 1 ↔ a = 1 :=
   unsym_injective.eq_iff' rfl
 #align sym_alg.unsym_eq_one_iff SymAlg.unsym_eq_one_iff
 #align sym_alg.unsym_eq_zero_iff SymAlg.unsym_eq_zero_iff
+-/
 
+#print SymAlg.sym_eq_one_iff /-
 @[simp, to_additive]
 theorem sym_eq_one_iff [One α] (a : α) : sym a = 1 ↔ a = 1 :=
   sym_injective.eq_iff' rfl
 #align sym_alg.sym_eq_one_iff SymAlg.sym_eq_one_iff
 #align sym_alg.sym_eq_zero_iff SymAlg.sym_eq_zero_iff
+-/
 
+#print SymAlg.unsym_ne_one_iff /-
 @[to_additive]
 theorem unsym_ne_one_iff [One α] (a : αˢʸᵐ) : a.unsym ≠ (1 : α) ↔ a ≠ (1 : αˢʸᵐ) :=
   not_congr <| unsym_eq_one_iff a
 #align sym_alg.unsym_ne_one_iff SymAlg.unsym_ne_one_iff
 #align sym_alg.unsym_ne_zero_iff SymAlg.unsym_ne_zero_iff
+-/
 
+#print SymAlg.sym_ne_one_iff /-
 @[to_additive]
 theorem sym_ne_one_iff [One α] (a : α) : sym a ≠ (1 : αˢʸᵐ) ↔ a ≠ (1 : α) :=
   not_congr <| sym_eq_one_iff a
 #align sym_alg.sym_ne_one_iff SymAlg.sym_ne_one_iff
 #align sym_alg.sym_ne_zero_iff SymAlg.sym_ne_zero_iff
+-/
 
 instance [AddCommSemigroup α] : AddCommSemigroup αˢʸᵐ :=
   unsym_injective.AddCommSemigroup _ unsym_add

93354783

bump to nightly-2023-03-11-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

cd44fb92

Diff

@@ -297,9 +297,11 @@ instance [Semiring α] [Invertible (2 : α)] : NonAssocSemiring αˢʸᵐ :=
     mul := (· * ·)
     zero := 0
     zero_mul := fun _ => by
-      rw [mul_def, unsym_zero, zero_mul, mul_zero, add_zero, mul_zero, sym_zero]
+      rw [mul_def, unsym_zero, MulZeroClass.zero_mul, MulZeroClass.mul_zero, add_zero,
+        MulZeroClass.mul_zero, sym_zero]
     mul_zero := fun _ => by
-      rw [mul_def, unsym_zero, zero_mul, mul_zero, add_zero, mul_zero, sym_zero]
+      rw [mul_def, unsym_zero, MulZeroClass.zero_mul, MulZeroClass.mul_zero, add_zero,
+        MulZeroClass.mul_zero, sym_zero]
     mul_one := fun _ => by
       rw [mul_def, unsym_one, mul_one, one_mul, ← two_mul, invOf_mul_self_assoc, sym_unsym]
     one_mul := fun _ => by
@@ -354,7 +356,7 @@ instance [Ring α] [Invertible (2 : α)] : IsCommJordan αˢʸᵐ
     rw [add_mul, ← add_assoc, ← mul_assoc, ← mul_assoc]
     rw [unsym_mul_self]
     rw [← mul_assoc, ← mul_assoc, ← mul_assoc, ← mul_assoc, ← sub_eq_zero, ← mul_sub]
-    convert mul_zero (⅟ (2 : α) * ⅟ (2 : α))
+    convert MulZeroClass.mul_zero (⅟ (2 : α) * ⅟ (2 : α))
     rw [add_sub_add_right_eq_sub, add_assoc, add_assoc, add_sub_add_left_eq_sub, add_comm,
       add_sub_add_right_eq_sub, sub_eq_zero]

93354783

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

93354783

chore: split Algebra.Module.Basic (#12501)

Similar to #12486, which did this for Algebra.Algebra.Basic.

Splits Algebra.Module.Defs off Algebra.Module.Basic. Most imports only need the Defs file, which has significantly smaller imports. The remaining Algebra.Module.Basic is now a grab-bag of unrelated results, and should probably be split further or rehomed.

This is mostly motivated by the wasted effort during minimization upon encountering Algebra.Module.Basic.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com>

7d5102df

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
 -/
 import Mathlib.Algebra.Jordan.Basic
-import Mathlib.Algebra.Module.Basic
+import Mathlib.Algebra.Module.Defs
 
 #align_import algebra.symmetrized from "leanprover-community/mathlib"@"933547832736be61a5de6576e22db351c6c2fbfd"

93354783

chore: remove mathport name: <expression> lines (#11928)

Quoting [@digama0](https://github.com/digama0):

These were actually never meant to go in the file, they are basically debugging information and only useful on significantly broken mathport files. You can safely remove all of them.

11431c65

Diff

@@ -38,7 +38,6 @@ def SymAlg (α : Type*) : Type _ :=
   α
 #align sym_alg SymAlg
 
--- mathport name: «expr ˢʸᵐ»
 postfix:max "ˢʸᵐ" => SymAlg
 
 namespace SymAlg

93354783

chore: classify removed @[pp_nodot] porting notes (#11181)

Classifies by adding issue number #11180 to porting notes claiming:

removed @[pp_nodot]

76aa1eb1

Diff

@@ -47,13 +47,13 @@ variable {α : Type*}
 
 /-- The element of `SymAlg α` that represents `a : α`. -/
 @[match_pattern]
--- Porting note: removed @[pp_nodot]
+-- Porting note (#11180): removed @[pp_nodot]
 def sym : α ≃ αˢʸᵐ :=
   Equiv.refl _
 #align sym_alg.sym SymAlg.sym
 
 /-- The element of `α` represented by `x : αˢʸᵐ`. -/
--- Porting note: removed @[pp_nodot]
+-- Porting note (#11180): removed @[pp_nodot]
 def unsym : αˢʸᵐ ≃ α :=
   Equiv.refl _
 #align sym_alg.unsym SymAlg.unsym

93354783

chore: classify simp can do this porting notes (#10619)

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

de765f60

Diff

@@ -112,12 +112,12 @@ theorem unsym_surjective : Surjective (unsym : αˢʸᵐ → α) :=
   unsym.surjective
 #align sym_alg.unsym_surjective SymAlg.unsym_surjective
 
--- Porting note: @[simp] can prove this
+-- Porting note (#10618): @[simp] can prove this
 theorem sym_inj {a b : α} : sym a = sym b ↔ a = b :=
   sym_injective.eq_iff
 #align sym_alg.sym_inj SymAlg.sym_inj
 
--- Porting note: @[simp] can prove this
+-- Porting note (#10618): @[simp] can prove this
 theorem unsym_inj {a b : αˢʸᵐ} : unsym a = unsym b ↔ a = b :=
   unsym_injective.eq_iff
 #align sym_alg.unsym_inj SymAlg.unsym_inj

93354783

refactor(Algebra/Group/Defs): Separate commutative and associative multiplication (addition) (#7060)

Currently in Mathlib there is no class for magma that are commutative but not associative - Field extends CommRing and DivisionRing, CommRing extends Ring and CommMonoid, CommGroup extends Group and CommMonoid and CommMonoid extends CommSemigroup and Monoid. CommSemigroup currently extends only Semigroup and has mul_comm as a property.

This PR moves mul_comm into a new CommMagma (AddCommMagma) class which extends Mul (Add). CommSemigroup now extends Semigroup and CommMagma.

The rest of Mathlib4 compiles as before, except with the need to increase synthInstance.maxHeartbeats for lift_of_splits.

(Update: The linter is objecting to an unused argument in what seems to be a completely unrelated bit of code (AddEquiv.lpPiLp). Trying a nolint for now.)

Also referenced in https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/.60add_comm.60.20without.20.60add_assoc.60

Co-authored-by: Jireh Loreaux <loreaujy@gmail.com> Co-authored-by: Christopher Hoskin <mans0954@users.noreply.github.com> Co-authored-by: Christopher Hoskin <christopher.hoskin@overleaf.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

ee87d34d

Diff

@@ -336,8 +336,10 @@ theorem mul_comm [Mul α] [AddCommSemigroup α] [One α] [OfNat α 2] [Invertibl
     a * b = b * a := by rw [mul_def, mul_def, add_comm]
 #align sym_alg.mul_comm SymAlg.mul_comm
 
-instance [Ring α] [Invertible (2 : α)] : IsCommJordan αˢʸᵐ where
+instance [Ring α] [Invertible (2 : α)] : CommMagma αˢʸᵐ where
   mul_comm := SymAlg.mul_comm
+
+instance [Ring α] [Invertible (2 : α)] : IsCommJordan αˢʸᵐ where
   lmul_comm_rmul_rmul a b := by
     have commute_half_left := fun a : α => by
       -- Porting note: mathlib3 used `bit0_left`

93354783

perf: remove overspecified fields (#6965)

This removes redundant field values of the form add := add for smaller terms and less unfolding during unification.

A list of all files containing a structure instance of the form { a1, ... with x1 := val, ... } where some xi is a field of some aj was generated by modifying the structure instance elaboration algorithm to print such overlaps to stdout in a custom toolchain.

Using that toolchain, I went through each file on the list and attempted to remove algebraic fields that overlapped and were redundant, eg add := add and not toFun (though some other ones did creep in). If things broke (which was the case in a couple of cases), I did not push further and reverted.

It is possible that pushing harder and trying to remove all redundant overlaps will yield further improvements.

12150475

Diff

@@ -293,7 +293,6 @@ instance nonAssocSemiring [Semiring α] [Invertible (2 : α)] : NonAssocSemiring
   { SymAlg.addCommMonoid with
     one := 1
     mul := (· * ·)
-    zero := 0
     zero_mul := fun _ => by
       rw [mul_def, unsym_zero, zero_mul, mul_zero, add_zero,
         mul_zero, sym_zero]

93354783

chore: simplify by rfl (#7039)

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

8908a0a5

Diff

@@ -198,11 +198,11 @@ theorem unsym_neg [Neg α] (a : αˢʸᵐ) : unsym (-a) = -unsym a :=
 #align sym_alg.unsym_neg SymAlg.unsym_neg
 
 theorem mul_def [Add α] [Mul α] [One α] [OfNat α 2] [Invertible (2 : α)] (a b : αˢʸᵐ) :
-    a * b = sym (⅟ 2 * (unsym a * unsym b + unsym b * unsym a)) := by rfl
+    a * b = sym (⅟ 2 * (unsym a * unsym b + unsym b * unsym a)) := rfl
 #align sym_alg.mul_def SymAlg.mul_def
 
 theorem unsym_mul [Mul α] [Add α] [One α] [OfNat α 2] [Invertible (2 : α)] (a b : αˢʸᵐ) :
-    unsym (a * b) = ⅟ 2 * (unsym a * unsym b + unsym b * unsym a) := by rfl
+    unsym (a * b) = ⅟ 2 * (unsym a * unsym b + unsym b * unsym a) := rfl
 #align sym_alg.unsym_mul SymAlg.unsym_mul
 
 theorem sym_mul_sym [Mul α] [Add α] [One α] [OfNat α 2] [Invertible (2 : α)] (a b : α) :

93354783

chore: drop MulZeroClass. in mul_zero/zero_mul (#6682)

Search&replace MulZeroClass.mul_zero -> mul_zero, MulZeroClass.zero_mul -> zero_mul.

These were introduced by Mathport, as the full name of mul_zero is actually MulZeroClass.mul_zero (it's exported with the short name).

277dea95

Diff

@@ -295,11 +295,11 @@ instance nonAssocSemiring [Semiring α] [Invertible (2 : α)] : NonAssocSemiring
     mul := (· * ·)
     zero := 0
     zero_mul := fun _ => by
-      rw [mul_def, unsym_zero, MulZeroClass.zero_mul, MulZeroClass.mul_zero, add_zero,
-        MulZeroClass.mul_zero, sym_zero]
+      rw [mul_def, unsym_zero, zero_mul, mul_zero, add_zero,
+        mul_zero, sym_zero]
     mul_zero := fun _ => by
-      rw [mul_def, unsym_zero, MulZeroClass.zero_mul, MulZeroClass.mul_zero, add_zero,
-        MulZeroClass.mul_zero, sym_zero]
+      rw [mul_def, unsym_zero, zero_mul, mul_zero, add_zero,
+        mul_zero, sym_zero]
     mul_one := fun _ => by
       rw [mul_def, unsym_one, mul_one, one_mul, ← two_mul, invOf_mul_self_assoc, sym_unsym]
     one_mul := fun _ => by
@@ -368,7 +368,7 @@ instance [Ring α] [Invertible (2 : α)] : IsCommJordan αˢʸᵐ where
       rw [add_mul, ← add_assoc, ← mul_assoc, ← mul_assoc]
       rw [unsym_mul_self]
       rw [← mul_assoc, ← mul_assoc, ← mul_assoc, ← mul_assoc, ← sub_eq_zero, ← mul_sub]
-      convert MulZeroClass.mul_zero (⅟ (2 : α) * ⅟ (2 : α))
+      convert mul_zero (⅟ (2 : α) * ⅟ (2 : α))
       rw [add_sub_add_right_eq_sub, add_assoc, add_assoc, add_sub_add_left_eq_sub, add_comm,
         add_sub_add_right_eq_sub, sub_eq_zero]

93354783

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

@@ -34,7 +34,7 @@ open Function
 
 /-- The symmetrized algebra has the same underlying space as the original algebra.
 -/
-def SymAlg (α : Type _) : Type _ :=
+def SymAlg (α : Type*) : Type _ :=
   α
 #align sym_alg SymAlg
 
@@ -43,7 +43,7 @@ postfix:max "ˢʸᵐ" => SymAlg
 
 namespace SymAlg
 
-variable {α : Type _}
+variable {α : Type*}
 
 /-- The element of `SymAlg α` that represents `a : α`. -/
 @[match_pattern]
@@ -153,7 +153,7 @@ instance [Add α] [Mul α] [One α] [OfNat α 2] [Invertible (2 : α)] : Mul α
 @[to_additive existing]
 instance [Inv α] : Inv αˢʸᵐ where inv a := sym <| (unsym a)⁻¹
 
-instance (R : Type _) [SMul R α] : SMul R αˢʸᵐ where smul r a := sym (r • unsym a)
+instance (R : Type*) [SMul R α] : SMul R αˢʸᵐ where smul r a := sym (r • unsym a)
 
 @[to_additive (attr := simp)]
 theorem sym_one [One α] : sym (1 : α) = 1 :=
@@ -223,12 +223,12 @@ theorem unsym_inv [Inv α] (a : αˢʸᵐ) : unsym a⁻¹ = (unsym a)⁻¹ :=
 #align sym_alg.unsym_inv SymAlg.unsym_inv
 
 @[simp]
-theorem sym_smul {R : Type _} [SMul R α] (c : R) (a : α) : sym (c • a) = c • sym a :=
+theorem sym_smul {R : Type*} [SMul R α] (c : R) (a : α) : sym (c • a) = c • sym a :=
   rfl
 #align sym_alg.sym_smul SymAlg.sym_smul
 
 @[simp]
-theorem unsym_smul {R : Type _} [SMul R α] (c : R) (a : αˢʸᵐ) : unsym (c • a) = c • unsym a :=
+theorem unsym_smul {R : Type*} [SMul R α] (c : R) (a : αˢʸᵐ) : unsym (c • a) = c • unsym a :=
   rfl
 #align sym_alg.unsym_smul SymAlg.unsym_smul
 
@@ -272,7 +272,7 @@ instance addCommMonoid [AddCommMonoid α] : AddCommMonoid αˢʸᵐ :=
 instance addCommGroup [AddCommGroup α] : AddCommGroup αˢʸᵐ :=
   { SymAlg.addCommMonoid, SymAlg.addGroup with }
 
-instance {R : Type _} [Semiring R] [AddCommMonoid α] [Module R α] : Module R αˢʸᵐ :=
+instance {R : Type*} [Semiring R] [AddCommMonoid α] [Module R α] : Module R αˢʸᵐ :=
   Function.Injective.module R ⟨⟨unsym, unsym_zero⟩, unsym_add⟩ unsym_injective unsym_smul
 
 instance [Mul α] [AddMonoidWithOne α] [Invertible (2 : α)] (a : α) [Invertible a] :

93354783

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) 2021 Christopher Hoskin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Christopher Hoskin
-
-! This file was ported from Lean 3 source module algebra.symmetrized
-! leanprover-community/mathlib commit 933547832736be61a5de6576e22db351c6c2fbfd
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Jordan.Basic
 import Mathlib.Algebra.Module.Basic
 
+#align_import algebra.symmetrized from "leanprover-community/mathlib"@"933547832736be61a5de6576e22db351c6c2fbfd"
+
 /-!
 # Symmetrized algebra

93354783

feat: port Algebra.Symmetrized (#4632)

041a489d

`algebra.symmetrized` ⟷ `Mathlib.Algebra.Symmetrized`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 469

algebra.symmetrized ⟷ Mathlib.Algebra.Symmetrized

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 8 + 469

`algebra.symmetrized` ⟷ `Mathlib.Algebra.Symmetrized`