algebra.category.Group.biproducts | 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

234ddfea

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

f60c6087

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Algebra.Group.Pi
-import Algebra.Category.Group.Preadditive
+import Algebra.Group.Pi.Lemmas
+import Algebra.Category.GroupCat.Preadditive
 import CategoryTheory.Preadditive.Biproducts
-import Algebra.Category.Group.Limits
+import Algebra.Category.GroupCat.Limits
 
 #align_import algebra.category.Group.biproducts from "leanprover-community/mathlib"@"f60c6087a7275b72d5db3c5a1d0e19e35a429c0a"

f60c6087

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,10 +3,10 @@ Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Mathbin.Algebra.Group.Pi
-import Mathbin.Algebra.Category.Group.Preadditive
-import Mathbin.CategoryTheory.Preadditive.Biproducts
-import Mathbin.Algebra.Category.Group.Limits
+import Algebra.Group.Pi
+import Algebra.Category.Group.Preadditive
+import CategoryTheory.Preadditive.Biproducts
+import Algebra.Category.Group.Limits
 
 #align_import algebra.category.Group.biproducts from "leanprover-community/mathlib"@"f60c6087a7275b72d5db3c5a1d0e19e35a429c0a"

f60c6087

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,17 +2,14 @@
 Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module algebra.category.Group.biproducts
-! leanprover-community/mathlib commit f60c6087a7275b72d5db3c5a1d0e19e35a429c0a
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Group.Pi
 import Mathbin.Algebra.Category.Group.Preadditive
 import Mathbin.CategoryTheory.Preadditive.Biproducts
 import Mathbin.Algebra.Category.Group.Limits
 
+#align_import algebra.category.Group.biproducts from "leanprover-community/mathlib"@"f60c6087a7275b72d5db3c5a1d0e19e35a429c0a"
+
 /-!
 # The category of abelian groups has finite biproducts

f60c6087

bump to nightly-2023-06-20-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

9b351f8c

Diff

@@ -134,7 +134,7 @@ def productLimitCone : Limits.LimitCone (Discrete.functor f)
     { lift := lift f
       fac := fun s j => by cases j; ext; simp
       uniq := fun s m w => by
-        ext (x j)
+        ext x j
         dsimp only [has_limit.lift]
         simp only [AddMonoidHom.coe_mk]
         exact congr_arg (fun g : s.X ⟶ f j => (g : s.X → f j) x) (w ⟨j⟩) }

f60c6087

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -61,18 +61,23 @@ def binaryProductLimitCone (G H : AddCommGroupCat.{u}) : Limits.LimitCone (pair
 #align AddCommGroup.binary_product_limit_cone AddCommGroupCat.binaryProductLimitCone
 -/
 
+#print AddCommGroupCat.binaryProductLimitCone_cone_π_app_left /-
 @[simp]
 theorem binaryProductLimitCone_cone_π_app_left (G H : AddCommGroupCat.{u}) :
     (binaryProductLimitCone G H).Cone.π.app ⟨WalkingPair.left⟩ = AddMonoidHom.fst G H :=
   rfl
 #align AddCommGroup.binary_product_limit_cone_cone_π_app_left AddCommGroupCat.binaryProductLimitCone_cone_π_app_left
+-/
 
+#print AddCommGroupCat.binaryProductLimitCone_cone_π_app_right /-
 @[simp]
 theorem binaryProductLimitCone_cone_π_app_right (G H : AddCommGroupCat.{u}) :
     (binaryProductLimitCone G H).Cone.π.app ⟨WalkingPair.right⟩ = AddMonoidHom.snd G H :=
   rfl
 #align AddCommGroup.binary_product_limit_cone_cone_π_app_right AddCommGroupCat.binaryProductLimitCone_cone_π_app_right
+-/
 
+#print AddCommGroupCat.biprodIsoProd /-
 /-- We verify that the biproduct in AddCommGroup is isomorphic to
 the cartesian product of the underlying types:
 -/
@@ -81,18 +86,23 @@ noncomputable def biprodIsoProd (G H : AddCommGroupCat.{u}) :
     (G ⊞ H : AddCommGroupCat) ≅ AddCommGroupCat.of (G × H) :=
   IsLimit.conePointUniqueUpToIso (BinaryBiproduct.isLimit G H) (binaryProductLimitCone G H).IsLimit
 #align AddCommGroup.biprod_iso_prod AddCommGroupCat.biprodIsoProd
+-/
 
+#print AddCommGroupCat.biprodIsoProd_inv_comp_fst /-
 @[simp, elementwise]
 theorem biprodIsoProd_inv_comp_fst (G H : AddCommGroupCat.{u}) :
     (biprodIsoProd G H).inv ≫ biprod.fst = AddMonoidHom.fst G H :=
   IsLimit.conePointUniqueUpToIso_inv_comp _ _ (Discrete.mk WalkingPair.left)
 #align AddCommGroup.biprod_iso_prod_inv_comp_fst AddCommGroupCat.biprodIsoProd_inv_comp_fst
+-/
 
+#print AddCommGroupCat.biprodIsoProd_inv_comp_snd /-
 @[simp, elementwise]
 theorem biprodIsoProd_inv_comp_snd (G H : AddCommGroupCat.{u}) :
     (biprodIsoProd G H).inv ≫ biprod.snd = AddMonoidHom.snd G H :=
   IsLimit.conePointUniqueUpToIso_inv_comp _ _ (Discrete.mk WalkingPair.right)
 #align AddCommGroup.biprod_iso_prod_inv_comp_snd AddCommGroupCat.biprodIsoProd_inv_comp_snd
+-/
 
 namespace HasLimit
 
@@ -137,6 +147,7 @@ open HasLimit
 
 variable {J : Type} [Fintype J]
 
+#print AddCommGroupCat.biproductIsoPi /-
 /-- We verify that the biproduct we've just defined is isomorphic to the AddCommGroup structure
 on the dependent function type
 -/
@@ -145,12 +156,15 @@ noncomputable def biproductIsoPi (f : J → AddCommGroupCat.{u}) :
     (⨁ f : AddCommGroupCat) ≅ AddCommGroupCat.of (∀ j, f j) :=
   IsLimit.conePointUniqueUpToIso (biproduct.isLimit f) (productLimitCone f).IsLimit
 #align AddCommGroup.biproduct_iso_pi AddCommGroupCat.biproductIsoPi
+-/
 
+#print AddCommGroupCat.biproductIsoPi_inv_comp_π /-
 @[simp, elementwise]
 theorem biproductIsoPi_inv_comp_π (f : J → AddCommGroupCat.{u}) (j : J) :
     (biproductIsoPi f).inv ≫ biproduct.π f j = Pi.evalAddMonoidHom (fun j => f j) j :=
   IsLimit.conePointUniqueUpToIso_inv_comp _ _ (Discrete.mk j)
 #align AddCommGroup.biproduct_iso_pi_inv_comp_π AddCommGroupCat.biproductIsoPi_inv_comp_π
+-/
 
 end AddCommGroupCat

f60c6087

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -57,7 +57,7 @@ def binaryProductLimitCone (G H : AddCommGroupCat.{u}) : Limits.LimitCone (pair
     { lift := fun s => AddMonoidHom.prod (s.π.app ⟨WalkingPair.left⟩) (s.π.app ⟨WalkingPair.right⟩)
       fac := by rintro s (⟨⟩ | ⟨⟩) <;> · ext x; simp
       uniq := fun s m w => by
-        ext <;> [rw [← w ⟨walking_pair.left⟩];rw [← w ⟨walking_pair.right⟩]] <;> rfl }
+        ext <;> [rw [← w ⟨walking_pair.left⟩]; rw [← w ⟨walking_pair.right⟩]] <;> rfl }
 #align AddCommGroup.binary_product_limit_cone AddCommGroupCat.binaryProductLimitCone
 -/

f60c6087

bump to nightly-2023-06-01-04

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

4d9eaa85

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 
 ! This file was ported from Lean 3 source module algebra.category.Group.biproducts
-! leanprover-community/mathlib commit 234ddfeaa5572bc13716dd215c6444410a679a8e
+! leanprover-community/mathlib commit f60c6087a7275b72d5db3c5a1d0e19e35a429c0a
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -15,6 +15,9 @@ import Mathbin.Algebra.Category.Group.Limits
 
 /-!
 # The category of abelian groups has finite biproducts
+
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
 -/

234ddfea

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -22,7 +22,7 @@ open CategoryTheory
 
 open CategoryTheory.Limits
 
-open BigOperators
+open scoped BigOperators
 
 universe w u

234ddfea

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -58,30 +58,18 @@ def binaryProductLimitCone (G H : AddCommGroupCat.{u}) : Limits.LimitCone (pair
 #align AddCommGroup.binary_product_limit_cone AddCommGroupCat.binaryProductLimitCone
 -/
 
-/- warning: AddCommGroup.binary_product_limit_cone_cone_π_app_left -> AddCommGroupCat.binaryProductLimitCone_cone_π_app_left is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.binary_product_limit_cone_cone_π_app_left AddCommGroupCat.binaryProductLimitCone_cone_π_app_leftₓ'. -/
 @[simp]
 theorem binaryProductLimitCone_cone_π_app_left (G H : AddCommGroupCat.{u}) :
     (binaryProductLimitCone G H).Cone.π.app ⟨WalkingPair.left⟩ = AddMonoidHom.fst G H :=
   rfl
 #align AddCommGroup.binary_product_limit_cone_cone_π_app_left AddCommGroupCat.binaryProductLimitCone_cone_π_app_left
 
-/- warning: AddCommGroup.binary_product_limit_cone_cone_π_app_right -> AddCommGroupCat.binaryProductLimitCone_cone_π_app_right is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.binary_product_limit_cone_cone_π_app_right AddCommGroupCat.binaryProductLimitCone_cone_π_app_rightₓ'. -/
 @[simp]
 theorem binaryProductLimitCone_cone_π_app_right (G H : AddCommGroupCat.{u}) :
     (binaryProductLimitCone G H).Cone.π.app ⟨WalkingPair.right⟩ = AddMonoidHom.snd G H :=
   rfl
 #align AddCommGroup.binary_product_limit_cone_cone_π_app_right AddCommGroupCat.binaryProductLimitCone_cone_π_app_right
 
-/- warning: AddCommGroup.biprod_iso_prod -> AddCommGroupCat.biprodIsoProd is a dubious translation:
-lean 3 declaration is
-  forall (G : AddCommGroupCat.{u1}) (H : AddCommGroupCat.{u1}), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.biprod.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H (AddCommGroupCat.biprodIsoProd._proof_1.{u1} G H)) (AddCommGroupCat.of.{u1} (Prod.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} G) (coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} H)) (Prod.addCommGroup.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} G) (coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} H) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} H)))
-but is expected to have type
-  forall (G : AddCommGroupCat.{u1}) (H : AddCommGroupCat.{u1}), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.biprod.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H (CategoryTheory.Limits.HasBinaryBiproducts.has_binary_biproduct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) AddCommGroupCat.instHasBinaryBiproductsAddCommGroupCatInstAddCommGroupCatLargeCategoryPreadditiveHasZeroMorphismsInstPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1} G H)) (AddCommGroupCat.of.{u1} (Prod.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H)) (Prod.instAddCommGroupSum.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} H)))
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.biprod_iso_prod AddCommGroupCat.biprodIsoProdₓ'. -/
 /-- We verify that the biproduct in AddCommGroup is isomorphic to
 the cartesian product of the underlying types:
 -/
@@ -91,18 +79,12 @@ noncomputable def biprodIsoProd (G H : AddCommGroupCat.{u}) :
   IsLimit.conePointUniqueUpToIso (BinaryBiproduct.isLimit G H) (binaryProductLimitCone G H).IsLimit
 #align AddCommGroup.biprod_iso_prod AddCommGroupCat.biprodIsoProd
 
-/- warning: AddCommGroup.biprod_iso_prod_inv_comp_fst -> AddCommGroupCat.biprodIsoProd_inv_comp_fst is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.biprod_iso_prod_inv_comp_fst AddCommGroupCat.biprodIsoProd_inv_comp_fstₓ'. -/
 @[simp, elementwise]
 theorem biprodIsoProd_inv_comp_fst (G H : AddCommGroupCat.{u}) :
     (biprodIsoProd G H).inv ≫ biprod.fst = AddMonoidHom.fst G H :=
   IsLimit.conePointUniqueUpToIso_inv_comp _ _ (Discrete.mk WalkingPair.left)
 #align AddCommGroup.biprod_iso_prod_inv_comp_fst AddCommGroupCat.biprodIsoProd_inv_comp_fst
 
-/- warning: AddCommGroup.biprod_iso_prod_inv_comp_snd -> AddCommGroupCat.biprodIsoProd_inv_comp_snd is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.biprod_iso_prod_inv_comp_snd AddCommGroupCat.biprodIsoProd_inv_comp_sndₓ'. -/
 @[simp, elementwise]
 theorem biprodIsoProd_inv_comp_snd (G H : AddCommGroupCat.{u}) :
     (biprodIsoProd G H).inv ≫ biprod.snd = AddMonoidHom.snd G H :=
@@ -152,12 +134,6 @@ open HasLimit
 
 variable {J : Type} [Fintype J]
 
-/- warning: AddCommGroup.biproduct_iso_pi -> AddCommGroupCat.biproductIsoPi is a dubious translation:
-lean 3 declaration is
-  forall {J : Type} [_inst_1 : Fintype.{0} J] (f : J -> AddCommGroupCat.{u1}), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) f (AddCommGroupCat.biproductIsoPi._proof_1.{u1} J _inst_1 f)) (AddCommGroupCat.of.{u1} (forall (j : J), coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i))))
-but is expected to have type
-  forall {J : Type} [_inst_1 : Fintype.{0} J] (f : J -> AddCommGroupCat.{u1}), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) f (CategoryTheory.Limits.HasBiproductsOfShape.has_biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasBiproductsOfShape_finite.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) AddCommGroupCat.instHasFiniteBiproductsAddCommGroupCatInstAddCommGroupCatLargeCategoryPreadditiveHasZeroMorphismsInstPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1} (Finite.of_fintype.{0} J _inst_1)) f)) (AddCommGroupCat.of.{u1} (forall (j : J), CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i))))
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.biproduct_iso_pi AddCommGroupCat.biproductIsoPiₓ'. -/
 /-- We verify that the biproduct we've just defined is isomorphic to the AddCommGroup structure
 on the dependent function type
 -/
@@ -167,12 +143,6 @@ noncomputable def biproductIsoPi (f : J → AddCommGroupCat.{u}) :
   IsLimit.conePointUniqueUpToIso (biproduct.isLimit f) (productLimitCone f).IsLimit
 #align AddCommGroup.biproduct_iso_pi AddCommGroupCat.biproductIsoPi
 
-/- warning: AddCommGroup.biproduct_iso_pi_inv_comp_π -> AddCommGroupCat.biproductIsoPi_inv_comp_π is a dubious translation:
-lean 3 declaration is
-  forall {J : Type} [_inst_1 : Fintype.{0} J] (f : J -> AddCommGroupCat.{u1}) (j : J), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1})) (AddCommGroupCat.of.{u1} (forall (j : J), coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (f j)) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1}) (AddCommGroupCat.of.{u1} (forall (j : J), coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) f (AddCommGroupCat.biproductIsoPi._proof_1.{u1} J _inst_1 f)) (f j) (CategoryTheory.Iso.inv.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) f (AddCommGroupCat.biproductIsoPi._proof_1.{u1} J _inst_1 f)) (AddCommGroupCat.of.{u1} (forall (j : J), coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (AddCommGroupCat.biproductIsoPi.{u1} J _inst_1 f)) (CategoryTheory.Limits.biproduct.π.{0, u1, succ u1} J AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) f (AddCommGroupCat.biproductIsoPi._proof_1.{u1} J _inst_1 f) j)) (Pi.evalAddMonoidHom.{0, u1} J (fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (fun (_x : J) => AddMonoid.toAddZeroClass.{u1} ((fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) _x) (SubNegMonoid.toAddMonoid.{u1} ((fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) _x) (AddGroup.toSubNegMonoid.{u1} ((fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) _x) (AddCommGroup.toAddGroup.{u1} ((fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) _x) ((fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)) _x))))) j)
-but is expected to have type
-  forall {J : Type} [_inst_1 : Fintype.{0} J] (f : J -> AddCommGroupCat.{u1}) (j : J), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1})) (AddCommGroupCat.of.{u1} (forall (j : J), CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (f j)) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1}) (AddCommGroupCat.of.{u1} (forall (j : J), CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) f (CategoryTheory.Limits.HasBiproductsOfShape.has_biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasBiproductsOfShape_finite.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) AddCommGroupCat.instHasFiniteBiproductsAddCommGroupCatInstAddCommGroupCatLargeCategoryPreadditiveHasZeroMorphismsInstPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1} (Finite.of_fintype.{0} J _inst_1)) f)) (f j) (CategoryTheory.Iso.inv.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) f (CategoryTheory.Limits.HasBiproductsOfShape.has_biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasBiproductsOfShape_finite.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) AddCommGroupCat.instHasFiniteBiproductsAddCommGroupCatInstAddCommGroupCatLargeCategoryPreadditiveHasZeroMorphismsInstPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1} (Finite.of_fintype.{0} J _inst_1)) f)) (AddCommGroupCat.of.{u1} (forall (j : J), CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (AddCommGroupCat.biproductIsoPi.{u1} J _inst_1 f)) (CategoryTheory.Limits.biproduct.π.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) f (CategoryTheory.Limits.HasBiproductsOfShape.has_biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasBiproductsOfShape_finite.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) AddCommGroupCat.instHasFiniteBiproductsAddCommGroupCatInstAddCommGroupCatLargeCategoryPreadditiveHasZeroMorphismsInstPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1} (Finite.of_fintype.{0} J _inst_1)) f) j)) (Pi.evalAddMonoidHom.{0, u1} J (fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (fun (_x : J) => AddMonoid.toAddZeroClass.{u1} ((fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) _x) (SubNegMonoid.toAddMonoid.{u1} ((fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) _x) (AddGroup.toSubNegMonoid.{u1} ((fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) _x) (AddCommGroup.toAddGroup.{u1} ((fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) _x) (AddCommGroupCat.addCommGroupInstance.{u1} (f _x)))))) j)
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.biproduct_iso_pi_inv_comp_π AddCommGroupCat.biproductIsoPi_inv_comp_πₓ'. -/
 @[simp, elementwise]
 theorem biproductIsoPi_inv_comp_π (f : J → AddCommGroupCat.{u}) (j : J) :
     (biproductIsoPi f).inv ≫ biproduct.π f j = Pi.evalAddMonoidHom (fun j => f j) j :=

234ddfea

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -52,10 +52,7 @@ def binaryProductLimitCone (G H : AddCommGroupCat.{u}) : Limits.LimitCone (pair
           naturality' := by rintro ⟨⟨⟩⟩ ⟨⟨⟩⟩ ⟨⟨⟨⟩⟩⟩ <;> rfl } }
   IsLimit :=
     { lift := fun s => AddMonoidHom.prod (s.π.app ⟨WalkingPair.left⟩) (s.π.app ⟨WalkingPair.right⟩)
-      fac := by
-        rintro s (⟨⟩ | ⟨⟩) <;>
-          · ext x
-            simp
+      fac := by rintro s (⟨⟩ | ⟨⟩) <;> · ext x; simp
       uniq := fun s m w => by
         ext <;> [rw [← w ⟨walking_pair.left⟩];rw [← w ⟨walking_pair.right⟩]] <;> rfl }
 #align AddCommGroup.binary_product_limit_cone AddCommGroupCat.binaryProductLimitCone
@@ -124,12 +121,8 @@ to the cartesian product of those groups.
 def lift (s : Fan f) : s.pt ⟶ AddCommGroupCat.of (∀ j, f j)
     where
   toFun x j := s.π.app ⟨j⟩ x
-  map_zero' := by
-    ext
-    simp
-  map_add' x y := by
-    ext
-    simp
+  map_zero' := by ext; simp
+  map_add' x y := by ext; simp
 #align AddCommGroup.has_limit.lift AddCommGroupCat.HasLimit.lift
 -/
 
@@ -144,10 +137,7 @@ def productLimitCone : Limits.LimitCone (Discrete.functor f)
       π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => f j) j.as }
   IsLimit :=
     { lift := lift f
-      fac := fun s j => by
-        cases j
-        ext
-        simp
+      fac := fun s j => by cases j; ext; simp
       uniq := fun s m w => by
         ext (x j)
         dsimp only [has_limit.lift]

234ddfea

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -35,6 +35,7 @@ instance : HasBinaryBiproducts AddCommGroupCat :=
 instance : HasFiniteBiproducts AddCommGroupCat :=
   HasFiniteBiproducts.of_hasFiniteProducts
 
+#print AddCommGroupCat.binaryProductLimitCone /-
 -- We now construct explicit limit data,
 -- so we can compare the biproducts to the usual unbundled constructions.
 /-- Construct limit data for a binary product in `AddCommGroup`, using `AddCommGroup.of (G × H)`.
@@ -58,19 +59,32 @@ def binaryProductLimitCone (G H : AddCommGroupCat.{u}) : Limits.LimitCone (pair
       uniq := fun s m w => by
         ext <;> [rw [← w ⟨walking_pair.left⟩];rw [← w ⟨walking_pair.right⟩]] <;> rfl }
 #align AddCommGroup.binary_product_limit_cone AddCommGroupCat.binaryProductLimitCone
+-/
 
+/- warning: AddCommGroup.binary_product_limit_cone_cone_π_app_left -> AddCommGroupCat.binaryProductLimitCone_cone_π_app_left is a dubious translation:
+<too large>
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.binary_product_limit_cone_cone_π_app_left AddCommGroupCat.binaryProductLimitCone_cone_π_app_leftₓ'. -/
 @[simp]
 theorem binaryProductLimitCone_cone_π_app_left (G H : AddCommGroupCat.{u}) :
     (binaryProductLimitCone G H).Cone.π.app ⟨WalkingPair.left⟩ = AddMonoidHom.fst G H :=
   rfl
 #align AddCommGroup.binary_product_limit_cone_cone_π_app_left AddCommGroupCat.binaryProductLimitCone_cone_π_app_left
 
+/- warning: AddCommGroup.binary_product_limit_cone_cone_π_app_right -> AddCommGroupCat.binaryProductLimitCone_cone_π_app_right is a dubious translation:
+<too large>
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.binary_product_limit_cone_cone_π_app_right AddCommGroupCat.binaryProductLimitCone_cone_π_app_rightₓ'. -/
 @[simp]
 theorem binaryProductLimitCone_cone_π_app_right (G H : AddCommGroupCat.{u}) :
     (binaryProductLimitCone G H).Cone.π.app ⟨WalkingPair.right⟩ = AddMonoidHom.snd G H :=
   rfl
 #align AddCommGroup.binary_product_limit_cone_cone_π_app_right AddCommGroupCat.binaryProductLimitCone_cone_π_app_right
 
+/- warning: AddCommGroup.biprod_iso_prod -> AddCommGroupCat.biprodIsoProd is a dubious translation:
+lean 3 declaration is
+  forall (G : AddCommGroupCat.{u1}) (H : AddCommGroupCat.{u1}), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.biprod.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) G H (AddCommGroupCat.biprodIsoProd._proof_1.{u1} G H)) (AddCommGroupCat.of.{u1} (Prod.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} G) (coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} H)) (Prod.addCommGroup.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} G) (coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} H) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} H)))
+but is expected to have type
+  forall (G : AddCommGroupCat.{u1}) (H : AddCommGroupCat.{u1}), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.biprod.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H (CategoryTheory.Limits.HasBinaryBiproducts.has_binary_biproduct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) AddCommGroupCat.instHasBinaryBiproductsAddCommGroupCatInstAddCommGroupCatLargeCategoryPreadditiveHasZeroMorphismsInstPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1} G H)) (AddCommGroupCat.of.{u1} (Prod.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H)) (Prod.instAddCommGroupSum.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} H)))
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.biprod_iso_prod AddCommGroupCat.biprodIsoProdₓ'. -/
 /-- We verify that the biproduct in AddCommGroup is isomorphic to
 the cartesian product of the underlying types:
 -/
@@ -80,12 +94,18 @@ noncomputable def biprodIsoProd (G H : AddCommGroupCat.{u}) :
   IsLimit.conePointUniqueUpToIso (BinaryBiproduct.isLimit G H) (binaryProductLimitCone G H).IsLimit
 #align AddCommGroup.biprod_iso_prod AddCommGroupCat.biprodIsoProd
 
+/- warning: AddCommGroup.biprod_iso_prod_inv_comp_fst -> AddCommGroupCat.biprodIsoProd_inv_comp_fst is a dubious translation:
+<too large>
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.biprod_iso_prod_inv_comp_fst AddCommGroupCat.biprodIsoProd_inv_comp_fstₓ'. -/
 @[simp, elementwise]
 theorem biprodIsoProd_inv_comp_fst (G H : AddCommGroupCat.{u}) :
     (biprodIsoProd G H).inv ≫ biprod.fst = AddMonoidHom.fst G H :=
   IsLimit.conePointUniqueUpToIso_inv_comp _ _ (Discrete.mk WalkingPair.left)
 #align AddCommGroup.biprod_iso_prod_inv_comp_fst AddCommGroupCat.biprodIsoProd_inv_comp_fst
 
+/- warning: AddCommGroup.biprod_iso_prod_inv_comp_snd -> AddCommGroupCat.biprodIsoProd_inv_comp_snd is a dubious translation:
+<too large>
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.biprod_iso_prod_inv_comp_snd AddCommGroupCat.biprodIsoProd_inv_comp_sndₓ'. -/
 @[simp, elementwise]
 theorem biprodIsoProd_inv_comp_snd (G H : AddCommGroupCat.{u}) :
     (biprodIsoProd G H).inv ≫ biprod.snd = AddMonoidHom.snd G H :=
@@ -96,6 +116,7 @@ namespace HasLimit
 
 variable {J : Type w} (f : J → AddCommGroupCat.{max w u})
 
+#print AddCommGroupCat.HasLimit.lift /-
 /-- The map from an arbitrary cone over a indexed family of abelian groups
 to the cartesian product of those groups.
 -/
@@ -110,7 +131,9 @@ def lift (s : Fan f) : s.pt ⟶ AddCommGroupCat.of (∀ j, f j)
     ext
     simp
 #align AddCommGroup.has_limit.lift AddCommGroupCat.HasLimit.lift
+-/
 
+#print AddCommGroupCat.HasLimit.productLimitCone /-
 /-- Construct limit data for a product in `AddCommGroup`, using `AddCommGroup.of (Π j, F.obj j)`.
 -/
 @[simps]
@@ -131,6 +154,7 @@ def productLimitCone : Limits.LimitCone (Discrete.functor f)
         simp only [AddMonoidHom.coe_mk]
         exact congr_arg (fun g : s.X ⟶ f j => (g : s.X → f j) x) (w ⟨j⟩) }
 #align AddCommGroup.has_limit.product_limit_cone AddCommGroupCat.HasLimit.productLimitCone
+-/
 
 end HasLimit
 
@@ -138,6 +162,12 @@ open HasLimit
 
 variable {J : Type} [Fintype J]
 
+/- warning: AddCommGroup.biproduct_iso_pi -> AddCommGroupCat.biproductIsoPi is a dubious translation:
+lean 3 declaration is
+  forall {J : Type} [_inst_1 : Fintype.{0} J] (f : J -> AddCommGroupCat.{u1}), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) f (AddCommGroupCat.biproductIsoPi._proof_1.{u1} J _inst_1 f)) (AddCommGroupCat.of.{u1} (forall (j : J), coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i))))
+but is expected to have type
+  forall {J : Type} [_inst_1 : Fintype.{0} J] (f : J -> AddCommGroupCat.{u1}), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) f (CategoryTheory.Limits.HasBiproductsOfShape.has_biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasBiproductsOfShape_finite.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) AddCommGroupCat.instHasFiniteBiproductsAddCommGroupCatInstAddCommGroupCatLargeCategoryPreadditiveHasZeroMorphismsInstPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1} (Finite.of_fintype.{0} J _inst_1)) f)) (AddCommGroupCat.of.{u1} (forall (j : J), CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i))))
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.biproduct_iso_pi AddCommGroupCat.biproductIsoPiₓ'. -/
 /-- We verify that the biproduct we've just defined is isomorphic to the AddCommGroup structure
 on the dependent function type
 -/
@@ -147,6 +177,12 @@ noncomputable def biproductIsoPi (f : J → AddCommGroupCat.{u}) :
   IsLimit.conePointUniqueUpToIso (biproduct.isLimit f) (productLimitCone f).IsLimit
 #align AddCommGroup.biproduct_iso_pi AddCommGroupCat.biproductIsoPi
 
+/- warning: AddCommGroup.biproduct_iso_pi_inv_comp_π -> AddCommGroupCat.biproductIsoPi_inv_comp_π is a dubious translation:
+lean 3 declaration is
+  forall {J : Type} [_inst_1 : Fintype.{0} J] (f : J -> AddCommGroupCat.{u1}) (j : J), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1})) (AddCommGroupCat.of.{u1} (forall (j : J), coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (f j)) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1}) (AddCommGroupCat.of.{u1} (forall (j : J), coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) f (AddCommGroupCat.biproductIsoPi._proof_1.{u1} J _inst_1 f)) (f j) (CategoryTheory.Iso.inv.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) f (AddCommGroupCat.biproductIsoPi._proof_1.{u1} J _inst_1 f)) (AddCommGroupCat.of.{u1} (forall (j : J), coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (AddCommGroupCat.biproductIsoPi.{u1} J _inst_1 f)) (CategoryTheory.Limits.biproduct.π.{0, u1, succ u1} J AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} AddCommGroupCat.CategoryTheory.preadditive.{u1}) f (AddCommGroupCat.biproductIsoPi._proof_1.{u1} J _inst_1 f) j)) (Pi.evalAddMonoidHom.{0, u1} J (fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) (fun (_x : J) => AddMonoid.toAddZeroClass.{u1} ((fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) _x) (SubNegMonoid.toAddMonoid.{u1} ((fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) _x) (AddGroup.toSubNegMonoid.{u1} ((fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) _x) (AddCommGroup.toAddGroup.{u1} ((fun (j : J) => coeSort.{succ (succ u1), succ (succ u1)} AddCommGroupCat.{u1} Type.{u1} AddCommGroupCat.hasCoeToSort.{u1} (f j)) _x) ((fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)) _x))))) j)
+but is expected to have type
+  forall {J : Type} [_inst_1 : Fintype.{0} J] (f : J -> AddCommGroupCat.{u1}) (j : J), Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1})) (AddCommGroupCat.of.{u1} (forall (j : J), CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (f j)) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1}) (AddCommGroupCat.of.{u1} (forall (j : J), CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) f (CategoryTheory.Limits.HasBiproductsOfShape.has_biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasBiproductsOfShape_finite.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) AddCommGroupCat.instHasFiniteBiproductsAddCommGroupCatInstAddCommGroupCatLargeCategoryPreadditiveHasZeroMorphismsInstPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1} (Finite.of_fintype.{0} J _inst_1)) f)) (f j) (CategoryTheory.Iso.inv.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) f (CategoryTheory.Limits.HasBiproductsOfShape.has_biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasBiproductsOfShape_finite.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) AddCommGroupCat.instHasFiniteBiproductsAddCommGroupCatInstAddCommGroupCatLargeCategoryPreadditiveHasZeroMorphismsInstPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1} (Finite.of_fintype.{0} J _inst_1)) f)) (AddCommGroupCat.of.{u1} (forall (j : J), CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (Pi.addCommGroup.{0, u1} J (fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (fun (i : J) => AddCommGroupCat.addCommGroupInstance.{u1} (f i)))) (AddCommGroupCat.biproductIsoPi.{u1} J _inst_1 f)) (CategoryTheory.Limits.biproduct.π.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) f (CategoryTheory.Limits.HasBiproductsOfShape.has_biproduct.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasBiproductsOfShape_finite.{0, u1, succ u1} J AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) AddCommGroupCat.instHasFiniteBiproductsAddCommGroupCatInstAddCommGroupCatLargeCategoryPreadditiveHasZeroMorphismsInstPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1} (Finite.of_fintype.{0} J _inst_1)) f) j)) (Pi.evalAddMonoidHom.{0, u1} J (fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) (fun (_x : J) => AddMonoid.toAddZeroClass.{u1} ((fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) _x) (SubNegMonoid.toAddMonoid.{u1} ((fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) _x) (AddGroup.toSubNegMonoid.{u1} ((fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) _x) (AddCommGroup.toAddGroup.{u1} ((fun (j : J) => CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} (f j)) _x) (AddCommGroupCat.addCommGroupInstance.{u1} (f _x)))))) j)
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.biproduct_iso_pi_inv_comp_π AddCommGroupCat.biproductIsoPi_inv_comp_πₓ'. -/
 @[simp, elementwise]
 theorem biproductIsoPi_inv_comp_π (f : J → AddCommGroupCat.{u}) (j : J) :
     (biproductIsoPi f).inv ≫ biproduct.π f j = Pi.evalAddMonoidHom (fun j => f j) j :=

234ddfea

bump to nightly-2023-05-24-06

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

fbc7b476

Diff

@@ -56,7 +56,7 @@ def binaryProductLimitCone (G H : AddCommGroupCat.{u}) : Limits.LimitCone (pair
           · ext x
             simp
       uniq := fun s m w => by
-        ext <;> [rw [← w ⟨walking_pair.left⟩], rw [← w ⟨walking_pair.right⟩]] <;> rfl }
+        ext <;> [rw [← w ⟨walking_pair.left⟩];rw [← w ⟨walking_pair.right⟩]] <;> rfl }
 #align AddCommGroup.binary_product_limit_cone AddCommGroupCat.binaryProductLimitCone
 
 @[simp]

234ddfea

bump to nightly-2023-03-08-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

b313bdac

Diff

@@ -144,7 +144,7 @@ on the dependent function type
 @[simps hom_apply]
 noncomputable def biproductIsoPi (f : J → AddCommGroupCat.{u}) :
     (⨁ f : AddCommGroupCat) ≅ AddCommGroupCat.of (∀ j, f j) :=
-  IsLimit.conePointUniqueUpToIso (Biproduct.isLimit f) (productLimitCone f).IsLimit
+  IsLimit.conePointUniqueUpToIso (biproduct.isLimit f) (productLimitCone f).IsLimit
 #align AddCommGroup.biproduct_iso_pi AddCommGroupCat.biproductIsoPi
 
 @[simp, elementwise]

234ddfea

bump to nightly-2023-02-28-22

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

1fb1623f

Diff

@@ -43,7 +43,7 @@ instance : HasFiniteBiproducts AddCommGroupCat :=
 def binaryProductLimitCone (G H : AddCommGroupCat.{u}) : Limits.LimitCone (pair G H)
     where
   Cone :=
-    { x := AddCommGroupCat.of (G × H)
+    { pt := AddCommGroupCat.of (G × H)
       π :=
         { app := fun j =>
             Discrete.casesOn j fun j =>
@@ -100,7 +100,7 @@ variable {J : Type w} (f : J → AddCommGroupCat.{max w u})
 to the cartesian product of those groups.
 -/
 @[simps]
-def lift (s : Fan f) : s.x ⟶ AddCommGroupCat.of (∀ j, f j)
+def lift (s : Fan f) : s.pt ⟶ AddCommGroupCat.of (∀ j, f j)
     where
   toFun x j := s.π.app ⟨j⟩ x
   map_zero' := by
@@ -117,7 +117,7 @@ def lift (s : Fan f) : s.x ⟶ AddCommGroupCat.of (∀ j, f j)
 def productLimitCone : Limits.LimitCone (Discrete.functor f)
     where
   Cone :=
-    { x := AddCommGroupCat.of (∀ j, f j)
+    { pt := AddCommGroupCat.of (∀ j, f j)
       π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => f j) j.as }
   IsLimit :=
     { lift := lift f

234ddfea

bump to nightly-2023-02-27-08

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

91d8c210

Diff

@@ -30,10 +30,10 @@ namespace AddCommGroupCat
 
 -- As `AddCommGroup` is preadditive, and has all limits, it automatically has biproducts.
 instance : HasBinaryBiproducts AddCommGroupCat :=
-  HasBinaryBiproducts.ofHasBinaryProducts
+  HasBinaryBiproducts.of_hasBinaryProducts
 
 instance : HasFiniteBiproducts AddCommGroupCat :=
-  HasFiniteBiproducts.ofHasFiniteProducts
+  HasFiniteBiproducts.of_hasFiniteProducts
 
 -- We now construct explicit limit data,
 -- so we can compare the biproducts to the usual unbundled constructions.
@@ -51,11 +51,11 @@ def binaryProductLimitCone (G H : AddCommGroupCat.{u}) : Limits.LimitCone (pair
           naturality' := by rintro ⟨⟨⟩⟩ ⟨⟨⟩⟩ ⟨⟨⟨⟩⟩⟩ <;> rfl } }
   IsLimit :=
     { lift := fun s => AddMonoidHom.prod (s.π.app ⟨WalkingPair.left⟩) (s.π.app ⟨WalkingPair.right⟩)
-      fac' := by
+      fac := by
         rintro s (⟨⟩ | ⟨⟩) <;>
           · ext x
             simp
-      uniq' := fun s m w => by
+      uniq := fun s m w => by
         ext <;> [rw [← w ⟨walking_pair.left⟩], rw [← w ⟨walking_pair.right⟩]] <;> rfl }
 #align AddCommGroup.binary_product_limit_cone AddCommGroupCat.binaryProductLimitCone
 
@@ -121,11 +121,11 @@ def productLimitCone : Limits.LimitCone (Discrete.functor f)
       π := Discrete.natTrans fun j => Pi.evalAddMonoidHom (fun j => f j) j.as }
   IsLimit :=
     { lift := lift f
-      fac' := fun s j => by
+      fac := fun s j => by
         cases j
         ext
         simp
-      uniq' := fun s m w => by
+      uniq := fun s m w => by
         ext (x j)
         dsimp only [has_limit.lift]
         simp only [AddMonoidHom.coe_mk]

234ddfea

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

234ddfea

chore: remove some unnecessary 'open BigOperators' (#11880)

Could we have an open linter, that checked for unused opened namespaces?

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

16eb4bdf

Diff

@@ -20,8 +20,6 @@ open CategoryTheory
 
 open CategoryTheory.Limits
 
-open BigOperators
-
 universe w u
 
 namespace AddCommGroupCat

234ddfea

move: Algebraic pi instances (#10693)

Rename

Data.Pi.Algebra to Algebra.Group.Pi.Basic
Algebra.Group.Pi to Algebra.Group.Pi.Lemmas

Move a few instances from the latter to the former, the goal being that Algebra.Group.Pi.Basic is about all the pi instances of the classes defined in Algebra.Group.Defs. Algebra.Group.Pi.Lemmas will need further rearranging.

c76aa9d6

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
 -/
-import Mathlib.Algebra.Group.Pi
+import Mathlib.Algebra.Group.Pi.Lemmas
 import Mathlib.Algebra.Category.GroupCat.Preadditive
 import Mathlib.CategoryTheory.Preadditive.Biproducts
 import Mathlib.Algebra.Category.GroupCat.Limits

234ddfea

chore(Algebra/Category): Fintype -> Finite (#10290)

3fea559c

Diff

@@ -131,7 +131,7 @@ end HasLimit
 
 open HasLimit
 
-variable {J : Type} [Fintype J]
+variable {J : Type} [Finite J]
 
 /-- We verify that the biproduct we've just defined is isomorphic to the `AddCommGroupCat` structure
 on the dependent function type.

234ddfea

chore: reduce imports (#9830)

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

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

f4c4ca61

Diff

@@ -7,6 +7,7 @@ import Mathlib.Algebra.Group.Pi
 import Mathlib.Algebra.Category.GroupCat.Preadditive
 import Mathlib.CategoryTheory.Preadditive.Biproducts
 import Mathlib.Algebra.Category.GroupCat.Limits
+import Mathlib.Tactic.CategoryTheory.Elementwise
 
 #align_import algebra.category.Group.biproducts from "leanprover-community/mathlib"@"234ddfeaa5572bc13716dd215c6444410a679a8e"

234ddfea

Revert "chore: revert #7703 (#7710)"

This reverts commit f3695eb2.

ab56fa28

Diff

@@ -76,6 +76,9 @@ noncomputable def biprodIsoProd (G H : AddCommGroupCat.{u}) :
   IsLimit.conePointUniqueUpToIso (BinaryBiproduct.isLimit G H) (binaryProductLimitCone G H).isLimit
 #align AddCommGroup.biprod_iso_prod AddCommGroupCat.biprodIsoProd
 
+-- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
+attribute [nolint simpNF] AddCommGroupCat.biprodIsoProd_hom_apply
+
 @[simp, elementwise]
 theorem biprodIsoProd_inv_comp_fst (G H : AddCommGroupCat.{u}) :
     (biprodIsoProd G H).inv ≫ biprod.fst = AddMonoidHom.fst G H :=
@@ -138,6 +141,9 @@ noncomputable def biproductIsoPi (f : J → AddCommGroupCat.{u}) :
   IsLimit.conePointUniqueUpToIso (biproduct.isLimit f) (productLimitCone f).isLimit
 #align AddCommGroup.biproduct_iso_pi AddCommGroupCat.biproductIsoPi
 
+-- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
+attribute [nolint simpNF] AddCommGroupCat.biproductIsoPi_hom_apply
+
 @[simp, elementwise]
 theorem biproductIsoPi_inv_comp_π (f : J → AddCommGroupCat.{u}) (j : J) :
     (biproductIsoPi f).inv ≫ biproduct.π f j = Pi.evalAddMonoidHom (fun j => f j) j :=

234ddfea

chore: revert #7703 (#7710)

This reverts commit 26eb2b0a.

f3695eb2

Diff

@@ -76,9 +76,6 @@ noncomputable def biprodIsoProd (G H : AddCommGroupCat.{u}) :
   IsLimit.conePointUniqueUpToIso (BinaryBiproduct.isLimit G H) (binaryProductLimitCone G H).isLimit
 #align AddCommGroup.biprod_iso_prod AddCommGroupCat.biprodIsoProd
 
--- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
-attribute [nolint simpNF] AddCommGroupCat.biprodIsoProd_hom_apply
-
 @[simp, elementwise]
 theorem biprodIsoProd_inv_comp_fst (G H : AddCommGroupCat.{u}) :
     (biprodIsoProd G H).inv ≫ biprod.fst = AddMonoidHom.fst G H :=
@@ -141,9 +138,6 @@ noncomputable def biproductIsoPi (f : J → AddCommGroupCat.{u}) :
   IsLimit.conePointUniqueUpToIso (biproduct.isLimit f) (productLimitCone f).isLimit
 #align AddCommGroup.biproduct_iso_pi AddCommGroupCat.biproductIsoPi
 
--- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
-attribute [nolint simpNF] AddCommGroupCat.biproductIsoPi_hom_apply
-
 @[simp, elementwise]
 theorem biproductIsoPi_inv_comp_π (f : J → AddCommGroupCat.{u}) (j : J) :
     (biproductIsoPi f).inv ≫ biproduct.π f j = Pi.evalAddMonoidHom (fun j => f j) j :=

234ddfea

chore: bump toolchain to v4.2.0-rc2 (#7703)

This includes all the changes from #7606.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

26eb2b0a

Diff

@@ -76,6 +76,9 @@ noncomputable def biprodIsoProd (G H : AddCommGroupCat.{u}) :
   IsLimit.conePointUniqueUpToIso (BinaryBiproduct.isLimit G H) (binaryProductLimitCone G H).isLimit
 #align AddCommGroup.biprod_iso_prod AddCommGroupCat.biprodIsoProd
 
+-- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
+attribute [nolint simpNF] AddCommGroupCat.biprodIsoProd_hom_apply
+
 @[simp, elementwise]
 theorem biprodIsoProd_inv_comp_fst (G H : AddCommGroupCat.{u}) :
     (biprodIsoProd G H).inv ≫ biprod.fst = AddMonoidHom.fst G H :=
@@ -138,6 +141,9 @@ noncomputable def biproductIsoPi (f : J → AddCommGroupCat.{u}) :
   IsLimit.conePointUniqueUpToIso (biproduct.isLimit f) (productLimitCone f).isLimit
 #align AddCommGroup.biproduct_iso_pi AddCommGroupCat.biproductIsoPi
 
+-- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
+attribute [nolint simpNF] AddCommGroupCat.biproductIsoPi_hom_apply
+
 @[simp, elementwise]
 theorem biproductIsoPi_inv_comp_π (f : J → AddCommGroupCat.{u}) (j : J) :
     (biproductIsoPi f).inv ≫ biproduct.π f j = Pi.evalAddMonoidHom (fun j => f j) j :=

234ddfea

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,17 +2,14 @@
 Copyright (c) 2020 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison
-
-! This file was ported from Lean 3 source module algebra.category.Group.biproducts
-! leanprover-community/mathlib commit 234ddfeaa5572bc13716dd215c6444410a679a8e
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Group.Pi
 import Mathlib.Algebra.Category.GroupCat.Preadditive
 import Mathlib.CategoryTheory.Preadditive.Biproducts
 import Mathlib.Algebra.Category.GroupCat.Limits
 
+#align_import algebra.category.Group.biproducts from "leanprover-community/mathlib"@"234ddfeaa5572bc13716dd215c6444410a679a8e"
+
 /-!
 # The category of abelian groups has finite biproducts
 -/

234ddfea

chore: fix grammar 1/3 (#5001)

All of these are doc fixes

d8caa37d

Diff

@@ -95,7 +95,7 @@ namespace HasLimit
 
 variable {J : Type w} (f : J → AddCommGroupCat.{max w u})
 
-/-- The map from an arbitrary cone over a indexed family of abelian groups
+/-- The map from an arbitrary cone over an indexed family of abelian groups
 to the cartesian product of those groups.
 -/
 @[simps]

234ddfea

feat: port Algebra.Category.GroupCat.Biproducts (#4411)

ba4e1ad1

`algebra.category.Group.biproducts` ⟷ `Mathlib.Algebra.Category.GroupCat.Biproducts`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 4 + 357

algebra.category.Group.biproducts ⟷ Mathlib.Algebra.Category.GroupCat.Biproducts

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 4 + 357

`algebra.category.Group.biproducts` ⟷ `Mathlib.Algebra.Category.GroupCat.Biproducts`