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

70fd9563

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

4280f5f3

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,9 +3,9 @@ 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.Category.Mon.Limits
-import Algebra.Category.Group.Preadditive
-import CategoryTheory.Over
+import Algebra.Category.MonCat.Limits
+import Algebra.Category.GroupCat.Preadditive
+import CategoryTheory.Comma.Over
 import GroupTheory.Subgroup.Basic
 import CategoryTheory.ConcreteCategory.Elementwise
 
@@ -146,13 +146,13 @@ instance hasLimits : HasLimits GroupCat.{u} :=
 
 This means the underlying monoid of a limit can be computed as a limit in the category of monoids.
 -/
-@[to_additive AddGroupCat.forget₂AddMonPreservesLimits
+@[to_additive AddGroupCat.forget₂AddMonPreservesLimitsOfSize
       "The forgetful functor from additive groups\nto additive monoids preserves all limits.\n\nThis means the underlying additive monoid of a limit can be computed as a limit in the category of\nadditive monoids."]
 instance forget₂MonPreservesLimitsOfSize :
     PreservesLimitsOfSize.{v, v} (forget₂ GroupCat MonCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance }
 #align Group.forget₂_Mon_preserves_limits_of_size GroupCat.forget₂MonPreservesLimitsOfSize
-#align AddGroup.forget₂_AddMon_preserves_limits AddGroupCat.forget₂AddMonPreservesLimits
+#align AddGroup.forget₂_AddMon_preserves_limits AddGroupCat.forget₂AddMonPreservesLimitsOfSize
 -/
 
 #print GroupCat.forget₂MonPreservesLimits /-
@@ -315,7 +315,7 @@ def forget₂CommMonPreservesLimitsAux (F : J ⥤ CommGroupCat.{max v u}) :
 (That is, the underlying commutative monoids could have been computed instead as limits
 in the category of commutative monoids.)
 -/
-@[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimits
+@[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsOfSize
       "The forgetful functor from additive commutative groups to additive commutative monoids preserves\nall limits. (That is, the underlying additive commutative monoids could have been computed instead\nas limits in the category of additive commutative monoids.)"]
 instance forget₂CommMonPreservesLimitsOfSize :
     PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCat CommMonCat.{max v u})
@@ -325,7 +325,7 @@ instance forget₂CommMonPreservesLimitsOfSize :
         preserves_limit_of_preserves_limit_cone (limit_cone_is_limit F)
           (forget₂_CommMon_preserves_limits_aux F) }
 #align CommGroup.forget₂_CommMon_preserves_limits_of_size CommGroupCat.forget₂CommMonPreservesLimitsOfSize
-#align AddCommGroup.forget₂_AddCommMon_preserves_limits AddCommGroupCat.forget₂AddCommMonPreservesLimits
+#align AddCommGroup.forget₂_AddCommMon_preserves_limits AddCommGroupCat.forget₂AddCommMonPreservesLimitsOfSize
 -/
 
 #print CommGroupCat.forgetPreservesLimitsOfSize /-

4280f5f3

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -57,7 +57,7 @@ def sectionsSubgroup (F : J ⥤ GroupCat) : Subgroup (∀ j, F.obj j) :=
     inv_mem' := fun a ah j j' f =>
       by
       simp only [forget_map_eq_coe, functor.comp_map, Pi.inv_apply, MonoidHom.map_inv, inv_inj]
-      dsimp [functor.sections] at ah 
+      dsimp [functor.sections] at ah
       rw [ah f] }
 #align Group.sections_subgroup GroupCat.sectionsSubgroup
 #align AddGroup.sections_add_subgroup AddGroupCat.sectionsAddSubgroup

4280f5f3

bump to nightly-2023-10-11-06

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

6e6bbb75

Diff

@@ -332,7 +332,7 @@ instance forget₂CommMonPreservesLimitsOfSize :
 /-- The forgetful functor from commutative groups to types preserves all limits. (That is, the
 underlying types could have been computed instead as limits in the category of types.)
 -/
-@[to_additive AddCommGroupCat.forgetPreservesLimits
+@[to_additive AddCommGroupCat.forgetPreservesLimitsOfSize
       "The forgetful functor from additive commutative groups to types preserves all limits. (That is,\nthe underlying types could have been computed instead as limits in the category of types.)"]
 instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget CommGroupCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 :=
@@ -340,7 +340,7 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget Comm
       PreservesLimit := fun F =>
         limits.comp_preserves_limit (forget₂ CommGroupCat GroupCat) (forget GroupCat) }
 #align CommGroup.forget_preserves_limits_of_size CommGroupCat.forgetPreservesLimitsOfSize
-#align AddCommGroup.forget_preserves_limits AddCommGroupCat.forgetPreservesLimits
+#align AddCommGroup.forget_preserves_limits AddCommGroupCat.forgetPreservesLimitsOfSize
 -/
 
 -- Verify we can form limits indexed over smaller categories.

4280f5f3

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,11 +3,11 @@ 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.Category.Mon.Limits
-import Mathbin.Algebra.Category.Group.Preadditive
-import Mathbin.CategoryTheory.Over
-import Mathbin.GroupTheory.Subgroup.Basic
-import Mathbin.CategoryTheory.ConcreteCategory.Elementwise
+import Algebra.Category.Mon.Limits
+import Algebra.Category.Group.Preadditive
+import CategoryTheory.Over
+import GroupTheory.Subgroup.Basic
+import CategoryTheory.ConcreteCategory.Elementwise
 
 #align_import algebra.category.Group.limits from "leanprover-community/mathlib"@"4280f5f32e16755ec7985ce11e189b6cd6ff6735"

4280f5f3

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,11 +2,6 @@
 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.limits
-! leanprover-community/mathlib commit 4280f5f32e16755ec7985ce11e189b6cd6ff6735
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Category.Mon.Limits
 import Mathbin.Algebra.Category.Group.Preadditive
@@ -14,6 +9,8 @@ import Mathbin.CategoryTheory.Over
 import Mathbin.GroupTheory.Subgroup.Basic
 import Mathbin.CategoryTheory.ConcreteCategory.Elementwise
 
+#align_import algebra.category.Group.limits from "leanprover-community/mathlib"@"4280f5f32e16755ec7985ce11e189b6cd6ff6735"
+
 /-!
 # The category of (commutative) (additive) groups has all limits

4280f5f3

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -38,12 +38,15 @@ variable {J : Type v} [SmallCategory J]
 
 namespace GroupCat
 
+#print GroupCat.groupObj /-
 @[to_additive]
 instance groupObj (F : J ⥤ GroupCat.{max v u}) (j) : Group ((F ⋙ forget GroupCat).obj j) := by
   change Group (F.obj j); infer_instance
 #align Group.group_obj GroupCat.groupObj
 #align AddGroup.add_group_obj AddGroupCat.addGroupObj
+-/
 
+#print GroupCat.sectionsSubgroup /-
 /-- The flat sections of a functor into `Group` form a subgroup of all sections.
 -/
 @[to_additive
@@ -61,6 +64,7 @@ def sectionsSubgroup (F : J ⥤ GroupCat) : Subgroup (∀ j, F.obj j) :=
       rw [ah f] }
 #align Group.sections_subgroup GroupCat.sectionsSubgroup
 #align AddGroup.sections_add_subgroup AddGroupCat.sectionsAddSubgroup
+-/
 
 #print GroupCat.limitGroup /-
 @[to_additive]
@@ -189,11 +193,13 @@ end GroupCat
 
 namespace CommGroupCat
 
+#print CommGroupCat.commGroupObj /-
 @[to_additive]
 instance commGroupObj (F : J ⥤ CommGroupCat.{max v u}) (j) :
     CommGroup ((F ⋙ forget CommGroupCat).obj j) := by change CommGroup (F.obj j); infer_instance
 #align CommGroup.comm_group_obj CommGroupCat.commGroupObj
 #align AddCommGroup.add_comm_group_obj AddCommGroupCat.addCommGroupObj
+-/
 
 #print CommGroupCat.limitCommGroup /-
 @[to_additive]
@@ -295,6 +301,7 @@ instance forget₂GroupPreservesLimits : PreservesLimits (forget₂ CommGroupCat
 #align AddCommGroup.forget₂_Group_preserves_limits AddCommGroupCat.forget₂AddGroupPreservesLimits
 -/
 
+#print CommGroupCat.forget₂CommMonPreservesLimitsAux /-
 /-- An auxiliary declaration to speed up typechecking.
 -/
 @[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
@@ -304,6 +311,7 @@ def forget₂CommMonPreservesLimitsAux (F : J ⥤ CommGroupCat.{max v u}) :
   CommMonCat.limitConeIsLimit (F ⋙ forget₂ CommGroupCat CommMonCat)
 #align CommGroup.forget₂_CommMon_preserves_limits_aux CommGroupCat.forget₂CommMonPreservesLimitsAux
 #align AddCommGroup.forget₂_AddCommMon_preserves_limits_aux AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
+-/
 
 #print CommGroupCat.forget₂CommMonPreservesLimitsOfSize /-
 /-- The forgetful functor from commutative groups to commutative monoids preserves all limits.
@@ -345,6 +353,7 @@ end CommGroupCat
 
 namespace AddCommGroupCat
 
+#print AddCommGroupCat.kernelIsoKer /-
 /-- The categorical kernel of a morphism in `AddCommGroup`
 agrees with the usual group-theoretical kernel.
 -/
@@ -367,12 +376,16 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) : kernel f ≅ AddCom
     rintro ⟨x, mem⟩
     simp
 #align AddCommGroup.kernel_iso_ker AddCommGroupCat.kernelIsoKer
+-/
 
+#print AddCommGroupCat.kernelIsoKer_hom_comp_subtype /-
 @[simp]
 theorem kernelIsoKer_hom_comp_subtype {G H : AddCommGroupCat} (f : G ⟶ H) :
     (kernelIsoKer f).Hom ≫ AddSubgroup.subtype f.ker = kernel.ι f := by ext <;> rfl
 #align AddCommGroup.kernel_iso_ker_hom_comp_subtype AddCommGroupCat.kernelIsoKer_hom_comp_subtype
+-/
 
+#print AddCommGroupCat.kernelIsoKer_inv_comp_ι /-
 @[simp]
 theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat} (f : G ⟶ H) :
     (kernelIsoKer f).inv ≫ kernel.ι f = AddSubgroup.subtype f.ker :=
@@ -380,7 +393,9 @@ theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat} (f : G ⟶ H) :
   ext
   simp [kernel_iso_ker]
 #align AddCommGroup.kernel_iso_ker_inv_comp_ι AddCommGroupCat.kernelIsoKer_inv_comp_ι
+-/
 
+#print AddCommGroupCat.kernelIsoKerOver /-
 /-- The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`,
 agrees with the `subtype` map.
 -/
@@ -389,6 +404,7 @@ def kernelIsoKerOver {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
     Over.mk (kernel.ι f) ≅ @Over.mk _ _ G (AddCommGroupCat.of f.ker) (AddSubgroup.subtype f.ker) :=
   Over.isoMk (kernelIsoKer f) (by simp)
 #align AddCommGroup.kernel_iso_ker_over AddCommGroupCat.kernelIsoKerOver
+-/
 
 end AddCommGroupCat

4280f5f3

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -57,7 +57,7 @@ def sectionsSubgroup (F : J ⥤ GroupCat) : Subgroup (∀ j, F.obj j) :=
     inv_mem' := fun a ah j j' f =>
       by
       simp only [forget_map_eq_coe, functor.comp_map, Pi.inv_apply, MonoidHom.map_inv, inv_inj]
-      dsimp [functor.sections] at ah
+      dsimp [functor.sections] at ah 
       rw [ah f] }
 #align Group.sections_subgroup GroupCat.sectionsSubgroup
 #align AddGroup.sections_add_subgroup AddGroupCat.sectionsAddSubgroup

4280f5f3

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -38,24 +38,12 @@ variable {J : Type v} [SmallCategory J]
 
 namespace GroupCat
 
-/- warning: Group.group_obj -> GroupCat.groupObj is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2}) (j : J), Group.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} GroupCat.concreteCategory.{max u1 u2})) j)
-but is expected to have type
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 GroupCatMax.{u1, u2} instGroupCatLargeCategory.{max u2 u1}) (j : J), Group.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 GroupCatMax.{u1, u2} instGroupCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{succ (max u2 u1), max u2 u1, max u2 u1} GroupCat.{max u2 u1} instGroupCatLargeCategory.{max u2 u1} GroupCat.concreteCategory.{max u2 u1}))) j)
-Case conversion may be inaccurate. Consider using '#align Group.group_obj GroupCat.groupObjₓ'. -/
 @[to_additive]
 instance groupObj (F : J ⥤ GroupCat.{max v u}) (j) : Group ((F ⋙ forget GroupCat).obj j) := by
   change Group (F.obj j); infer_instance
 #align Group.group_obj GroupCat.groupObj
 #align AddGroup.add_group_obj AddGroupCat.addGroupObj
 
-/- warning: Group.sections_subgroup -> GroupCat.sectionsSubgroup is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2}), Subgroup.{max u1 u2} (forall (j : J), coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} GroupCat.{max u1 u2} Type.{max u1 u2} GroupCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} F j)) (Pi.group.{u1, max u1 u2} J (fun (j : J) => coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} GroupCat.{max u1 u2} Type.{max u1 u2} GroupCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} F j)) (fun (i : J) => GroupCat.group.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} F i)))
-but is expected to have type
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2}), Subgroup.{max u1 u2} (forall (j : J), CategoryTheory.Bundled.α.{max u1 u2, max u1 u2} Group.{max u1 u2} (Prefunctor.obj.{succ u1, succ (max u1 u2), u1, succ (max u1 u2)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) GroupCat.{max u1 u2} (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} (CategoryTheory.Category.toCategoryStruct.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2})) (CategoryTheory.Functor.toPrefunctor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2} F) j)) (Pi.group.{u1, max u1 u2} J (fun (j : J) => CategoryTheory.Bundled.α.{max u1 u2, max u1 u2} Group.{max u1 u2} (Prefunctor.obj.{succ u1, succ (max u1 u2), u1, succ (max u1 u2)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) GroupCat.{max u1 u2} (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} (CategoryTheory.Category.toCategoryStruct.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2})) (CategoryTheory.Functor.toPrefunctor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2} F) j)) (fun (i : J) => GroupCat.instGroupα.{max u1 u2} (Prefunctor.obj.{succ u1, succ (max u1 u2), u1, succ (max u1 u2)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) GroupCat.{max u1 u2} (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} (CategoryTheory.Category.toCategoryStruct.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2})) (CategoryTheory.Functor.toPrefunctor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2} F) i)))
-Case conversion may be inaccurate. Consider using '#align Group.sections_subgroup GroupCat.sectionsSubgroupₓ'. -/
 /-- The flat sections of a functor into `Group` form a subgroup of all sections.
 -/
 @[to_additive
@@ -201,12 +189,6 @@ end GroupCat
 
 namespace CommGroupCat
 
-/- warning: CommGroup.comm_group_obj -> CommGroupCat.commGroupObj is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2}) (j : J), CommGroup.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommGroupCat.concreteCategory.{max u1 u2})) j)
-but is expected to have type
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1}) (j : J), CommGroup.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} CommGroupCat.concreteCategory.{max u2 u1}))) j)
-Case conversion may be inaccurate. Consider using '#align CommGroup.comm_group_obj CommGroupCat.commGroupObjₓ'. -/
 @[to_additive]
 instance commGroupObj (F : J ⥤ CommGroupCat.{max v u}) (j) :
     CommGroup ((F ⋙ forget CommGroupCat).obj j) := by change CommGroup (F.obj j); infer_instance
@@ -313,12 +295,6 @@ instance forget₂GroupPreservesLimits : PreservesLimits (forget₂ CommGroupCat
 #align AddCommGroup.forget₂_Group_preserves_limits AddCommGroupCat.forget₂AddGroupPreservesLimits
 -/
 
-/- warning: CommGroup.forget₂_CommMon_preserves_limits_aux -> CommGroupCat.forget₂CommMonPreservesLimitsAux is a dubious translation:
-lean 3 declaration is
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2}), CategoryTheory.Limits.IsLimit.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} F (CategoryTheory.forget₂.{succ (max u1 u2), succ (max u1 u2), max u1 u2, max u1 u2, max u1 u2} CommGroupCat.{max u1 u2} CommMonCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommGroupCat.concreteCategory.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} CommMonCat.concreteCategory.{max u1 u2} CommGroupCat.hasForgetToCommMonCat.{max u1 u2})) (CategoryTheory.Functor.mapCone.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} F (CategoryTheory.forget₂.{succ (max u1 u2), succ (max u1 u2), max u1 u2, max u1 u2, max u1 u2} CommGroupCat.{max u1 u2} CommMonCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommGroupCat.concreteCategory.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} CommMonCat.concreteCategory.{max u1 u2} CommGroupCat.hasForgetToCommMonCat.{max u1 u2}) (CommGroupCat.limitCone.{u1, u2} J _inst_1 F))
-but is expected to have type
-  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1}), CategoryTheory.Limits.IsLimit.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommMonCat.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} CommMonCat.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} F (CategoryTheory.forget₂.{max (succ u2) (succ u1), succ (max u2 u1), max u2 u1, max u2 u1, max u2 u1} CommGroupCatMax.{u1, u2} CommMonCat.{max u2 u1} instCommGroupCatLargeCategory.{max u2 u1} CommGroupCat.concreteCategory.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} CommMonCat.concreteCategory.{max u2 u1} CommGroupCat.hasForgetToCommMonCat.{max u2 u1})) (CategoryTheory.Functor.mapCone.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} CommMonCat.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} (CategoryTheory.forget₂.{max (succ u2) (succ u1), succ (max u2 u1), max u2 u1, max u2 u1, max u2 u1} CommGroupCatMax.{u1, u2} CommMonCat.{max u2 u1} instCommGroupCatLargeCategory.{max u2 u1} CommGroupCat.concreteCategory.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} CommMonCat.concreteCategory.{max u2 u1} CommGroupCat.hasForgetToCommMonCat.{max u2 u1}) F (CommGroupCat.limitCone.{u1, u2} J _inst_1 F))
-Case conversion may be inaccurate. Consider using '#align CommGroup.forget₂_CommMon_preserves_limits_aux CommGroupCat.forget₂CommMonPreservesLimitsAuxₓ'. -/
 /-- An auxiliary declaration to speed up typechecking.
 -/
 @[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
@@ -369,12 +345,6 @@ end CommGroupCat
 
 namespace AddCommGroupCat
 
-/- warning: AddCommGroup.kernel_iso_ker -> AddCommGroupCat.kernelIsoKer is a dubious translation:
-lean 3 declaration is
-  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)))
-but is expected to have type
-  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)))
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker AddCommGroupCat.kernelIsoKerₓ'. -/
 /-- The categorical kernel of a morphism in `AddCommGroup`
 agrees with the usual group-theoretical kernel.
 -/
@@ -398,17 +368,11 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) : kernel f ≅ AddCom
     simp
 #align AddCommGroup.kernel_iso_ker AddCommGroupCat.kernelIsoKer
 
-/- warning: AddCommGroup.kernel_iso_ker_hom_comp_subtype -> AddCommGroupCat.kernelIsoKer_hom_comp_subtype is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_hom_comp_subtype AddCommGroupCat.kernelIsoKer_hom_comp_subtypeₓ'. -/
 @[simp]
 theorem kernelIsoKer_hom_comp_subtype {G H : AddCommGroupCat} (f : G ⟶ H) :
     (kernelIsoKer f).Hom ≫ AddSubgroup.subtype f.ker = kernel.ι f := by ext <;> rfl
 #align AddCommGroup.kernel_iso_ker_hom_comp_subtype AddCommGroupCat.kernelIsoKer_hom_comp_subtype
 
-/- warning: AddCommGroup.kernel_iso_ker_inv_comp_ι -> AddCommGroupCat.kernelIsoKer_inv_comp_ι is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_inv_comp_ι AddCommGroupCat.kernelIsoKer_inv_comp_ιₓ'. -/
 @[simp]
 theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat} (f : G ⟶ H) :
     (kernelIsoKer f).inv ≫ kernel.ι f = AddSubgroup.subtype f.ker :=
@@ -417,9 +381,6 @@ theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat} (f : G ⟶ H) :
   simp [kernel_iso_ker]
 #align AddCommGroup.kernel_iso_ker_inv_comp_ι AddCommGroupCat.kernelIsoKer_inv_comp_ι
 
-/- warning: AddCommGroup.kernel_iso_ker_over -> AddCommGroupCat.kernelIsoKerOver is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_over AddCommGroupCat.kernelIsoKerOverₓ'. -/
 /-- The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`,
 agrees with the `subtype` map.
 -/

4280f5f3

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -45,10 +45,8 @@ but is expected to have type
   forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 GroupCatMax.{u1, u2} instGroupCatLargeCategory.{max u2 u1}) (j : J), Group.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 GroupCatMax.{u1, u2} instGroupCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{succ (max u2 u1), max u2 u1, max u2 u1} GroupCat.{max u2 u1} instGroupCatLargeCategory.{max u2 u1} GroupCat.concreteCategory.{max u2 u1}))) j)
 Case conversion may be inaccurate. Consider using '#align Group.group_obj GroupCat.groupObjₓ'. -/
 @[to_additive]
-instance groupObj (F : J ⥤ GroupCat.{max v u}) (j) : Group ((F ⋙ forget GroupCat).obj j) :=
-  by
-  change Group (F.obj j)
-  infer_instance
+instance groupObj (F : J ⥤ GroupCat.{max v u}) (j) : Group ((F ⋙ forget GroupCat).obj j) := by
+  change Group (F.obj j); infer_instance
 #align Group.group_obj GroupCat.groupObj
 #align AddGroup.add_group_obj AddGroupCat.addGroupObj
 
@@ -211,10 +209,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align CommGroup.comm_group_obj CommGroupCat.commGroupObjₓ'. -/
 @[to_additive]
 instance commGroupObj (F : J ⥤ CommGroupCat.{max v u}) (j) :
-    CommGroup ((F ⋙ forget CommGroupCat).obj j) :=
-  by
-  change CommGroup (F.obj j)
-  infer_instance
+    CommGroup ((F ⋙ forget CommGroupCat).obj j) := by change CommGroup (F.obj j); infer_instance
 #align CommGroup.comm_group_obj CommGroupCat.commGroupObj
 #align AddCommGroup.add_comm_group_obj AddCommGroupCat.addCommGroupObj
 
@@ -392,17 +387,10 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) : kernel f ≅ AddCom
           -- TODO where is this `has_coe_t_aux.coe` coming from? can we prevent it appearing?
           change (kernel.ι f) g ∈ f.ker
           simp [AddMonoidHom.mem_ker]⟩
-      map_zero' := by
-        ext
-        simp
-      map_add' := fun g g' => by
-        ext
-        simp }
+      map_zero' := by ext; simp
+      map_add' := fun g g' => by ext; simp }
   inv := kernel.lift f (AddSubgroup.subtype f.ker) (by tidy)
-  hom_inv_id' := by
-    apply equalizer.hom_ext _
-    ext
-    simp
+  hom_inv_id' := by apply equalizer.hom_ext _; ext; simp
   inv_hom_id' := by
     apply AddCommGroupCat.ext
     simp only [AddMonoidHom.coe_mk, coe_id, coe_comp]

4280f5f3

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -411,10 +411,7 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) : kernel f ≅ AddCom
 #align AddCommGroup.kernel_iso_ker AddCommGroupCat.kernelIsoKer
 
 /- warning: AddCommGroup.kernel_iso_ker_hom_comp_subtype -> AddCommGroupCat.kernelIsoKer_hom_comp_subtype is a dubious translation:
-lean 3 declaration is
-  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), 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})) (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1}) (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G (CategoryTheory.Iso.hom.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (AddSubgroup.subtype.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.ι.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f))
-but is expected to have type
-  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), 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})) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G (CategoryTheory.Iso.hom.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (AddSubgroup.subtype.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f))
+<too large>
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_hom_comp_subtype AddCommGroupCat.kernelIsoKer_hom_comp_subtypeₓ'. -/
 @[simp]
 theorem kernelIsoKer_hom_comp_subtype {G H : AddCommGroupCat} (f : G ⟶ H) :
@@ -422,10 +419,7 @@ theorem kernelIsoKer_hom_comp_subtype {G H : AddCommGroupCat} (f : G ⟶ H) :
 #align AddCommGroup.kernel_iso_ker_hom_comp_subtype AddCommGroupCat.kernelIsoKer_hom_comp_subtype
 
 /- warning: AddCommGroup.kernel_iso_ker_inv_comp_ι -> AddCommGroupCat.kernelIsoKer_inv_comp_ι is a dubious translation:
-lean 3 declaration is
-  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), 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} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1}) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) G (CategoryTheory.Iso.inv.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (CategoryTheory.Limits.kernel.ι.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f))) (AddSubgroup.subtype.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))
-but is expected to have type
-  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), 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} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1}) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) G (CategoryTheory.Iso.inv.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f))) (AddSubgroup.subtype.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))
+<too large>
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_inv_comp_ι AddCommGroupCat.kernelIsoKer_inv_comp_ιₓ'. -/
 @[simp]
 theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat} (f : G ⟶ H) :
@@ -436,10 +430,7 @@ theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat} (f : G ⟶ H) :
 #align AddCommGroup.kernel_iso_ker_inv_comp_ι AddCommGroupCat.kernelIsoKer_inv_comp_ι
 
 /- warning: AddCommGroup.kernel_iso_ker_over -> AddCommGroupCat.kernelIsoKerOver is a dubious translation:
-lean 3 declaration is
-  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), CategoryTheory.Iso.{u1, succ u1} (CategoryTheory.Over.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G) (CategoryTheory.Over.category.{succ u1, u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKerOver._proof_1.{u1} G H f)) (CategoryTheory.Limits.kernel.ι.{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 f (AddCommGroupCat.kernelIsoKerOver._proof_2.{u1} G H f))) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.subtype.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)))
-but is expected to have type
-  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), CategoryTheory.Iso.{u1, succ u1} (CategoryTheory.Over.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G) (CategoryTheory.instCategoryOver.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f))) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.subtype.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_over AddCommGroupCat.kernelIsoKerOverₓ'. -/
 /-- The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`,
 agrees with the `subtype` map.

4280f5f3

bump to nightly-2023-05-23-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/75e7fca56381d056096ce5d05e938f63a6567828

ed98987c

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.limits
-! leanprover-community/mathlib commit 70fd9563a21e7b963887c9360bd29b2393e6225a
+! leanprover-community/mathlib commit 4280f5f32e16755ec7985ce11e189b6cd6ff6735
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -17,6 +17,9 @@ import Mathbin.CategoryTheory.ConcreteCategory.Elementwise
 /-!
 # The category of (commutative) (additive) groups has all limits
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 Further, these limits are preserved by the forgetful functor --- that is,
 the underlying types are just the limits in the category of types.

70fd9563

bump to nightly-2023-05-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/33c67ae661dd8988516ff7f247b0be3018cdd952

110b734b

Diff

@@ -35,6 +35,12 @@ variable {J : Type v} [SmallCategory J]
 
 namespace GroupCat
 
+/- warning: Group.group_obj -> GroupCat.groupObj is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2}) (j : J), Group.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} GroupCat.concreteCategory.{max u1 u2})) j)
+but is expected to have type
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 GroupCatMax.{u1, u2} instGroupCatLargeCategory.{max u2 u1}) (j : J), Group.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 GroupCatMax.{u1, u2} instGroupCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{succ (max u2 u1), max u2 u1, max u2 u1} GroupCat.{max u2 u1} instGroupCatLargeCategory.{max u2 u1} GroupCat.concreteCategory.{max u2 u1}))) j)
+Case conversion may be inaccurate. Consider using '#align Group.group_obj GroupCat.groupObjₓ'. -/
 @[to_additive]
 instance groupObj (F : J ⥤ GroupCat.{max v u}) (j) : Group ((F ⋙ forget GroupCat).obj j) :=
   by
@@ -43,6 +49,12 @@ instance groupObj (F : J ⥤ GroupCat.{max v u}) (j) : Group ((F ⋙ forget Grou
 #align Group.group_obj GroupCat.groupObj
 #align AddGroup.add_group_obj AddGroupCat.addGroupObj
 
+/- warning: Group.sections_subgroup -> GroupCat.sectionsSubgroup is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2}), Subgroup.{max u1 u2} (forall (j : J), coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} GroupCat.{max u1 u2} Type.{max u1 u2} GroupCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} F j)) (Pi.group.{u1, max u1 u2} J (fun (j : J) => coeSort.{succ (succ (max u1 u2)), succ (succ (max u1 u2))} GroupCat.{max u1 u2} Type.{max u1 u2} GroupCat.hasCoeToSort.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} F j)) (fun (i : J) => GroupCat.group.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} GroupCat.largeCategory.{max u1 u2} F i)))
+but is expected to have type
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2}), Subgroup.{max u1 u2} (forall (j : J), CategoryTheory.Bundled.α.{max u1 u2, max u1 u2} Group.{max u1 u2} (Prefunctor.obj.{succ u1, succ (max u1 u2), u1, succ (max u1 u2)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) GroupCat.{max u1 u2} (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} (CategoryTheory.Category.toCategoryStruct.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2})) (CategoryTheory.Functor.toPrefunctor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2} F) j)) (Pi.group.{u1, max u1 u2} J (fun (j : J) => CategoryTheory.Bundled.α.{max u1 u2, max u1 u2} Group.{max u1 u2} (Prefunctor.obj.{succ u1, succ (max u1 u2), u1, succ (max u1 u2)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) GroupCat.{max u1 u2} (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} (CategoryTheory.Category.toCategoryStruct.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2})) (CategoryTheory.Functor.toPrefunctor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2} F) j)) (fun (i : J) => GroupCat.instGroupα.{max u1 u2} (Prefunctor.obj.{succ u1, succ (max u1 u2), u1, succ (max u1 u2)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) GroupCat.{max u1 u2} (CategoryTheory.CategoryStruct.toQuiver.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} (CategoryTheory.Category.toCategoryStruct.{max u1 u2, succ (max u1 u2)} GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2})) (CategoryTheory.Functor.toPrefunctor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 GroupCat.{max u1 u2} instGroupCatLargeCategory.{max u1 u2} F) i)))
+Case conversion may be inaccurate. Consider using '#align Group.sections_subgroup GroupCat.sectionsSubgroupₓ'. -/
 /-- The flat sections of a functor into `Group` form a subgroup of all sections.
 -/
 @[to_additive
@@ -61,6 +73,7 @@ def sectionsSubgroup (F : J ⥤ GroupCat) : Subgroup (∀ j, F.obj j) :=
 #align Group.sections_subgroup GroupCat.sectionsSubgroup
 #align AddGroup.sections_add_subgroup AddGroupCat.sectionsAddSubgroup
 
+#print GroupCat.limitGroup /-
 @[to_additive]
 instance limitGroup (F : J ⥤ GroupCat.{max v u}) :
     Group (Types.limitCone (F ⋙ forget GroupCat)).pt :=
@@ -69,7 +82,9 @@ instance limitGroup (F : J ⥤ GroupCat.{max v u}) :
   infer_instance
 #align Group.limit_group GroupCat.limitGroup
 #align AddGroup.limit_add_group AddGroupCat.limitAddGroup
+-/
 
+#print GroupCat.Forget₂.createsLimit /-
 /-- We show that the forgetful functor `Group ⥤ Mon` creates limits.
 
 All we need to do is notice that the limit point has a `group` instance available, and then reuse
@@ -92,7 +107,9 @@ instance Forget₂.createsLimit (F : J ⥤ GroupCat.{max v u}) :
           (fun s => _) fun s => rfl }
 #align Group.forget₂.creates_limit GroupCat.Forget₂.createsLimit
 #align AddGroup.forget₂.creates_limit AddGroupCat.Forget₂.createsLimit
+-/
 
+#print GroupCat.limitCone /-
 /-- A choice of limit cone for a functor into `Group`.
 (Generally, you'll just want to use `limit F`.)
 -/
@@ -102,7 +119,9 @@ def limitCone (F : J ⥤ GroupCat.{max v u}) : Cone F :=
   liftLimit (limit.isLimit (F ⋙ forget₂ GroupCat MonCat.{max v u}))
 #align Group.limit_cone GroupCat.limitCone
 #align AddGroup.limit_cone AddGroupCat.limitCone
+-/
 
+#print GroupCat.limitConeIsLimit /-
 /-- The chosen cone is a limit cone.
 (Generally, you'll just want to use `limit.cone F`.)
 -/
@@ -112,7 +131,9 @@ def limitConeIsLimit (F : J ⥤ GroupCat.{max v u}) : IsLimit (limitCone F) :=
   liftedLimitIsLimit _
 #align Group.limit_cone_is_limit GroupCat.limitConeIsLimit
 #align AddGroup.limit_cone_is_limit AddGroupCat.limitConeIsLimit
+-/
 
+#print GroupCat.hasLimitsOfSize /-
 /-- The category of groups has all limits. -/
 @[to_additive "The category of additive groups has all limits."]
 instance hasLimitsOfSize : HasLimitsOfSize.{v, v} GroupCat.{max v u}
@@ -120,13 +141,17 @@ instance hasLimitsOfSize : HasLimitsOfSize.{v, v} GroupCat.{max v u}
     { HasLimit := fun F => has_limit_of_created F (forget₂ GroupCat MonCat.{max v u}) }
 #align Group.has_limits_of_size GroupCat.hasLimitsOfSize
 #align AddGroup.has_limits_of_size AddGroupCat.hasLimitsOfSize
+-/
 
+#print GroupCat.hasLimits /-
 @[to_additive]
 instance hasLimits : HasLimits GroupCat.{u} :=
   GroupCat.hasLimitsOfSize.{u, u}
 #align Group.has_limits GroupCat.hasLimits
 #align AddGroup.has_limits AddGroupCat.hasLimits
+-/
 
+#print GroupCat.forget₂MonPreservesLimitsOfSize /-
 /-- The forgetful functor from groups to monoids preserves all limits.
 
 This means the underlying monoid of a limit can be computed as a limit in the category of monoids.
@@ -138,13 +163,17 @@ instance forget₂MonPreservesLimitsOfSize :
     where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance }
 #align Group.forget₂_Mon_preserves_limits_of_size GroupCat.forget₂MonPreservesLimitsOfSize
 #align AddGroup.forget₂_AddMon_preserves_limits AddGroupCat.forget₂AddMonPreservesLimits
+-/
 
+#print GroupCat.forget₂MonPreservesLimits /-
 @[to_additive]
 instance forget₂MonPreservesLimits : PreservesLimits (forget₂ GroupCat MonCat.{u}) :=
   GroupCat.forget₂MonPreservesLimitsOfSize.{u, u}
 #align Group.forget₂_Mon_preserves_limits GroupCat.forget₂MonPreservesLimits
 #align AddGroup.forget₂_Mon_preserves_limits AddGroupCat.forget₂MonPreservesLimits
+-/
 
+#print GroupCat.forgetPreservesLimitsOfSize /-
 /-- The forgetful functor from groups to types preserves all limits.
 
 This means the underlying type of a limit can be computed as a limit in the category of types. -/
@@ -157,17 +186,26 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget Grou
         limits.comp_preserves_limit (forget₂ GroupCat MonCat) (forget MonCat) }
 #align Group.forget_preserves_limits_of_size GroupCat.forgetPreservesLimitsOfSize
 #align AddGroup.forget_preserves_limits_of_size AddGroupCat.forgetPreservesLimitsOfSize
+-/
 
+#print GroupCat.forgetPreservesLimits /-
 @[to_additive]
 instance forgetPreservesLimits : PreservesLimits (forget GroupCat.{u}) :=
   GroupCat.forgetPreservesLimitsOfSize.{u, u}
 #align Group.forget_preserves_limits GroupCat.forgetPreservesLimits
 #align AddGroup.forget_preserves_limits AddGroupCat.forgetPreservesLimits
+-/
 
 end GroupCat
 
 namespace CommGroupCat
 
+/- warning: CommGroup.comm_group_obj -> CommGroupCat.commGroupObj is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2}) (j : J), CommGroup.{max u1 u2} (CategoryTheory.Functor.obj.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 Type.{max u1 u2} CategoryTheory.types.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} Type.{max u1 u2} CategoryTheory.types.{max u1 u2} F (CategoryTheory.forget.{succ (max u1 u2), max u1 u2, max u1 u2} CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommGroupCat.concreteCategory.{max u1 u2})) j)
+but is expected to have type
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1}) (j : J), CommGroup.{max u2 u1} (Prefunctor.obj.{succ u1, max (succ u2) (succ u1), u1, max (succ u2) (succ u1)} J (CategoryTheory.CategoryStruct.toQuiver.{u1, u1} J (CategoryTheory.Category.toCategoryStruct.{u1, u1} J _inst_1)) Type.{max u2 u1} (CategoryTheory.CategoryStruct.toQuiver.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} (CategoryTheory.Category.toCategoryStruct.{max u2 u1, max (succ u2) (succ u1)} Type.{max u2 u1} CategoryTheory.types.{max u2 u1})) (CategoryTheory.Functor.toPrefunctor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 Type.{max u2 u1} CategoryTheory.types.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} Type.{max u2 u1} CategoryTheory.types.{max u2 u1} F (CategoryTheory.forget.{max (succ u2) (succ u1), max u2 u1, max u2 u1} CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} CommGroupCat.concreteCategory.{max u2 u1}))) j)
+Case conversion may be inaccurate. Consider using '#align CommGroup.comm_group_obj CommGroupCat.commGroupObjₓ'. -/
 @[to_additive]
 instance commGroupObj (F : J ⥤ CommGroupCat.{max v u}) (j) :
     CommGroup ((F ⋙ forget CommGroupCat).obj j) :=
@@ -177,6 +215,7 @@ instance commGroupObj (F : J ⥤ CommGroupCat.{max v u}) (j) :
 #align CommGroup.comm_group_obj CommGroupCat.commGroupObj
 #align AddCommGroup.add_comm_group_obj AddCommGroupCat.addCommGroupObj
 
+#print CommGroupCat.limitCommGroup /-
 @[to_additive]
 instance limitCommGroup (F : J ⥤ CommGroupCat.{max v u}) :
     CommGroup (Types.limitCone (F ⋙ forget CommGroupCat.{max v u})).pt :=
@@ -184,7 +223,9 @@ instance limitCommGroup (F : J ⥤ CommGroupCat.{max v u}) :
     (GroupCat.sectionsSubgroup (F ⋙ forget₂ CommGroupCat GroupCat.{max v u}))
 #align CommGroup.limit_comm_group CommGroupCat.limitCommGroup
 #align AddCommGroup.limit_add_comm_group AddCommGroupCat.limitAddCommGroup
+-/
 
+#print CommGroupCat.Forget₂.createsLimit /-
 /-- We show that the forgetful functor `CommGroup ⥤ Group` creates limits.
 
 All we need to do is notice that the limit point has a `comm_group` instance available,
@@ -208,7 +249,9 @@ instance Forget₂.createsLimit (F : J ⥤ CommGroupCat.{max v u}) :
           (by apply MonCat.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl }
 #align CommGroup.forget₂.creates_limit CommGroupCat.Forget₂.createsLimit
 #align AddCommGroup.forget₂.creates_limit AddCommGroupCat.Forget₂.createsLimit
+-/
 
+#print CommGroupCat.limitCone /-
 /-- A choice of limit cone for a functor into `CommGroup`.
 (Generally, you'll just want to use `limit F`.)
 -/
@@ -218,7 +261,9 @@ def limitCone (F : J ⥤ CommGroupCat.{max v u}) : Cone F :=
   liftLimit (limit.isLimit (F ⋙ forget₂ CommGroupCat GroupCat.{max v u}))
 #align CommGroup.limit_cone CommGroupCat.limitCone
 #align AddCommGroup.limit_cone AddCommGroupCat.limitCone
+-/
 
+#print CommGroupCat.limitConeIsLimit /-
 /-- The chosen cone is a limit cone.
 (Generally, you'll just want to use `limit.cone F`.)
 -/
@@ -228,7 +273,9 @@ def limitConeIsLimit (F : J ⥤ CommGroupCat.{max v u}) : IsLimit (limitCone F)
   liftedLimitIsLimit _
 #align CommGroup.limit_cone_is_limit CommGroupCat.limitConeIsLimit
 #align AddCommGroup.limit_cone_is_limit AddCommGroupCat.limitConeIsLimit
+-/
 
+#print CommGroupCat.hasLimitsOfSize /-
 /-- The category of commutative groups has all limits. -/
 @[to_additive "The category of additive commutative groups has all limits."]
 instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommGroupCat.{max v u}
@@ -236,31 +283,44 @@ instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommGroupCat.{max v u}
     { HasLimit := fun F => has_limit_of_created F (forget₂ CommGroupCat GroupCat.{max v u}) }
 #align CommGroup.has_limits_of_size CommGroupCat.hasLimitsOfSize
 #align AddCommGroup.has_limits_of_size AddCommGroupCat.hasLimitsOfSize
+-/
 
+#print CommGroupCat.hasLimits /-
 @[to_additive]
 instance hasLimits : HasLimits CommGroupCat.{u} :=
   CommGroupCat.hasLimitsOfSize.{u, u}
 #align CommGroup.has_limits CommGroupCat.hasLimits
 #align AddCommGroup.has_limits AddCommGroupCat.hasLimits
+-/
 
+#print CommGroupCat.forget₂GroupPreservesLimitsOfSize /-
 /-- The forgetful functor from commutative groups to groups preserves all limits.
 (That is, the underlying group could have been computed instead as limits in the category
 of groups.)
 -/
-@[to_additive AddCommGroupCat.forget₂AddGroupPreservesLimits
+@[to_additive AddCommGroupCat.forget₂AddGroupPreservesLimitsOfSize
       "The forgetful functor from additive commutative groups to groups preserves all limits.\n(That is, the underlying group could have been computed instead as limits in the category\nof additive groups.)"]
 instance forget₂GroupPreservesLimitsOfSize :
     PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCat GroupCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance }
 #align CommGroup.forget₂_Group_preserves_limits_of_size CommGroupCat.forget₂GroupPreservesLimitsOfSize
-#align AddCommGroup.forget₂_AddGroup_preserves_limits AddCommGroupCat.forget₂AddGroupPreservesLimits
+#align AddCommGroup.forget₂_AddGroup_preserves_limits AddCommGroupCat.forget₂AddGroupPreservesLimitsOfSize
+-/
 
+#print CommGroupCat.forget₂GroupPreservesLimits /-
 @[to_additive]
 instance forget₂GroupPreservesLimits : PreservesLimits (forget₂ CommGroupCat GroupCat.{u}) :=
   CommGroupCat.forget₂GroupPreservesLimitsOfSize.{u, u}
 #align CommGroup.forget₂_Group_preserves_limits CommGroupCat.forget₂GroupPreservesLimits
-#align AddCommGroup.forget₂_Group_preserves_limits AddCommGroupCat.forget₂GroupPreservesLimits
+#align AddCommGroup.forget₂_Group_preserves_limits AddCommGroupCat.forget₂AddGroupPreservesLimits
+-/
 
+/- warning: CommGroup.forget₂_CommMon_preserves_limits_aux -> CommGroupCat.forget₂CommMonPreservesLimitsAux is a dubious translation:
+lean 3 declaration is
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2}), CategoryTheory.Limits.IsLimit.{u1, max u1 u2, u1, succ (max u1 u2)} J _inst_1 CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} (CategoryTheory.Functor.comp.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} F (CategoryTheory.forget₂.{succ (max u1 u2), succ (max u1 u2), max u1 u2, max u1 u2, max u1 u2} CommGroupCat.{max u1 u2} CommMonCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommGroupCat.concreteCategory.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} CommMonCat.concreteCategory.{max u1 u2} CommGroupCat.hasForgetToCommMonCat.{max u1 u2})) (CategoryTheory.Functor.mapCone.{u1, max u1 u2, max u1 u2, u1, succ (max u1 u2), succ (max u1 u2)} J _inst_1 CommGroupCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommMonCat.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} F (CategoryTheory.forget₂.{succ (max u1 u2), succ (max u1 u2), max u1 u2, max u1 u2, max u1 u2} CommGroupCat.{max u1 u2} CommMonCat.{max u1 u2} CommGroupCat.largeCategory.{max u1 u2} CommGroupCat.concreteCategory.{max u1 u2} CommMonCat.largeCategory.{max u1 u2} CommMonCat.concreteCategory.{max u1 u2} CommGroupCat.hasForgetToCommMonCat.{max u1 u2}) (CommGroupCat.limitCone.{u1, u2} J _inst_1 F))
+but is expected to have type
+  forall {J : Type.{u1}} [_inst_1 : CategoryTheory.SmallCategory.{u1} J] (F : CategoryTheory.Functor.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1}), CategoryTheory.Limits.IsLimit.{u1, max u2 u1, u1, max (succ u2) (succ u1)} J _inst_1 CommMonCat.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} (CategoryTheory.Functor.comp.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} CommMonCat.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} F (CategoryTheory.forget₂.{max (succ u2) (succ u1), succ (max u2 u1), max u2 u1, max u2 u1, max u2 u1} CommGroupCatMax.{u1, u2} CommMonCat.{max u2 u1} instCommGroupCatLargeCategory.{max u2 u1} CommGroupCat.concreteCategory.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} CommMonCat.concreteCategory.{max u2 u1} CommGroupCat.hasForgetToCommMonCat.{max u2 u1})) (CategoryTheory.Functor.mapCone.{u1, max u2 u1, max u2 u1, u1, max (succ u2) (succ u1), max (succ u2) (succ u1)} J _inst_1 CommGroupCatMax.{u1, u2} instCommGroupCatLargeCategory.{max u2 u1} CommMonCat.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} (CategoryTheory.forget₂.{max (succ u2) (succ u1), succ (max u2 u1), max u2 u1, max u2 u1, max u2 u1} CommGroupCatMax.{u1, u2} CommMonCat.{max u2 u1} instCommGroupCatLargeCategory.{max u2 u1} CommGroupCat.concreteCategory.{max u2 u1} instCommMonCatLargeCategory.{max u2 u1} CommMonCat.concreteCategory.{max u2 u1} CommGroupCat.hasForgetToCommMonCat.{max u2 u1}) F (CommGroupCat.limitCone.{u1, u2} J _inst_1 F))
+Case conversion may be inaccurate. Consider using '#align CommGroup.forget₂_CommMon_preserves_limits_aux CommGroupCat.forget₂CommMonPreservesLimitsAuxₓ'. -/
 /-- An auxiliary declaration to speed up typechecking.
 -/
 @[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
@@ -271,6 +331,7 @@ def forget₂CommMonPreservesLimitsAux (F : J ⥤ CommGroupCat.{max v u}) :
 #align CommGroup.forget₂_CommMon_preserves_limits_aux CommGroupCat.forget₂CommMonPreservesLimitsAux
 #align AddCommGroup.forget₂_AddCommMon_preserves_limits_aux AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
 
+#print CommGroupCat.forget₂CommMonPreservesLimitsOfSize /-
 /-- The forgetful functor from commutative groups to commutative monoids preserves all limits.
 (That is, the underlying commutative monoids could have been computed instead as limits
 in the category of commutative monoids.)
@@ -286,7 +347,9 @@ instance forget₂CommMonPreservesLimitsOfSize :
           (forget₂_CommMon_preserves_limits_aux F) }
 #align CommGroup.forget₂_CommMon_preserves_limits_of_size CommGroupCat.forget₂CommMonPreservesLimitsOfSize
 #align AddCommGroup.forget₂_AddCommMon_preserves_limits AddCommGroupCat.forget₂AddCommMonPreservesLimits
+-/
 
+#print CommGroupCat.forgetPreservesLimitsOfSize /-
 /-- The forgetful functor from commutative groups to types preserves all limits. (That is, the
 underlying types could have been computed instead as limits in the category of types.)
 -/
@@ -299,6 +362,7 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget Comm
         limits.comp_preserves_limit (forget₂ CommGroupCat GroupCat) (forget GroupCat) }
 #align CommGroup.forget_preserves_limits_of_size CommGroupCat.forgetPreservesLimitsOfSize
 #align AddCommGroup.forget_preserves_limits AddCommGroupCat.forgetPreservesLimits
+-/
 
 -- Verify we can form limits indexed over smaller categories.
 example (f : ℕ → AddCommGroupCat) : HasProduct f := by infer_instance
@@ -307,6 +371,12 @@ end CommGroupCat
 
 namespace AddCommGroupCat
 
+/- warning: AddCommGroup.kernel_iso_ker -> AddCommGroupCat.kernelIsoKer is a dubious translation:
+lean 3 declaration is
+  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)))
+but is expected to have type
+  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), CategoryTheory.Iso.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)))
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker AddCommGroupCat.kernelIsoKerₓ'. -/
 /-- The categorical kernel of a morphism in `AddCommGroup`
 agrees with the usual group-theoretical kernel.
 -/
@@ -337,11 +407,23 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) : kernel f ≅ AddCom
     simp
 #align AddCommGroup.kernel_iso_ker AddCommGroupCat.kernelIsoKer
 
+/- warning: AddCommGroup.kernel_iso_ker_hom_comp_subtype -> AddCommGroupCat.kernelIsoKer_hom_comp_subtype is a dubious translation:
+lean 3 declaration is
+  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), 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})) (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1}) (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G (CategoryTheory.Iso.hom.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (AddSubgroup.subtype.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.ι.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f))
+but is expected to have type
+  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), 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})) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G (CategoryTheory.Iso.hom.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (AddSubgroup.subtype.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f))
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_hom_comp_subtype AddCommGroupCat.kernelIsoKer_hom_comp_subtypeₓ'. -/
 @[simp]
 theorem kernelIsoKer_hom_comp_subtype {G H : AddCommGroupCat} (f : G ⟶ H) :
     (kernelIsoKer f).Hom ≫ AddSubgroup.subtype f.ker = kernel.ι f := by ext <;> rfl
 #align AddCommGroup.kernel_iso_ker_hom_comp_subtype AddCommGroupCat.kernelIsoKer_hom_comp_subtype
 
+/- warning: AddCommGroup.kernel_iso_ker_inv_comp_ι -> AddCommGroupCat.kernelIsoKer_inv_comp_ι is a dubious translation:
+lean 3 declaration is
+  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), 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} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1}) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) G (CategoryTheory.Iso.inv.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f)) (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (CategoryTheory.Limits.kernel.ι.{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 f (AddCommGroupCat.kernelIsoKer._proof_1.{u1} G H f))) (AddSubgroup.subtype.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))
+but is expected to have type
+  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), 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} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) G) (CategoryTheory.CategoryStruct.comp.{u1, succ u1} AddCommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1}) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) G (CategoryTheory.Iso.inv.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddCommGroupCat.kernelIsoKer.{u1} G H f)) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f))) (AddSubgroup.subtype.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_inv_comp_ι AddCommGroupCat.kernelIsoKer_inv_comp_ιₓ'. -/
 @[simp]
 theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat} (f : G ⟶ H) :
     (kernelIsoKer f).inv ≫ kernel.ι f = AddSubgroup.subtype f.ker :=
@@ -350,6 +432,12 @@ theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat} (f : G ⟶ H) :
   simp [kernel_iso_ker]
 #align AddCommGroup.kernel_iso_ker_inv_comp_ι AddCommGroupCat.kernelIsoKer_inv_comp_ι
 
+/- warning: AddCommGroup.kernel_iso_ker_over -> AddCommGroupCat.kernelIsoKerOver is a dubious translation:
+lean 3 declaration is
+  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), CategoryTheory.Iso.{u1, succ u1} (CategoryTheory.Over.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G) (CategoryTheory.Over.category.{succ u1, u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G (CategoryTheory.Limits.kernel.{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 f (AddCommGroupCat.kernelIsoKerOver._proof_1.{u1} G H f)) (CategoryTheory.Limits.kernel.ι.{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 f (AddCommGroupCat.kernelIsoKerOver._proof_2.{u1} G H f))) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} AddCommGroupCat.largeCategory.{u1} G (AddCommGroupCat.of.{u1} (coeSort.{succ u1, succ (succ u1)} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (AddSubgroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddSubgroup.setLike.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)) (AddSubgroup.toAddCommGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.subtype.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddMonoid.toAddZeroClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddGroup.toAddMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (AddCommGroup.toAddGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} AddCommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} AddCommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)))
+but is expected to have type
+  forall {G : AddCommGroupCat.{u1}} {H : AddCommGroupCat.{u1}} (f : 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})) G H), CategoryTheory.Iso.{u1, succ u1} (CategoryTheory.Over.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G) (CategoryTheory.instCategoryOver.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G (CategoryTheory.Limits.kernel.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f)) (CategoryTheory.Limits.kernel.ι.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) G H f (CategoryTheory.Limits.HasKernels.has_limit.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasKernels_of_hasEqualizers.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} (CategoryTheory.Preadditive.preadditiveHasZeroMorphisms.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} AddCommGroupCat.instPreadditiveAddCommGroupCatInstAddCommGroupCatLargeCategory.{u1}) (CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits.{0, 0, u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} CategoryTheory.Limits.WalkingParallelPair CategoryTheory.Limits.walkingParallelPairHomCategory AddCommGroupCat.hasLimitsOfSize.{0, u1})) G H f))) (CategoryTheory.Over.mk.{u1, succ u1} AddCommGroupCat.{u1} instAddCommGroupCatLargeCategory.{u1} G (AddCommGroupCat.of.{u1} (Subtype.{succ u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (fun (x : CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) => Membership.mem.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G))) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)))) x (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.toAddCommGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f))) (AddSubgroup.subtype.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (AddMonoidHom.ker.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} G) (AddCommGroupCat.addCommGroupInstance.{u1} G)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddMonoid.toAddZeroClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) ((fun {α : Type.{u1}} (h : AddGroup.{u1} α) => SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α h)) (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (AddCommGroup.toAddGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} AddCommGroup.{u1} H) (CategoryTheory.Bundled.str.{u1, u1} AddCommGroup.{u1} H)))) f)))
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.kernel_iso_ker_over AddCommGroupCat.kernelIsoKerOverₓ'. -/
 /-- The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`,
 agrees with the `subtype` map.
 -/

70fd9563

bump to nightly-2023-03-21-14

mathlib commit https://github.com/leanprover-community/mathlib/commit/290a7ba01fbcab1b64757bdaa270d28f4dcede35

4b782568

Diff

@@ -49,9 +49,9 @@ instance groupObj (F : J ⥤ GroupCat.{max v u}) (j) : Group ((F ⋙ forget Grou
       "The flat sections of a functor into `AddGroup` form an additive subgroup of all sections."]
 def sectionsSubgroup (F : J ⥤ GroupCat) : Subgroup (∀ j, F.obj j) :=
   {
-    Mon.sectionsSubmonoid
+    MonCat.sectionsSubmonoid
       (F ⋙ forget₂ GroupCat
-          Mon) with
+          MonCat) with
     carrier := (F ⋙ forget GroupCat).sections
     inv_mem' := fun a ah j j' f =>
       by
@@ -77,17 +77,18 @@ the existing limit. -/
 @[to_additive
       "We show that the forgetful functor `AddGroup ⥤ AddMon` creates limits.\n\nAll we need to do is notice that the limit point has an `add_group` instance available, and then\nreuse the existing limit."]
 instance Forget₂.createsLimit (F : J ⥤ GroupCat.{max v u}) :
-    CreatesLimit F (forget₂ GroupCat.{max v u} Mon.{max v u}) :=
+    CreatesLimit F (forget₂ GroupCat.{max v u} MonCat.{max v u}) :=
   createsLimitOfReflectsIso fun c' t =>
     { liftedCone :=
         { pt := GroupCat.of (Types.limitCone (F ⋙ forget GroupCat)).pt
           π :=
-            { app := Mon.limitπMonoidHom (F ⋙ forget₂ GroupCat Mon.{max v u})
+            { app := MonCat.limitπMonoidHom (F ⋙ forget₂ GroupCat MonCat.{max v u})
               naturality' :=
-                (Mon.HasLimits.limitCone (F ⋙ forget₂ GroupCat Mon.{max v u})).π.naturality } }
-      validLift := by apply is_limit.unique_up_to_iso (Mon.HasLimits.limitConeIsLimit _) t
+                (MonCat.HasLimits.limitCone
+                      (F ⋙ forget₂ GroupCat MonCat.{max v u})).π.naturality } }
+      validLift := by apply is_limit.unique_up_to_iso (MonCat.HasLimits.limitConeIsLimit _) t
       makesLimit :=
-        IsLimit.ofFaithful (forget₂ GroupCat Mon.{max v u}) (Mon.HasLimits.limitConeIsLimit _)
+        IsLimit.ofFaithful (forget₂ GroupCat MonCat.{max v u}) (MonCat.HasLimits.limitConeIsLimit _)
           (fun s => _) fun s => rfl }
 #align Group.forget₂.creates_limit GroupCat.Forget₂.createsLimit
 #align AddGroup.forget₂.creates_limit AddGroupCat.Forget₂.createsLimit
@@ -98,7 +99,7 @@ instance Forget₂.createsLimit (F : J ⥤ GroupCat.{max v u}) :
 @[to_additive
       "A choice of limit cone for a functor into `Group`.\n(Generally, you'll just want to use `limit F`.)"]
 def limitCone (F : J ⥤ GroupCat.{max v u}) : Cone F :=
-  liftLimit (limit.isLimit (F ⋙ forget₂ GroupCat Mon.{max v u}))
+  liftLimit (limit.isLimit (F ⋙ forget₂ GroupCat MonCat.{max v u}))
 #align Group.limit_cone GroupCat.limitCone
 #align AddGroup.limit_cone AddGroupCat.limitCone
 
@@ -116,7 +117,7 @@ def limitConeIsLimit (F : J ⥤ GroupCat.{max v u}) : IsLimit (limitCone F) :=
 @[to_additive "The category of additive groups has all limits."]
 instance hasLimitsOfSize : HasLimitsOfSize.{v, v} GroupCat.{max v u}
     where HasLimitsOfShape J 𝒥 :=
-    { HasLimit := fun F => has_limit_of_created F (forget₂ GroupCat Mon.{max v u}) }
+    { HasLimit := fun F => has_limit_of_created F (forget₂ GroupCat MonCat.{max v u}) }
 #align Group.has_limits_of_size GroupCat.hasLimitsOfSize
 #align AddGroup.has_limits_of_size AddGroupCat.hasLimitsOfSize
 
@@ -133,13 +134,13 @@ This means the underlying monoid of a limit can be computed as a limit in the ca
 @[to_additive AddGroupCat.forget₂AddMonPreservesLimits
       "The forgetful functor from additive groups\nto additive monoids preserves all limits.\n\nThis means the underlying additive monoid of a limit can be computed as a limit in the category of\nadditive monoids."]
 instance forget₂MonPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ GroupCat Mon.{max v u})
+    PreservesLimitsOfSize.{v, v} (forget₂ GroupCat MonCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance }
 #align Group.forget₂_Mon_preserves_limits_of_size GroupCat.forget₂MonPreservesLimitsOfSize
 #align AddGroup.forget₂_AddMon_preserves_limits AddGroupCat.forget₂AddMonPreservesLimits
 
 @[to_additive]
-instance forget₂MonPreservesLimits : PreservesLimits (forget₂ GroupCat Mon.{u}) :=
+instance forget₂MonPreservesLimits : PreservesLimits (forget₂ GroupCat MonCat.{u}) :=
   GroupCat.forget₂MonPreservesLimitsOfSize.{u, u}
 #align Group.forget₂_Mon_preserves_limits GroupCat.forget₂MonPreservesLimits
 #align AddGroup.forget₂_Mon_preserves_limits AddGroupCat.forget₂MonPreservesLimits
@@ -151,7 +152,9 @@ This means the underlying type of a limit can be computed as a limit in the cate
       "The forgetful functor from additive groups to types preserves all limits.\n\nThis means the underlying type of a limit can be computed as a limit in the category of types."]
 instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget GroupCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 :=
-    { PreservesLimit := fun F => limits.comp_preserves_limit (forget₂ GroupCat Mon) (forget Mon) }
+    {
+      PreservesLimit := fun F =>
+        limits.comp_preserves_limit (forget₂ GroupCat MonCat) (forget MonCat) }
 #align Group.forget_preserves_limits_of_size GroupCat.forgetPreservesLimitsOfSize
 #align AddGroup.forget_preserves_limits_of_size AddGroupCat.forgetPreservesLimitsOfSize
 
@@ -196,13 +199,13 @@ instance Forget₂.createsLimit (F : J ⥤ CommGroupCat.{max v u}) :
         { pt := CommGroupCat.of (Types.limitCone (F ⋙ forget CommGroupCat)).pt
           π :=
             { app :=
-                Mon.limitπMonoidHom
-                  (F ⋙ forget₂ CommGroupCat GroupCat.{max v u} ⋙ forget₂ GroupCat Mon.{max v u})
-              naturality' := (Mon.HasLimits.limitCone _).π.naturality } }
+                MonCat.limitπMonoidHom
+                  (F ⋙ forget₂ CommGroupCat GroupCat.{max v u} ⋙ forget₂ GroupCat MonCat.{max v u})
+              naturality' := (MonCat.HasLimits.limitCone _).π.naturality } }
       validLift := by apply is_limit.unique_up_to_iso (GroupCat.limitConeIsLimit _) t
       makesLimit :=
-        IsLimit.ofFaithful (forget₂ _ GroupCat.{max v u} ⋙ forget₂ _ Mon.{max v u})
-          (by apply Mon.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl }
+        IsLimit.ofFaithful (forget₂ _ GroupCat.{max v u} ⋙ forget₂ _ MonCat.{max v u})
+          (by apply MonCat.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl }
 #align CommGroup.forget₂.creates_limit CommGroupCat.Forget₂.createsLimit
 #align AddCommGroup.forget₂.creates_limit AddCommGroupCat.Forget₂.createsLimit
 
@@ -263,8 +266,8 @@ instance forget₂GroupPreservesLimits : PreservesLimits (forget₂ CommGroupCat
 @[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
       "An auxiliary declaration to speed up typechecking."]
 def forget₂CommMonPreservesLimitsAux (F : J ⥤ CommGroupCat.{max v u}) :
-    IsLimit ((forget₂ CommGroupCat CommMon).mapCone (limitCone F)) :=
-  CommMon.limitConeIsLimit (F ⋙ forget₂ CommGroupCat CommMon)
+    IsLimit ((forget₂ CommGroupCat CommMonCat).mapCone (limitCone F)) :=
+  CommMonCat.limitConeIsLimit (F ⋙ forget₂ CommGroupCat CommMonCat)
 #align CommGroup.forget₂_CommMon_preserves_limits_aux CommGroupCat.forget₂CommMonPreservesLimitsAux
 #align AddCommGroup.forget₂_AddCommMon_preserves_limits_aux AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
 
@@ -275,7 +278,7 @@ in the category of commutative monoids.)
 @[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimits
       "The forgetful functor from additive commutative groups to additive commutative monoids preserves\nall limits. (That is, the underlying additive commutative monoids could have been computed instead\nas limits in the category of additive commutative monoids.)"]
 instance forget₂CommMonPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCat CommMon.{max v u})
+    PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCat CommMonCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 :=
     {
       PreservesLimit := fun F =>

70fd9563

bump to nightly-2023-02-28-22

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

1fb1623f

Diff

@@ -63,7 +63,7 @@ def sectionsSubgroup (F : J ⥤ GroupCat) : Subgroup (∀ j, F.obj j) :=
 
 @[to_additive]
 instance limitGroup (F : J ⥤ GroupCat.{max v u}) :
-    Group (Types.limitCone (F ⋙ forget GroupCat)).x :=
+    Group (Types.limitCone (F ⋙ forget GroupCat)).pt :=
   by
   change Group (sections_subgroup F)
   infer_instance
@@ -80,7 +80,7 @@ instance Forget₂.createsLimit (F : J ⥤ GroupCat.{max v u}) :
     CreatesLimit F (forget₂ GroupCat.{max v u} Mon.{max v u}) :=
   createsLimitOfReflectsIso fun c' t =>
     { liftedCone :=
-        { x := GroupCat.of (Types.limitCone (F ⋙ forget GroupCat)).x
+        { pt := GroupCat.of (Types.limitCone (F ⋙ forget GroupCat)).pt
           π :=
             { app := Mon.limitπMonoidHom (F ⋙ forget₂ GroupCat Mon.{max v u})
               naturality' :=
@@ -176,7 +176,7 @@ instance commGroupObj (F : J ⥤ CommGroupCat.{max v u}) (j) :
 
 @[to_additive]
 instance limitCommGroup (F : J ⥤ CommGroupCat.{max v u}) :
-    CommGroup (Types.limitCone (F ⋙ forget CommGroupCat.{max v u})).x :=
+    CommGroup (Types.limitCone (F ⋙ forget CommGroupCat.{max v u})).pt :=
   @Subgroup.toCommGroup (∀ j, F.obj j) _
     (GroupCat.sectionsSubgroup (F ⋙ forget₂ CommGroupCat GroupCat.{max v u}))
 #align CommGroup.limit_comm_group CommGroupCat.limitCommGroup
@@ -193,7 +193,7 @@ instance Forget₂.createsLimit (F : J ⥤ CommGroupCat.{max v u}) :
     CreatesLimit F (forget₂ CommGroupCat GroupCat.{max v u}) :=
   createsLimitOfReflectsIso fun c' t =>
     { liftedCone :=
-        { x := CommGroupCat.of (Types.limitCone (F ⋙ forget CommGroupCat)).x
+        { pt := CommGroupCat.of (Types.limitCone (F ⋙ forget CommGroupCat)).pt
           π :=
             { app :=
                 Mon.limitπMonoidHom

70fd9563

bump to nightly-2023-02-27-08

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

91d8c210

Diff

@@ -90,7 +90,7 @@ instance Forget₂.createsLimit (F : J ⥤ GroupCat.{max v u}) :
         IsLimit.ofFaithful (forget₂ GroupCat Mon.{max v u}) (Mon.HasLimits.limitConeIsLimit _)
           (fun s => _) fun s => rfl }
 #align Group.forget₂.creates_limit GroupCat.Forget₂.createsLimit
-#align AddGroup.forget₂.creates_limit AddGroupCat.Forget₂.creates_limit
+#align AddGroup.forget₂.creates_limit AddGroupCat.Forget₂.createsLimit
 
 /-- A choice of limit cone for a functor into `Group`.
 (Generally, you'll just want to use `limit F`.)
@@ -110,7 +110,7 @@ def limitCone (F : J ⥤ GroupCat.{max v u}) : Cone F :=
 def limitConeIsLimit (F : J ⥤ GroupCat.{max v u}) : IsLimit (limitCone F) :=
   liftedLimitIsLimit _
 #align Group.limit_cone_is_limit GroupCat.limitConeIsLimit
-#align AddGroup.limit_cone_is_limit AddGroupCat.limit_cone_is_limit
+#align AddGroup.limit_cone_is_limit AddGroupCat.limitConeIsLimit
 
 /-- The category of groups has all limits. -/
 @[to_additive "The category of additive groups has all limits."]
@@ -118,7 +118,7 @@ instance hasLimitsOfSize : HasLimitsOfSize.{v, v} GroupCat.{max v u}
     where HasLimitsOfShape J 𝒥 :=
     { HasLimit := fun F => has_limit_of_created F (forget₂ GroupCat Mon.{max v u}) }
 #align Group.has_limits_of_size GroupCat.hasLimitsOfSize
-#align AddGroup.has_limits_of_size AddGroupCat.has_limits_of_size
+#align AddGroup.has_limits_of_size AddGroupCat.hasLimitsOfSize
 
 @[to_additive]
 instance hasLimits : HasLimits GroupCat.{u} :=
@@ -130,13 +130,13 @@ instance hasLimits : HasLimits GroupCat.{u} :=
 
 This means the underlying monoid of a limit can be computed as a limit in the category of monoids.
 -/
-@[to_additive AddGroupCat.forget₂_AddMon_preserves_limits
+@[to_additive AddGroupCat.forget₂AddMonPreservesLimits
       "The forgetful functor from additive groups\nto additive monoids preserves all limits.\n\nThis means the underlying additive monoid of a limit can be computed as a limit in the category of\nadditive monoids."]
 instance forget₂MonPreservesLimitsOfSize :
     PreservesLimitsOfSize.{v, v} (forget₂ GroupCat Mon.{max v u})
     where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance }
 #align Group.forget₂_Mon_preserves_limits_of_size GroupCat.forget₂MonPreservesLimitsOfSize
-#align AddGroup.forget₂_AddMon_preserves_limits AddGroupCat.forget₂_AddMon_preserves_limits
+#align AddGroup.forget₂_AddMon_preserves_limits AddGroupCat.forget₂AddMonPreservesLimits
 
 @[to_additive]
 instance forget₂MonPreservesLimits : PreservesLimits (forget₂ GroupCat Mon.{u}) :=
@@ -153,7 +153,7 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget Grou
     where PreservesLimitsOfShape J 𝒥 :=
     { PreservesLimit := fun F => limits.comp_preserves_limit (forget₂ GroupCat Mon) (forget Mon) }
 #align Group.forget_preserves_limits_of_size GroupCat.forgetPreservesLimitsOfSize
-#align AddGroup.forget_preserves_limits_of_size AddGroupCat.forget_preserves_limits_of_size
+#align AddGroup.forget_preserves_limits_of_size AddGroupCat.forgetPreservesLimitsOfSize
 
 @[to_additive]
 instance forgetPreservesLimits : PreservesLimits (forget GroupCat.{u}) :=
@@ -204,7 +204,7 @@ instance Forget₂.createsLimit (F : J ⥤ CommGroupCat.{max v u}) :
         IsLimit.ofFaithful (forget₂ _ GroupCat.{max v u} ⋙ forget₂ _ Mon.{max v u})
           (by apply Mon.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl }
 #align CommGroup.forget₂.creates_limit CommGroupCat.Forget₂.createsLimit
-#align AddCommGroup.forget₂.creates_limit AddCommGroupCat.Forget₂.creates_limit
+#align AddCommGroup.forget₂.creates_limit AddCommGroupCat.Forget₂.createsLimit
 
 /-- A choice of limit cone for a functor into `CommGroup`.
 (Generally, you'll just want to use `limit F`.)
@@ -224,7 +224,7 @@ def limitCone (F : J ⥤ CommGroupCat.{max v u}) : Cone F :=
 def limitConeIsLimit (F : J ⥤ CommGroupCat.{max v u}) : IsLimit (limitCone F) :=
   liftedLimitIsLimit _
 #align CommGroup.limit_cone_is_limit CommGroupCat.limitConeIsLimit
-#align AddCommGroup.limit_cone_is_limit AddCommGroupCat.limit_cone_is_limit
+#align AddCommGroup.limit_cone_is_limit AddCommGroupCat.limitConeIsLimit
 
 /-- The category of commutative groups has all limits. -/
 @[to_additive "The category of additive commutative groups has all limits."]
@@ -232,7 +232,7 @@ instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommGroupCat.{max v u}
     where HasLimitsOfShape J 𝒥 :=
     { HasLimit := fun F => has_limit_of_created F (forget₂ CommGroupCat GroupCat.{max v u}) }
 #align CommGroup.has_limits_of_size CommGroupCat.hasLimitsOfSize
-#align AddCommGroup.has_limits_of_size AddCommGroupCat.has_limits_of_size
+#align AddCommGroup.has_limits_of_size AddCommGroupCat.hasLimitsOfSize
 
 @[to_additive]
 instance hasLimits : HasLimits CommGroupCat.{u} :=
@@ -244,13 +244,13 @@ instance hasLimits : HasLimits CommGroupCat.{u} :=
 (That is, the underlying group could have been computed instead as limits in the category
 of groups.)
 -/
-@[to_additive AddCommGroupCat.forget₂_AddGroup_preserves_limits
+@[to_additive AddCommGroupCat.forget₂AddGroupPreservesLimits
       "The forgetful functor from additive commutative groups to groups preserves all limits.\n(That is, the underlying group could have been computed instead as limits in the category\nof additive groups.)"]
 instance forget₂GroupPreservesLimitsOfSize :
     PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCat GroupCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 := { PreservesLimit := fun F => by infer_instance }
 #align CommGroup.forget₂_Group_preserves_limits_of_size CommGroupCat.forget₂GroupPreservesLimitsOfSize
-#align AddCommGroup.forget₂_AddGroup_preserves_limits AddCommGroupCat.forget₂_AddGroup_preserves_limits
+#align AddCommGroup.forget₂_AddGroup_preserves_limits AddCommGroupCat.forget₂AddGroupPreservesLimits
 
 @[to_additive]
 instance forget₂GroupPreservesLimits : PreservesLimits (forget₂ CommGroupCat GroupCat.{u}) :=
@@ -260,19 +260,19 @@ instance forget₂GroupPreservesLimits : PreservesLimits (forget₂ CommGroupCat
 
 /-- An auxiliary declaration to speed up typechecking.
 -/
-@[to_additive AddCommGroupCat.forget₂_AddCommMon_preserves_limits_aux
+@[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
       "An auxiliary declaration to speed up typechecking."]
 def forget₂CommMonPreservesLimitsAux (F : J ⥤ CommGroupCat.{max v u}) :
     IsLimit ((forget₂ CommGroupCat CommMon).mapCone (limitCone F)) :=
   CommMon.limitConeIsLimit (F ⋙ forget₂ CommGroupCat CommMon)
 #align CommGroup.forget₂_CommMon_preserves_limits_aux CommGroupCat.forget₂CommMonPreservesLimitsAux
-#align AddCommGroup.forget₂_AddCommMon_preserves_limits_aux AddCommGroupCat.forget₂_AddCommMon_preserves_limits_aux
+#align AddCommGroup.forget₂_AddCommMon_preserves_limits_aux AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
 
 /-- The forgetful functor from commutative groups to commutative monoids preserves all limits.
 (That is, the underlying commutative monoids could have been computed instead as limits
 in the category of commutative monoids.)
 -/
-@[to_additive AddCommGroupCat.forget₂_AddCommMon_preserves_limits
+@[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimits
       "The forgetful functor from additive commutative groups to additive commutative monoids preserves\nall limits. (That is, the underlying additive commutative monoids could have been computed instead\nas limits in the category of additive commutative monoids.)"]
 instance forget₂CommMonPreservesLimitsOfSize :
     PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCat CommMon.{max v u})
@@ -282,12 +282,12 @@ instance forget₂CommMonPreservesLimitsOfSize :
         preserves_limit_of_preserves_limit_cone (limit_cone_is_limit F)
           (forget₂_CommMon_preserves_limits_aux F) }
 #align CommGroup.forget₂_CommMon_preserves_limits_of_size CommGroupCat.forget₂CommMonPreservesLimitsOfSize
-#align AddCommGroup.forget₂_AddCommMon_preserves_limits AddCommGroupCat.forget₂_AddCommMon_preserves_limits
+#align AddCommGroup.forget₂_AddCommMon_preserves_limits AddCommGroupCat.forget₂AddCommMonPreservesLimits
 
 /-- The forgetful functor from commutative groups to types preserves all limits. (That is, the
 underlying types could have been computed instead as limits in the category of types.)
 -/
-@[to_additive AddCommGroupCat.forget_preserves_limits
+@[to_additive AddCommGroupCat.forgetPreservesLimits
       "The forgetful functor from additive commutative groups to types preserves all limits. (That is,\nthe underlying types could have been computed instead as limits in the category of types.)"]
 instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget CommGroupCat.{max v u})
     where PreservesLimitsOfShape J 𝒥 :=
@@ -295,7 +295,7 @@ instance forgetPreservesLimitsOfSize : PreservesLimitsOfSize.{v, v} (forget Comm
       PreservesLimit := fun F =>
         limits.comp_preserves_limit (forget₂ CommGroupCat GroupCat) (forget GroupCat) }
 #align CommGroup.forget_preserves_limits_of_size CommGroupCat.forgetPreservesLimitsOfSize
-#align AddCommGroup.forget_preserves_limits AddCommGroupCat.forget_preserves_limits
+#align AddCommGroup.forget_preserves_limits AddCommGroupCat.forgetPreservesLimits
 
 -- Verify we can form limits indexed over smaller categories.
 example (f : ℕ → AddCommGroupCat) : HasProduct f := by infer_instance

70fd9563

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

70fd9563

feat: make generalize_proofs handle proofs under binders (#12472)

The generalize_proofs tactic had a bug where it would not generalize proofs that appeared under binders correctly, creating terms with fvars from the wrong context. The tactic has been refactored, and it now abstracts the proofs (universally quantifying all the bound variables that appear in the proof) before lifting them to the local context.

This feature can be controlled with the abstract option. Using generalize_proofs (config := { abstract := false }) turns off proof abstraction and leaves alone those proofs that refer to bound variables.

Other new features:

generalize_proofs at h for a let-bound local hypothesis h will clear its value.
generalize_proofs at h for a duplicate proposition will eliminate h from the local context.
Proofs are recursively generalized for each new local hypothesis. This can be turned off with generalize_proofs (config := { maxDepth := 0 }).
generalize_proofs at h will no longer generalize proofs from the goal.
The type of the generalized proof is carefully computed by propagating expected types, rather than by using inferType. This gives local hypotheses in more useful forms.

(This PR serves as a followup to this comment.)

32616bea

Diff

@@ -520,18 +520,14 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
     refine equalizer.hom_ext ?_
     ext x
     dsimp
-    generalize_proofs _ h1 h2
-    erw [DFunLike.congr_fun (kernel.lift_ι f _ h1) ⟨_, h2⟩]
-    rfl
+    apply DFunLike.congr_fun (kernel.lift_ι f _ _)
   inv_hom_id := by
     apply AddCommGroupCat.ext
     simp only [AddMonoidHom.coe_mk, coe_id, coe_comp]
     rintro ⟨x, mem⟩
     refine Subtype.ext ?_
     simp only [ZeroHom.coe_mk, Function.comp_apply, id_eq]
-    generalize_proofs _ h1 h2
-    erw [DFunLike.congr_fun (kernel.lift_ι f _ h1) ⟨_, mem⟩]
-    rfl
+    apply DFunLike.congr_fun (kernel.lift_ι f _ _)
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.kernel_iso_ker AddCommGroupCat.kernelIsoKer

70fd9563

feat: the forget functor from commutative groups to groups preserves all limits (#11669)

It is shown in this PR that the forget functor from commutative groups to groups preserves all limits (regardless of the universe parameters of the index category). It is also shown that a functor F : J ⥤ CommGroupCat (or F : J ⥤ GroupCat) has a limit iff the type (F ⋙ forget _).sections is small. This is related to the fact that the forget functor CommGroupCat.{u} ⥤ Type u is corepresentable (by ULift ℤ).

Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr>

e8ccef95

Diff

@@ -5,7 +5,9 @@ Authors: Scott Morrison
 -/
 import Mathlib.Algebra.Category.MonCat.Limits
 import Mathlib.Algebra.Category.GroupCat.Preadditive
+import Mathlib.Algebra.Category.GroupCat.ForgetCorepresentable
 import Mathlib.CategoryTheory.Comma.Over
+import Mathlib.CategoryTheory.Limits.ConcreteCategory
 import Mathlib.CategoryTheory.ConcreteCategory.ReflectsIso
 import Mathlib.GroupTheory.Subgroup.Basic
 
@@ -60,6 +62,8 @@ set_option linter.uppercaseLean3 false in
 instance sectionsGroup : Group (F ⋙ forget GroupCat.{u}).sections :=
   (sectionsSubgroup F).toGroup
 
+section
+
 variable [Small.{u} (Functor.sections (F ⋙ forget GroupCat))]
 
 @[to_additive]
@@ -138,6 +142,19 @@ instance hasLimit : HasLimit F :=
     isLimit := limitConeIsLimit F
   }
 
+end
+
+/-- A functor `F : J ⥤ GroupCat.{u}` has a limit iff `(F ⋙ forget GroupCat).sections` is
+`u`-small.  -/
+@[to_additive "A functor `F : J ⥤ AddGroupCat.{u}` has a limit iff
+`(F ⋙ forget AddGroupCat).sections` is `u`-small."]
+lemma hasLimit_iff_small_sections :
+    HasLimit F ↔ Small.{u} (F ⋙ forget GroupCat).sections := by
+  constructor
+  · apply Concrete.small_sections_of_hasLimit
+  · intro
+    infer_instance
+
 /-- If `J` is `u`-small, `GroupCat.{u}` has limits of shape `J`. -/
 @[to_additive "If `J` is `u`-small, `AddGroupCat.{u}` has limits of shape `J`."]
 instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J GroupCat.{u} where
@@ -203,9 +220,8 @@ This means the underlying type of a limit can be computed as a limit in the cate
 
   This means the underlying type of a limit can be computed as a limit in the category of types.",
   to_additive_relevant_arg 2]
-noncomputable instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
-    PreservesLimitsOfSize.{w, v} (forget GroupCat.{u})
-  where preservesLimitsOfShape {J _} := { }
+noncomputable instance forgetPreservesLimitsOfSize :
+    PreservesLimitsOfSize.{w, v} (forget GroupCat.{u}) := inferInstance
 set_option linter.uppercaseLean3 false in
 #align Group.forget_preserves_limits_of_size GroupCat.forgetPreservesLimitsOfSize
 set_option linter.uppercaseLean3 false in
@@ -233,10 +249,9 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.add_comm_group_obj AddCommGroupCat.addCommGroupObj
 
-variable [Small.{u} (Functor.sections (F ⋙ forget CommGroupCat))]
-
 @[to_additive]
-noncomputable instance limitCommGroup :
+noncomputable instance limitCommGroup
+    [Small.{u} (Functor.sections (F ⋙ forget CommGroupCat))] :
     CommGroup (Types.Small.limitCone.{v, u} (F ⋙ forget CommGroupCat.{u})).pt :=
   letI : CommGroup (F ⋙ forget CommGroupCat.{u}).sections :=
     @Subgroup.toCommGroup (∀ j, F.obj j) _
@@ -247,6 +262,10 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.limit_add_comm_group AddCommGroupCat.limitAddCommGroup
 
+@[to_additive]
+instance : (forget₂ CommGroupCat.{u} GroupCat.{u}).ReflectsIsomorphisms :=
+    reflectsIsomorphisms_forget₂ _ _
+
 /-- We show that the forgetful functor `CommGroupCat ⥤ GroupCat` creates limits.
 
 All we need to do is notice that the limit point has a `CommGroup` instance available,
@@ -258,30 +277,33 @@ and then reuse the existing limit.
   and then reuse the existing limit."]
 noncomputable instance Forget₂.createsLimit :
     CreatesLimit F (forget₂ CommGroupCat GroupCat.{u}) :=
-  letI : (forget₂ CommGroupCat.{u} GroupCat.{u}).ReflectsIsomorphisms :=
-    CategoryTheory.reflectsIsomorphisms_forget₂ _ _
-  letI : Small.{u}
-      (Functor.sections ((F ⋙ forget₂ CommGroupCat GroupCat) ⋙ forget GroupCat)) :=
-    inferInstanceAs <| Small (Functor.sections (F ⋙ forget CommGroupCat))
-  letI : Small.{u}
-      (Functor.sections ((F ⋙ forget₂ _ GroupCat ⋙ forget₂ _ MonCat) ⋙ forget MonCat)) :=
-    inferInstanceAs <| Small (Functor.sections (F ⋙ forget CommGroupCat))
-  createsLimitOfReflectsIso fun c' t =>
-    { liftedCone :=
-        { pt := CommGroupCat.of (Types.Small.limitCone.{v, u} (F ⋙ forget CommGroupCat)).pt
-          π :=
-            { app := MonCat.limitπMonoidHom
-                (F ⋙ forget₂ CommGroupCat GroupCat.{u} ⋙ forget₂ GroupCat MonCat.{u})
-              naturality := (MonCat.HasLimits.limitCone _).π.naturality } }
-      validLift := by apply IsLimit.uniqueUpToIso (GroupCat.limitConeIsLimit _) t
-      makesLimit :=
-        IsLimit.ofFaithful (forget₂ _ GroupCat.{u} ⋙ forget₂ _ MonCat.{u})
-          (by apply MonCat.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl }
+  createsLimitOfReflectsIso (fun c hc => by
+    have : HasLimit _ := ⟨_, hc⟩
+    have : Small.{u} (F ⋙ forget CommGroupCat).sections :=
+      Concrete.small_sections_of_hasLimit (F ⋙ forget₂ CommGroupCat GroupCat)
+    have : Small.{u} ((F ⋙ forget₂ CommGroupCat GroupCat ⋙ forget₂ GroupCat MonCat) ⋙
+      forget MonCat).sections := this
+    have : Small.{u} ((F ⋙ forget₂ CommGroupCat GroupCat) ⋙ forget GroupCat).sections := this
+    exact
+      { liftedCone :=
+          { pt := CommGroupCat.of (Types.Small.limitCone.{v, u} (F ⋙ forget CommGroupCat)).pt
+            π :=
+              { app := MonCat.limitπMonoidHom
+                  (F ⋙ forget₂ CommGroupCat GroupCat.{u} ⋙ forget₂ GroupCat MonCat.{u})
+                naturality := (MonCat.HasLimits.limitCone _).π.naturality } }
+        validLift := by apply IsLimit.uniqueUpToIso (GroupCat.limitConeIsLimit _) hc
+        makesLimit :=
+          IsLimit.ofFaithful (forget₂ _ GroupCat.{u} ⋙ forget₂ _ MonCat.{u})
+            (by apply MonCat.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl })
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget₂.creates_limit CommGroupCat.Forget₂.createsLimit
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.forget₂.creates_limit AddCommGroupCat.Forget₂.createsLimit
 
+section
+
+variable [Small.{u} (Functor.sections (F ⋙ forget CommGroupCat))]
+
 /-- A choice of limit cone for a functor into `CommGroupCat`.
 (Generally, you'll just want to use `limit F`.)
 -/
@@ -318,6 +340,19 @@ instance hasLimit : HasLimit F :=
     isLimit := limitConeIsLimit F
   }
 
+end
+
+/-- A functor `F : J ⥤ CommGroupCat.{u}` has a limit iff `(F ⋙ forget CommGroupCat).sections` is
+`u`-small.  -/
+@[to_additive "A functor `F : J ⥤ AddCommGroupCat.{u}` has a limit iff
+`(F ⋙ forget AddCommGroupCat).sections` is `u`-small."]
+lemma hasLimit_iff_small_sections :
+    HasLimit F ↔ Small.{u} (F ⋙ forget CommGroupCat).sections := by
+  constructor
+  · apply Concrete.small_sections_of_hasLimit
+  · intro
+    infer_instance
+
 /-- If `J` is `u`-small, `CommGroupCat.{u}` has limits of shape `J`. -/
 @[to_additive "If `J` is `u`-small, `AddCommGroupCat.{u}` has limits of shape `J`."]
 instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J CommGroupCat.{u} where
@@ -340,18 +375,32 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.has_limits AddCommGroupCat.hasLimits
 
+@[to_additive]
+noncomputable instance forget₂GroupPreservesLimit :
+    PreservesLimit F (forget₂ CommGroupCat.{u} GroupCat.{u}) where
+  preserves {c} hc := by
+    have : HasLimit (F ⋙ forget₂ CommGroupCat GroupCat) := by
+      rw [GroupCat.hasLimit_iff_small_sections]
+      change Small.{u} (F ⋙ forget CommGroupCat).sections
+      rw [← CommGroupCat.hasLimit_iff_small_sections]
+      exact ⟨_, hc⟩
+    exact isLimitOfPreserves _ hc
+
+@[to_additive]
+noncomputable instance forget₂GroupPreservesLimitsOfShape :
+    PreservesLimitsOfShape J (forget₂ CommGroupCat.{u} GroupCat.{u}) where
+
 /-- The forgetful functor from commutative groups to groups preserves all limits.
 (That is, the underlying group could have been computed instead as limits in the category
 of groups.)
 -/
 @[to_additive
-  "The forgetful functor from additive commutative groups to groups preserves all limits.
+  "The forgetful functor from additive commutative groups to additive groups preserves all limits.
   (That is, the underlying group could have been computed instead as limits in the category
     of additive groups.)",
   to_additive_relevant_arg 2]
-noncomputable instance forget₂GroupPreservesLimitsOfSize [UnivLE.{v, u}] :
+noncomputable instance forget₂GroupPreservesLimitsOfSize :
     PreservesLimitsOfSize.{w, v} (forget₂ CommGroupCat.{u} GroupCat.{u}) where
-  preservesLimitsOfShape {J 𝒥} := { }
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget₂_Group_preserves_limits_of_size CommGroupCat.forget₂GroupPreservesLimitsOfSize
 set_option linter.uppercaseLean3 false in
@@ -370,7 +419,8 @@ set_option linter.uppercaseLean3 false in
 -/
 @[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
   "An auxiliary declaration to speed up typechecking."]
-noncomputable def forget₂CommMonPreservesLimitsAux :
+noncomputable def forget₂CommMonPreservesLimitsAux
+    [Small.{u} (F ⋙ forget CommGroupCat).sections] :
     IsLimit ((forget₂ CommGroupCat.{u} CommMonCat.{u}).mapCone (limitCone.{v, u} F)) :=
   letI : Small.{u} (Functor.sections ((F ⋙ forget₂ _ CommMonCat) ⋙ forget CommMonCat)) :=
     inferInstanceAs <| Small (Functor.sections (F ⋙ forget CommGroupCat))
@@ -422,9 +472,8 @@ underlying types could have been computed instead as limits in the category of t
   "The forgetful functor from additive commutative groups to types preserves all limits.
   (That is, the underlying types could have been computed instead as limits in the category of
   types.)"]
-noncomputable instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
-    PreservesLimitsOfSize.{w, v} (forget CommGroupCat.{u}) where
-  preservesLimitsOfShape {_ _} := { }
+noncomputable instance forgetPreservesLimitsOfSize :
+    PreservesLimitsOfSize.{w, v} (forget CommGroupCat.{u}) := inferInstance
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget_preserves_limits_of_size CommGroupCat.forgetPreservesLimitsOfSize
 set_option linter.uppercaseLean3 false in

70fd9563

chore(CategoryTheory): move Full, Faithful, EssSurj, IsEquivalence and ReflectsIsomorphisms to the Functor namespace (#11985)

These notions on functors are now Functor.Full, Functor.Faithful, Functor.EssSurj, Functor.IsEquivalence, Functor.ReflectsIsomorphisms. Deprecated aliases are introduced for the previous names.

65b7affc

Diff

@@ -86,7 +86,7 @@ reuse the existing limit."]
 noncomputable instance Forget₂.createsLimit :
     CreatesLimit F (forget₂ GroupCat.{u} MonCat.{u}) :=
   -- Porting note: need to add `forget₂ GrpCat MonCat` reflects isomorphism
-  letI : ReflectsIsomorphisms (forget₂ GroupCat.{u} MonCat.{u}) :=
+  letI : (forget₂ GroupCat.{u} MonCat.{u}).ReflectsIsomorphisms :=
     CategoryTheory.reflectsIsomorphisms_forget₂ _ _
   createsLimitOfReflectsIso (K := F) (F := (forget₂ GroupCat.{u} MonCat.{u}))
     fun c' t =>
@@ -258,7 +258,7 @@ and then reuse the existing limit.
   and then reuse the existing limit."]
 noncomputable instance Forget₂.createsLimit :
     CreatesLimit F (forget₂ CommGroupCat GroupCat.{u}) :=
-  letI : ReflectsIsomorphisms (forget₂ CommGroupCat.{u} GroupCat.{u}) :=
+  letI : (forget₂ CommGroupCat.{u} GroupCat.{u}).ReflectsIsomorphisms :=
     CategoryTheory.reflectsIsomorphisms_forget₂ _ _
   letI : Small.{u}
       (Functor.sections ((F ⋙ forget₂ CommGroupCat GroupCat) ⋙ forget GroupCat)) :=

70fd9563

doc(Algebra,AlgebraicGeometry): remove mathlib3 names in doc comments (#11955)

Mostly automatic, with a few manual corrections.

11516514

Diff

@@ -503,7 +503,7 @@ set_option linter.uppercaseLean3 false in
 -- Porting note: explicitly add what to be synthesized under `simps!`, because other lemmas
 -- automatically generated is not in normal form
 /-- The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`,
-agrees with the `subtype` map.
+agrees with the `AddSubgroup.subtype` map.
 -/
 @[simps! hom_left_apply_coe inv_left_apply]
 def kernelIsoKerOver {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :

70fd9563

refactor(Algebra/Category): replace TypeMax constructions by UnivLE assumptions (#11420)

Replaces TypeMax limit constructions in MonCat, GroupCat, Ring, AlgebraCat and ModuleCat by the UnivLE analogs. Also generalizes some universe assumptions.

a746c523

Diff

@@ -22,18 +22,19 @@ the underlying types are just the limits in the category of types.
 
 open CategoryTheory CategoryTheory.Limits
 
-universe v u
+universe v u w
 
 noncomputable section
 
-variable {J : Type v} [SmallCategory J]
+variable {J : Type v} [Category.{w} J]
 
 namespace GroupCat
 
+variable (F : J ⥤ GroupCat.{u})
+
 @[to_additive]
-instance groupObj (F : J ⥤ GroupCatMax.{v, u}) (j) : Group ((F ⋙ forget GroupCat).obj j) := by
-  change Group (F.obj j)
-  infer_instance
+instance groupObj (j) : Group ((F ⋙ forget GroupCat).obj j) :=
+  inferInstanceAs <| Group (F.obj j)
 set_option linter.uppercaseLean3 false in
 #align Group.group_obj GroupCat.groupObj
 set_option linter.uppercaseLean3 false in
@@ -43,7 +44,7 @@ set_option linter.uppercaseLean3 false in
 -/
 @[to_additive
   "The flat sections of a functor into `AddGroupCat` form an additive subgroup of all sections."]
-def sectionsSubgroup (F : J ⥤ GroupCat) : Subgroup (∀ j, F.obj j) :=
+def sectionsSubgroup : Subgroup (∀ j, F.obj j) :=
   { MonCat.sectionsSubmonoid (F ⋙ forget₂ GroupCat MonCat) with
     carrier := (F ⋙ forget GroupCat).sections
     inv_mem' := fun {a} ah j j' f => by
@@ -56,15 +57,24 @@ set_option linter.uppercaseLean3 false in
 #align AddGroup.sections_add_subgroup AddGroupCat.sectionsAddSubgroup
 
 @[to_additive]
-noncomputable instance limitGroup (F : J ⥤ GroupCatMax.{v, u}) :
-    Group (Types.limitCone.{v, u} (F ⋙ forget GroupCat)).pt := by
-  change Group (sectionsSubgroup.{v, u} F)
-  infer_instance
+instance sectionsGroup : Group (F ⋙ forget GroupCat.{u}).sections :=
+  (sectionsSubgroup F).toGroup
+
+variable [Small.{u} (Functor.sections (F ⋙ forget GroupCat))]
+
+@[to_additive]
+noncomputable instance limitGroup :
+    Group (Types.Small.limitCone.{v, u} (F ⋙ forget GroupCat.{u})).pt :=
+  inferInstanceAs <| Group (Shrink (F ⋙ forget GroupCat.{u}).sections)
 set_option linter.uppercaseLean3 false in
 #align Group.limit_group GroupCat.limitGroup
 set_option linter.uppercaseLean3 false in
 #align AddGroup.limit_add_group AddGroupCat.limitAddGroup
 
+@[to_additive]
+instance : Small.{u} (Functor.sections ((F ⋙ forget₂ GroupCat MonCat) ⋙ forget MonCat)) :=
+  inferInstanceAs <| Small.{u} (Functor.sections (F ⋙ forget GroupCat))
+
 /-- We show that the forgetful functor `GroupCat ⥤ MonCat` creates limits.
 
 All we need to do is notice that the limit point has a `Group` instance available, and then reuse
@@ -73,23 +83,23 @@ the existing limit. -/
 
 All we need to do is notice that the limit point has an `AddGroup` instance available, and then
 reuse the existing limit."]
-noncomputable instance Forget₂.createsLimit (F : J ⥤ GroupCatMax.{v, u}) :
-    CreatesLimit F (forget₂ GroupCatMax.{v, u} MonCatMax.{v, u}) :=
+noncomputable instance Forget₂.createsLimit :
+    CreatesLimit F (forget₂ GroupCat.{u} MonCat.{u}) :=
   -- Porting note: need to add `forget₂ GrpCat MonCat` reflects isomorphism
-  letI : ReflectsIsomorphisms (forget₂ GroupCatMax.{v, u} MonCatMax.{v, u}) :=
+  letI : ReflectsIsomorphisms (forget₂ GroupCat.{u} MonCat.{u}) :=
     CategoryTheory.reflectsIsomorphisms_forget₂ _ _
-  createsLimitOfReflectsIso (K := F) (F := (forget₂ GroupCat.{max v u} MonCat.{max v u}))
+  createsLimitOfReflectsIso (K := F) (F := (forget₂ GroupCat.{u} MonCat.{u}))
     fun c' t =>
     { liftedCone :=
-        { pt := GroupCat.of (Types.limitCone (F ⋙ forget GroupCatMax)).pt
+        { pt := GroupCat.of (Types.Small.limitCone (F ⋙ forget GroupCat)).pt
           π :=
-            { app := MonCat.limitπMonoidHom (F ⋙ forget₂ GroupCatMax MonCatMax)
+            { app := MonCat.limitπMonoidHom (F ⋙ forget₂ GroupCat MonCat)
               naturality :=
                 (MonCat.HasLimits.limitCone
-                      (F ⋙ forget₂ GroupCat MonCat.{max v u})).π.naturality } }
+                      (F ⋙ forget₂ GroupCat MonCat.{u})).π.naturality } }
       validLift := by apply IsLimit.uniqueUpToIso (MonCat.HasLimits.limitConeIsLimit.{v, u} _) t
       makesLimit :=
-        IsLimit.ofFaithful (forget₂ GroupCat MonCat.{max v u}) (MonCat.HasLimits.limitConeIsLimit _)
+        IsLimit.ofFaithful (forget₂ GroupCat MonCat.{u}) (MonCat.HasLimits.limitConeIsLimit _)
           (fun s => _) fun s => rfl }
 set_option linter.uppercaseLean3 false in
 #align Group.forget₂.creates_limit GroupCat.Forget₂.createsLimit
@@ -101,12 +111,8 @@ set_option linter.uppercaseLean3 false in
 -/
 @[to_additive "A choice of limit cone for a functor into `GroupCat`.
   (Generally, you'll just want to use `limit F`.)"]
-noncomputable def limitCone (F : J ⥤ GroupCatMax.{v, u}) : Cone F :=
-  -- Porting note: add this instance to help Lean unify universe levels
-  letI : HasLimit (F ⋙ forget₂ GroupCatMax.{v, u} MonCat.{max v u}) :=
-    (MonCat.hasLimitsOfSize.{v, u}.1 J).1 _
-  liftLimit
-    (limit.isLimit (F ⋙ forget₂ GroupCatMax.{v, u} MonCat.{max v u}))
+noncomputable def limitCone : Cone F :=
+  liftLimit (limit.isLimit (F ⋙ forget₂ GroupCat.{u} MonCat.{u}))
 set_option linter.uppercaseLean3 false in
 #align Group.limit_cone GroupCat.limitCone
 set_option linter.uppercaseLean3 false in
@@ -117,22 +123,30 @@ set_option linter.uppercaseLean3 false in
 -/
 @[to_additive "The chosen cone is a limit cone.
   (Generally, you'll just want to use `limit.cone F`.)"]
-noncomputable def limitConeIsLimit (F : J ⥤ GroupCatMax.{v, u}) : IsLimit (limitCone F) :=
+noncomputable def limitConeIsLimit : IsLimit (limitCone F) :=
   liftedLimitIsLimit _
 set_option linter.uppercaseLean3 false in
 #align Group.limit_cone_is_limit GroupCat.limitConeIsLimit
 set_option linter.uppercaseLean3 false in
 #align AddGroup.limit_cone_is_limit AddGroupCat.limitConeIsLimit
 
+/-- If `(F ⋙ forget GroupCat).sections` is `u`-small, `F` has a limit. -/
+@[to_additive "If `(F ⋙ forget AddGroupCat).sections` is `u`-small, `F` has a limit."]
+instance hasLimit : HasLimit F :=
+  HasLimit.mk {
+    cone := limitCone F
+    isLimit := limitConeIsLimit F
+  }
+
+/-- If `J` is `u`-small, `GroupCat.{u}` has limits of shape `J`. -/
+@[to_additive "If `J` is `u`-small, `AddGroupCat.{u}` has limits of shape `J`."]
+instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J GroupCat.{u} where
+  has_limit _ := inferInstance
+
 /-- The category of groups has all limits. -/
 @[to_additive "The category of additive groups has all limits."]
-instance hasLimitsOfSize : HasLimitsOfSize.{v, v} GroupCatMax.{v, u} where
-  has_limits_of_shape J _ :=
-    { has_limit :=
-        -- Porting note: add this instance to help Lean unify universe levels
-        fun F => letI : HasLimit (F ⋙ forget₂ GroupCatMax.{v, u} MonCat.{max v u}) :=
-          (MonCat.hasLimitsOfSize.{v, u}.1 J).1 _
-        hasLimit_of_created F (forget₂ GroupCatMax.{v, u} MonCat.{max v u}) }
+instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} GroupCat.{u} where
+  has_limits_of_shape J _ := { }
 set_option linter.uppercaseLean3 false in
 #align Group.has_limits_of_size GroupCat.hasLimitsOfSize
 set_option linter.uppercaseLean3 false in
@@ -150,22 +164,19 @@ set_option linter.uppercaseLean3 false in
 
 This means the underlying monoid of a limit can be computed as a limit in the category of monoids.
 -/
-@[to_additive AddGroupCat.forget₂AddMonPreservesLimits
+@[to_additive AddGroupCat.forget₂AddMonPreservesLimitsOfSize
   "The forgetful functor from additive groups to additive monoids preserves all limits.
 
   This means the underlying additive monoid of a limit can be computed as a limit in the category of
-  additive monoids."]
-noncomputable instance forget₂MonPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ GroupCatMax.{v, u} MonCat.{max v u}) where
-  preservesLimitsOfShape {J _} := { preservesLimit := fun {F} =>
-      -- Porting note: add this instance to help Lean unify universe levels
-      letI : HasLimit (F ⋙ forget₂ GroupCatMax.{v, u} MonCat.{max v u}) :=
-        (MonCat.hasLimitsOfSize.{v, u}.1 J).1 _
-      inferInstance }
+  additive monoids.",
+  to_additive_relevant_arg 2]
+noncomputable instance forget₂MonPreservesLimitsOfSize [UnivLE.{v, u}] :
+    PreservesLimitsOfSize.{w, v} (forget₂ GroupCat.{u} MonCat.{u}) where
+  preservesLimitsOfShape {J _} := { }
 set_option linter.uppercaseLean3 false in
 #align Group.forget₂_Mon_preserves_limits_of_size GroupCat.forget₂MonPreservesLimitsOfSize
 set_option linter.uppercaseLean3 false in
-#align AddGroup.forget₂_AddMon_preserves_limits AddGroupCat.forget₂AddMonPreservesLimits
+#align AddGroup.forget₂_AddMon_preserves_limits AddGroupCat.forget₂AddMonPreservesLimitsOfSize
 
 @[to_additive]
 noncomputable instance forget₂MonPreservesLimits :
@@ -176,25 +187,25 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddGroup.forget₂_Mon_preserves_limits AddGroupCat.forget₂MonPreservesLimits
 
+/-- If `J` is `u`-small, the forgetful functor from `GroupCat.{u}` preserves limits of shape `J`. -/
+@[to_additive "If `J` is `u`-small, the forgetful functor from `AddGroupCat.{u}`\n
+preserves limits of shape `J`."]
+noncomputable instance forgetPreservesLimitsOfShape [Small.{u} J] :
+    PreservesLimitsOfShape J (forget GroupCat.{u}) where
+  preservesLimit {F} := preservesLimitOfPreservesLimitCone (limitConeIsLimit F)
+    (Types.Small.limitConeIsLimit (F ⋙ forget _))
+
 /-- The forgetful functor from groups to types preserves all limits.
 
 This means the underlying type of a limit can be computed as a limit in the category of types. -/
 @[to_additive
   "The forgetful functor from additive groups to types preserves all limits.
 
-  This means the underlying type of a limit can be computed as a limit in the category of types."]
-noncomputable instance forgetPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget GroupCatMax.{v, u})
-  where preservesLimitsOfShape {J _} :=
-  { preservesLimit := fun {F} =>
-      -- Porting note: add these instances to help Lean unify universe levels
-      letI : HasLimit (F ⋙ forget₂ GroupCatMax.{v, u} MonCat.{max v u}) :=
-        (MonCat.hasLimitsOfSize.{v, u}.1 J).1 _
-      letI h1 := GroupCat.forget₂MonPreservesLimitsOfSize.{v, u}
-      letI h2 := MonCat.forgetPreservesLimitsOfSize.{v, u}
-      Limits.compPreservesLimit (K := F)
-        (forget₂ GroupCatMax.{v, u} MonCat.{max v u})
-        (forget MonCat.{max v u}) }
+  This means the underlying type of a limit can be computed as a limit in the category of types.",
+  to_additive_relevant_arg 2]
+noncomputable instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
+    PreservesLimitsOfSize.{w, v} (forget GroupCat.{u})
+  where preservesLimitsOfShape {J _} := { }
 set_option linter.uppercaseLean3 false in
 #align Group.forget_preserves_limits_of_size GroupCat.forgetPreservesLimitsOfSize
 set_option linter.uppercaseLean3 false in
@@ -212,22 +223,25 @@ end GroupCat
 
 namespace CommGroupCat
 
+variable (F : J ⥤ CommGroupCat.{u})
+
 @[to_additive]
-instance commGroupObj (F : J ⥤ CommGroupCatMax.{v, u}) (j) :
-    CommGroup ((F ⋙ forget CommGroupCatMax).obj j) := by
-  change CommGroup (F.obj j)
-  infer_instance
+instance commGroupObj (j) : CommGroup ((F ⋙ forget CommGroupCat).obj j) :=
+  inferInstanceAs <| CommGroup (F.obj j)
 set_option linter.uppercaseLean3 false in
 #align CommGroup.comm_group_obj CommGroupCat.commGroupObj
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.add_comm_group_obj AddCommGroupCat.addCommGroupObj
 
+variable [Small.{u} (Functor.sections (F ⋙ forget CommGroupCat))]
+
 @[to_additive]
-noncomputable instance limitCommGroup (F : J ⥤ CommGroupCat.{max v u}) :
-    CommGroup (Types.limitCone.{v, u} (F ⋙ forget CommGroupCatMax.{v, u})).pt :=
-  @Subgroup.toCommGroup (∀ j, F.obj j) _
-    (GroupCat.sectionsSubgroup.{v, max v u}
-      (F ⋙ forget₂ CommGroupCatMax.{v, u} GroupCatMax.{v, u}))
+noncomputable instance limitCommGroup :
+    CommGroup (Types.Small.limitCone.{v, u} (F ⋙ forget CommGroupCat.{u})).pt :=
+  letI : CommGroup (F ⋙ forget CommGroupCat.{u}).sections :=
+    @Subgroup.toCommGroup (∀ j, F.obj j) _
+      (GroupCat.sectionsSubgroup (F ⋙ forget₂ CommGroupCat.{u} GroupCat.{u}))
+  inferInstanceAs <| CommGroup (Shrink (F ⋙ forget CommGroupCat.{u}).sections)
 set_option linter.uppercaseLean3 false in
 #align CommGroup.limit_comm_group CommGroupCat.limitCommGroup
 set_option linter.uppercaseLean3 false in
@@ -242,20 +256,26 @@ and then reuse the existing limit.
 
   All we need to do is notice that the limit point has an `AddCommGroup` instance available,
   and then reuse the existing limit."]
-noncomputable instance Forget₂.createsLimit (F : J ⥤ CommGroupCatMax.{v, u}) :
-    CreatesLimit F (forget₂ CommGroupCat GroupCatMax.{v, u}) :=
-  letI : ReflectsIsomorphisms (forget₂ CommGroupCatMax.{v, u} GroupCatMax.{v, u}) :=
+noncomputable instance Forget₂.createsLimit :
+    CreatesLimit F (forget₂ CommGroupCat GroupCat.{u}) :=
+  letI : ReflectsIsomorphisms (forget₂ CommGroupCat.{u} GroupCat.{u}) :=
     CategoryTheory.reflectsIsomorphisms_forget₂ _ _
+  letI : Small.{u}
+      (Functor.sections ((F ⋙ forget₂ CommGroupCat GroupCat) ⋙ forget GroupCat)) :=
+    inferInstanceAs <| Small (Functor.sections (F ⋙ forget CommGroupCat))
+  letI : Small.{u}
+      (Functor.sections ((F ⋙ forget₂ _ GroupCat ⋙ forget₂ _ MonCat) ⋙ forget MonCat)) :=
+    inferInstanceAs <| Small (Functor.sections (F ⋙ forget CommGroupCat))
   createsLimitOfReflectsIso fun c' t =>
     { liftedCone :=
-        { pt := CommGroupCat.of (Types.limitCone.{v, u} (F ⋙ forget CommGroupCat)).pt
+        { pt := CommGroupCat.of (Types.Small.limitCone.{v, u} (F ⋙ forget CommGroupCat)).pt
           π :=
             { app := MonCat.limitπMonoidHom
-                (F ⋙ forget₂ CommGroupCat GroupCat.{max v u} ⋙ forget₂ GroupCat MonCat.{max v u})
+                (F ⋙ forget₂ CommGroupCat GroupCat.{u} ⋙ forget₂ GroupCat MonCat.{u})
               naturality := (MonCat.HasLimits.limitCone _).π.naturality } }
       validLift := by apply IsLimit.uniqueUpToIso (GroupCat.limitConeIsLimit _) t
       makesLimit :=
-        IsLimit.ofFaithful (forget₂ _ GroupCat.{max v u} ⋙ forget₂ _ MonCat.{max v u})
+        IsLimit.ofFaithful (forget₂ _ GroupCat.{u} ⋙ forget₂ _ MonCat.{u})
           (by apply MonCat.HasLimits.limitConeIsLimit _) (fun s => _) fun s => rfl }
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget₂.creates_limit CommGroupCat.Forget₂.createsLimit
@@ -268,8 +288,10 @@ set_option linter.uppercaseLean3 false in
 @[to_additive
   "A choice of limit cone for a functor into `AddCommGroupCat`.
   (Generally, you'll just want to use `limit F`.)"]
-noncomputable def limitCone (F : J ⥤ CommGroupCat.{max v u}) : Cone F :=
-  liftLimit (limit.isLimit (F ⋙ forget₂ CommGroupCatMax.{v, u} GroupCatMax.{v, u}))
+noncomputable def limitCone : Cone F :=
+  letI : Small.{u} (Functor.sections ((F ⋙ forget₂ CommGroupCat GroupCat) ⋙ forget GroupCat)) :=
+    inferInstanceAs <| Small (Functor.sections (F ⋙ forget CommGroupCat))
+  liftLimit (limit.isLimit (F ⋙ forget₂ CommGroupCat.{u} GroupCat.{u}))
 set_option linter.uppercaseLean3 false in
 #align CommGroup.limit_cone CommGroupCat.limitCone
 set_option linter.uppercaseLean3 false in
@@ -281,20 +303,30 @@ set_option linter.uppercaseLean3 false in
 @[to_additive
   "The chosen cone is a limit cone.
   (Generally, you'll just want to use `limit.cone F`.)"]
-noncomputable def limitConeIsLimit (F : J ⥤ CommGroupCatMax.{v, u}) :
-    IsLimit (limitCone.{v, u} F) :=
+noncomputable def limitConeIsLimit : IsLimit (limitCone.{v, u} F) :=
   liftedLimitIsLimit _
 set_option linter.uppercaseLean3 false in
 #align CommGroup.limit_cone_is_limit CommGroupCat.limitConeIsLimit
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.limit_cone_is_limit AddCommGroupCat.limitConeIsLimit
 
+/-- If `(F ⋙ forget CommGroupCat).sections` is `u`-small, `F` has a limit. -/
+@[to_additive "If `(F ⋙ forget AddCommGroupCat).sections` is `u`-small, `F` has a limit."]
+instance hasLimit : HasLimit F :=
+  HasLimit.mk {
+    cone := limitCone F
+    isLimit := limitConeIsLimit F
+  }
+
+/-- If `J` is `u`-small, `CommGroupCat.{u}` has limits of shape `J`. -/
+@[to_additive "If `J` is `u`-small, `AddCommGroupCat.{u}` has limits of shape `J`."]
+instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J CommGroupCat.{u} where
+  has_limit _ := inferInstance
+
 /-- The category of commutative groups has all limits. -/
 @[to_additive "The category of additive commutative groups has all limits."]
-instance hasLimitsOfSize : HasLimitsOfSize.{v, v} CommGroupCat.{max v u}
-  where has_limits_of_shape _ _ :=
-  { has_limit := fun F => hasLimit_of_created F
-      (forget₂ CommGroupCatMax.{v, u} GroupCatMax.{v, u}) }
+instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} CommGroupCat.{u}
+  where has_limits_of_shape _ _ := { }
 set_option linter.uppercaseLean3 false in
 #align CommGroup.has_limits_of_size CommGroupCat.hasLimitsOfSize
 set_option linter.uppercaseLean3 false in
@@ -315,10 +347,11 @@ of groups.)
 @[to_additive
   "The forgetful functor from additive commutative groups to groups preserves all limits.
   (That is, the underlying group could have been computed instead as limits in the category
-    of additive groups.)"]
-noncomputable instance forget₂GroupPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCatMax.{v, u} GroupCatMax.{v, u}) where
-  preservesLimitsOfShape {J 𝒥} := { preservesLimit := fun {F} => by infer_instance }
+    of additive groups.)",
+  to_additive_relevant_arg 2]
+noncomputable instance forget₂GroupPreservesLimitsOfSize [UnivLE.{v, u}] :
+    PreservesLimitsOfSize.{w, v} (forget₂ CommGroupCat.{u} GroupCat.{u}) where
+  preservesLimitsOfShape {J 𝒥} := { }
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget₂_Group_preserves_limits_of_size CommGroupCat.forget₂GroupPreservesLimitsOfSize
 set_option linter.uppercaseLean3 false in
@@ -337,32 +370,50 @@ set_option linter.uppercaseLean3 false in
 -/
 @[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
   "An auxiliary declaration to speed up typechecking."]
-noncomputable def forget₂CommMonPreservesLimitsAux (F : J ⥤ CommGroupCatMax.{v, u}) :
-    IsLimit ((forget₂ CommGroupCatMax.{v, u} CommMonCat).mapCone (limitCone.{v, u} F)) :=
-  CommMonCat.limitConeIsLimit.{v, u} (F ⋙ forget₂ CommGroupCatMax.{v, u} CommMonCat)
+noncomputable def forget₂CommMonPreservesLimitsAux :
+    IsLimit ((forget₂ CommGroupCat.{u} CommMonCat.{u}).mapCone (limitCone.{v, u} F)) :=
+  letI : Small.{u} (Functor.sections ((F ⋙ forget₂ _ CommMonCat) ⋙ forget CommMonCat)) :=
+    inferInstanceAs <| Small (Functor.sections (F ⋙ forget CommGroupCat))
+  CommMonCat.limitConeIsLimit.{v, u} (F ⋙ forget₂ CommGroupCat.{u} CommMonCat.{u})
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget₂_CommMon_preserves_limits_aux CommGroupCat.forget₂CommMonPreservesLimitsAux
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.forget₂_AddCommMon_preserves_limits_aux AddCommGroupCat.forget₂AddCommMonPreservesLimitsAux
 
+/-- If `J` is `u`-small, the forgetful functor from `CommGroupCat.{u}` to `CommMonCat.{u}`
+preserves limits of shape `J`. -/
+@[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsOfShape
+  "If `J` is `u`-small, the forgetful functor from `AddCommGroupCat.{u}`
+  to `AddCommMonCat.{u}` preserves limits of shape `J`."]
+noncomputable instance forget₂CommMonPreservesLimitsOfShape [Small.{u} J] :
+    PreservesLimitsOfShape J (forget₂ CommGroupCat.{u} CommMonCat.{u}) where
+  preservesLimit {F} := preservesLimitOfPreservesLimitCone (limitConeIsLimit.{v, u} F)
+      (forget₂CommMonPreservesLimitsAux.{v, u} F)
+
 /-- The forgetful functor from commutative groups to commutative monoids preserves all limits.
 (That is, the underlying commutative monoids could have been computed instead as limits
 in the category of commutative monoids.)
 -/
-@[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimits
+@[to_additive AddCommGroupCat.forget₂AddCommMonPreservesLimitsOfSize
   "The forgetful functor from additive commutative groups to additive commutative monoids
   preserves all limits. (That is, the underlying additive commutative monoids could have been
   computed instead as limits in the category of additive commutative monoids.)"]
-noncomputable instance forget₂CommMonPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCat CommMonCat.{max v u}) where
-  preservesLimitsOfShape :=
-    { preservesLimit := fun {F} =>
-        preservesLimitOfPreservesLimitCone (limitConeIsLimit.{v, u} F)
-          (forget₂CommMonPreservesLimitsAux.{v, u} F) }
+noncomputable instance forget₂CommMonPreservesLimitsOfSize [UnivLE.{v, u}] :
+    PreservesLimitsOfSize.{w, v} (forget₂ CommGroupCat CommMonCat.{u}) where
+  preservesLimitsOfShape := { }
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget₂_CommMon_preserves_limits_of_size CommGroupCat.forget₂CommMonPreservesLimitsOfSize
 set_option linter.uppercaseLean3 false in
-#align AddCommGroup.forget₂_AddCommMon_preserves_limits AddCommGroupCat.forget₂AddCommMonPreservesLimits
+#align AddCommGroup.forget₂_AddCommMon_preserves_limits AddCommGroupCat.forget₂AddCommMonPreservesLimitsOfSize
+
+/-- If `J` is `u`-small, the forgetful functor from `CommGroupCat.{u}` preserves limits of
+shape `J`. -/
+@[to_additive "If `J` is `u`-small, the forgetful functor from `AddCommGroupCat.{u}`\n
+preserves limits of shape `J`."]
+noncomputable instance forgetPreservesLimitsOfShape [Small.{u} J] :
+    PreservesLimitsOfShape J (forget CommGroupCat.{u}) where
+  preservesLimit {F} := preservesLimitOfPreservesLimitCone (limitConeIsLimit F)
+    (Types.Small.limitConeIsLimit (F ⋙ forget _))
 
 /-- The forgetful functor from commutative groups to types preserves all limits. (That is, the
 underlying types could have been computed instead as limits in the category of types.)
@@ -371,22 +422,19 @@ underlying types could have been computed instead as limits in the category of t
   "The forgetful functor from additive commutative groups to types preserves all limits.
   (That is, the underlying types could have been computed instead as limits in the category of
   types.)"]
-noncomputable instance forgetPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget CommGroupCatMax.{v, u}) where
-  preservesLimitsOfShape {J _} :=
-  { preservesLimit := fun {F} =>
-    -- Porting note: add these instance to help Lean unify universe levels
-    letI : HasLimit (F ⋙ forget₂ CommGroupCatMax.{v, u} GroupCat.{max v u}) :=
-      (GroupCat.hasLimitsOfSize.{v, u}.1 J).1 _
-    letI h1 := CommGroupCat.forget₂CommMonPreservesLimitsOfSize.{v, u}
-    letI h2 := GroupCat.forgetPreservesLimitsOfSize.{v, u}
-    Limits.compPreservesLimit (K := F) (forget₂ CommGroupCatMax.{v, u} GroupCat) (forget GroupCat) }
+noncomputable instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
+    PreservesLimitsOfSize.{w, v} (forget CommGroupCat.{u}) where
+  preservesLimitsOfShape {_ _} := { }
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget_preserves_limits_of_size CommGroupCat.forgetPreservesLimitsOfSize
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.forget_preserves_limits AddCommGroupCat.forgetPreservesLimitsOfSize
 
-@[to_additive]
+noncomputable instance _root_.AddCommGroupCat.forgetPreservesLimits :
+    PreservesLimits (forget AddCommGroupCat.{u}) :=
+  AddCommGroupCat.forgetPreservesLimitsOfSize.{u, u}
+
+@[to_additive existing]
 noncomputable instance forgetPreservesLimits : PreservesLimits (forget CommGroupCat.{u}) :=
   CommGroupCat.forgetPreservesLimitsOfSize.{u, u}

70fd9563

chore: classify was tidy porting notes (#10937)

Classifies by adding issue number (#10936) to porting notes claiming anything semantically equivalent to:

"used to be tidy"
"was tidy "

d0946f02

Diff

@@ -413,7 +413,7 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
         dsimp
         simp }
   inv := kernel.lift f (AddSubgroup.subtype f.ker) <| by
-    -- Porting note: used to be `tidy`, but `aesop` can't do it
+    -- Porting note (#10936): used to be `tidy`, but `aesop` can't do it
     refine DFunLike.ext _ _ ?_
     rintro ⟨x, (hx : f _ = 0)⟩
     exact hx

70fd9563

style: reduce spacing variation in "porting note" comments (#10886)

In this pull request, I have systematically eliminated the leading whitespace preceding the colon (:) within all unlabelled or unclassified porting notes. This adjustment facilitates a more efficient review process for the remaining notes by ensuring no entries are overlooked due to formatting inconsistencies.

86b84c52

Diff

@@ -375,7 +375,7 @@ noncomputable instance forgetPreservesLimitsOfSize :
     PreservesLimitsOfSize.{v, v} (forget CommGroupCatMax.{v, u}) where
   preservesLimitsOfShape {J _} :=
   { preservesLimit := fun {F} =>
-    -- Porting note : add these instance to help Lean unify universe levels
+    -- Porting note: add these instance to help Lean unify universe levels
     letI : HasLimit (F ⋙ forget₂ CommGroupCatMax.{v, u} GroupCat.{max v u}) :=
       (GroupCat.hasLimitsOfSize.{v, u}.1 J).1 _
     letI h1 := CommGroupCat.forget₂CommMonPreservesLimitsOfSize.{v, u}
@@ -413,7 +413,7 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
         dsimp
         simp }
   inv := kernel.lift f (AddSubgroup.subtype f.ker) <| by
-    -- porting note : used to be `tidy`, but `aesop` can't do it
+    -- Porting note: used to be `tidy`, but `aesop` can't do it
     refine DFunLike.ext _ _ ?_
     rintro ⟨x, (hx : f _ = 0)⟩
     exact hx
@@ -452,7 +452,7 @@ theorem kernelIsoKer_inv_comp_ι {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.kernel_iso_ker_inv_comp_ι AddCommGroupCat.kernelIsoKer_inv_comp_ι
 
--- Porting note : explicitly add what to be synthesized under `simps!`, because other lemmas
+-- Porting note: explicitly add what to be synthesized under `simps!`, because other lemmas
 -- automatically generated is not in normal form
 /-- The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`,
 agrees with the `subtype` map.

70fd9563

refactor: create folder CategoryTheory/Comma (#10108)

38cd7278

Diff

@@ -5,9 +5,9 @@ Authors: Scott Morrison
 -/
 import Mathlib.Algebra.Category.MonCat.Limits
 import Mathlib.Algebra.Category.GroupCat.Preadditive
-import Mathlib.CategoryTheory.Over
-import Mathlib.GroupTheory.Subgroup.Basic
+import Mathlib.CategoryTheory.Comma.Over
 import Mathlib.CategoryTheory.ConcreteCategory.ReflectsIso
+import Mathlib.GroupTheory.Subgroup.Basic
 
 #align_import algebra.category.Group.limits from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"

70fd9563

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,7 +7,6 @@ import Mathlib.Algebra.Category.MonCat.Limits
 import Mathlib.Algebra.Category.GroupCat.Preadditive
 import Mathlib.CategoryTheory.Over
 import Mathlib.GroupTheory.Subgroup.Basic
-import Mathlib.CategoryTheory.ConcreteCategory.Elementwise
 import Mathlib.CategoryTheory.ConcreteCategory.ReflectsIso
 
 #align_import algebra.category.Group.limits from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"

70fd9563

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

@@ -404,7 +404,7 @@ agrees with the usual group-theoretical kernel.
 def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
     kernel f ≅ AddCommGroupCat.of f.ker where
   hom :=
-    { toFun := fun g => ⟨kernel.ι f g, FunLike.congr_fun (kernel.condition f) g⟩
+    { toFun := fun g => ⟨kernel.ι f g, DFunLike.congr_fun (kernel.condition f) g⟩
       map_zero' := by
         refine Subtype.ext ?_
         simp [(AddSubgroup.coe_zero _).symm]
@@ -415,7 +415,7 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
         simp }
   inv := kernel.lift f (AddSubgroup.subtype f.ker) <| by
     -- porting note : used to be `tidy`, but `aesop` can't do it
-    refine FunLike.ext _ _ ?_
+    refine DFunLike.ext _ _ ?_
     rintro ⟨x, (hx : f _ = 0)⟩
     exact hx
   hom_inv_id := by
@@ -425,7 +425,7 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
     ext x
     dsimp
     generalize_proofs _ h1 h2
-    erw [FunLike.congr_fun (kernel.lift_ι f _ h1) ⟨_, h2⟩]
+    erw [DFunLike.congr_fun (kernel.lift_ι f _ h1) ⟨_, h2⟩]
     rfl
   inv_hom_id := by
     apply AddCommGroupCat.ext
@@ -434,7 +434,7 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
     refine Subtype.ext ?_
     simp only [ZeroHom.coe_mk, Function.comp_apply, id_eq]
     generalize_proofs _ h1 h2
-    erw [FunLike.congr_fun (kernel.lift_ι f _ h1) ⟨_, mem⟩]
+    erw [DFunLike.congr_fun (kernel.lift_ι f _ h1) ⟨_, mem⟩]
     rfl
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.kernel_iso_ker AddCommGroupCat.kernelIsoKer

70fd9563

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

This reverts commit f3695eb2.

ab56fa28

Diff

@@ -465,4 +465,8 @@ def kernelIsoKerOver {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.kernel_iso_ker_over AddCommGroupCat.kernelIsoKerOver
 
+-- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
+attribute [nolint simpNF] AddCommGroupCat.kernelIsoKerOver_inv_left_apply
+  AddCommGroupCat.kernelIsoKerOver_hom_left_apply_coe
+
 end AddCommGroupCat

70fd9563

chore: revert #7703 (#7710)

This reverts commit 26eb2b0a.

f3695eb2

Diff

@@ -465,8 +465,4 @@ def kernelIsoKerOver {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.kernel_iso_ker_over AddCommGroupCat.kernelIsoKerOver
 
--- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
-attribute [nolint simpNF] AddCommGroupCat.kernelIsoKerOver_inv_left_apply
-  AddCommGroupCat.kernelIsoKerOver_hom_left_apply_coe
-
 end AddCommGroupCat

70fd9563

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

@@ -465,4 +465,8 @@ def kernelIsoKerOver {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.kernel_iso_ker_over AddCommGroupCat.kernelIsoKerOver
 
+-- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
+attribute [nolint simpNF] AddCommGroupCat.kernelIsoKerOver_inv_left_apply
+  AddCommGroupCat.kernelIsoKerOver_hom_left_apply_coe
+
 end AddCommGroupCat

70fd9563

feat: structure sheaf of a manifold (#7332)

In https://github.com/leanprover-community/mathlib/pull/19146, we defined StructureGroupoid.LocalInvariantProp.sheaf, the sheaf-of-types of functions f : M → M' (for charted spaces M, M') satisfying some local property in the sense of StructureGroupoid.LocalInvariantProp (for example continuity, differentiability, smoothness).

In this PR, in the case of smoothness, we upgrade this to a sheaf of groups if M' is a Lie group, a sheaf of abelian groups if M' is an abelian Lie group, and a sheaf of rings if M' is a "smooth ring".

Co-authored-by: Adam Topaz <github@adamtopaz.com>

Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

4f086f94

Diff

@@ -368,7 +368,7 @@ set_option linter.uppercaseLean3 false in
 /-- The forgetful functor from commutative groups to types preserves all limits. (That is, the
 underlying types could have been computed instead as limits in the category of types.)
 -/
-@[to_additive AddCommGroupCat.forgetPreservesLimits
+@[to_additive
   "The forgetful functor from additive commutative groups to types preserves all limits.
   (That is, the underlying types could have been computed instead as limits in the category of
   types.)"]
@@ -385,7 +385,11 @@ noncomputable instance forgetPreservesLimitsOfSize :
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget_preserves_limits_of_size CommGroupCat.forgetPreservesLimitsOfSize
 set_option linter.uppercaseLean3 false in
-#align AddCommGroup.forget_preserves_limits AddCommGroupCat.forgetPreservesLimits
+#align AddCommGroup.forget_preserves_limits AddCommGroupCat.forgetPreservesLimitsOfSize
+
+@[to_additive]
+noncomputable instance forgetPreservesLimits : PreservesLimits (forget CommGroupCat.{u}) :=
+  CommGroupCat.forgetPreservesLimitsOfSize.{u, u}
 
 -- Verify we can form limits indexed over smaller categories.
 example (f : ℕ → AddCommGroupCat) : HasProduct f := by infer_instance

70fd9563

style: fix wrapping of where (#7149)

084cfb35

Diff

@@ -127,8 +127,8 @@ set_option linter.uppercaseLean3 false in
 
 /-- The category of groups has all limits. -/
 @[to_additive "The category of additive groups has all limits."]
-instance hasLimitsOfSize : HasLimitsOfSize.{v, v} GroupCatMax.{v, u}
-    where has_limits_of_shape J _ :=
+instance hasLimitsOfSize : HasLimitsOfSize.{v, v} GroupCatMax.{v, u} where
+  has_limits_of_shape J _ :=
     { has_limit :=
         -- Porting note: add this instance to help Lean unify universe levels
         fun F => letI : HasLimit (F ⋙ forget₂ GroupCatMax.{v, u} MonCat.{max v u}) :=
@@ -318,8 +318,8 @@ of groups.)
   (That is, the underlying group could have been computed instead as limits in the category
     of additive groups.)"]
 noncomputable instance forget₂GroupPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCatMax.{v, u} GroupCatMax.{v, u})
-    where preservesLimitsOfShape {J 𝒥} := { preservesLimit := fun {F} => by infer_instance }
+    PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCatMax.{v, u} GroupCatMax.{v, u}) where
+  preservesLimitsOfShape {J 𝒥} := { preservesLimit := fun {F} => by infer_instance }
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget₂_Group_preserves_limits_of_size CommGroupCat.forget₂GroupPreservesLimitsOfSize
 set_option linter.uppercaseLean3 false in

70fd9563

refactor: colimits in ModuleCat (#6925)

This PR refactors the construction of colimits of modules in order to prove that the forgetful functor to abelian groups preserves colimits.

b1caad96

Diff

@@ -29,13 +29,6 @@ noncomputable section
 
 variable {J : Type v} [SmallCategory J]
 
--- Porting note: typemax hack to fix universe complaints
-/-- An alias for `GroupCat.{max u v}`, to deal around unification issues. -/
-@[to_additive (attr := nolint checkUnivs)
-  "An alias for `AddGroupCat.{max u v}`, to deal around unification issues."]
-abbrev GroupCatMax.{u1, u2} := GroupCat.{max u1 u2}
-
-
 namespace GroupCat
 
 @[to_additive]
@@ -218,12 +211,6 @@ set_option linter.uppercaseLean3 false in
 
 end GroupCat
 
--- Porting note: typemax hack to fix universe complaints
-/-- An alias for `CommGroupCat.{max u v}`, to deal around unification issues. -/
-@[to_additive (attr := nolint checkUnivs)
-  "An alias for `AddCommGroupCat.{max u v}`, to deal around unification issues."]
-abbrev CommGroupCatMax.{u1, u2} := CommGroupCat.{max u1 u2}
-
 namespace CommGroupCat
 
 @[to_additive]

70fd9563

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,11 +2,6 @@
 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.limits
-! leanprover-community/mathlib commit 70fd9563a21e7b963887c9360bd29b2393e6225a
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Category.MonCat.Limits
 import Mathlib.Algebra.Category.GroupCat.Preadditive
@@ -15,6 +10,8 @@ import Mathlib.GroupTheory.Subgroup.Basic
 import Mathlib.CategoryTheory.ConcreteCategory.Elementwise
 import Mathlib.CategoryTheory.ConcreteCategory.ReflectsIso
 
+#align_import algebra.category.Group.limits from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
+
 /-!
 # The category of (commutative) (additive) groups has all limits

70fd9563

chore: bump to nightly-2023-07-01 (#5409)

depends on: https://github.com/leanprover/std4/pull/163
depends on: #5584
depends on: #5715
depends on: #5729
depends on: https://github.com/leanprover/std4/pull/173

Co-authored-by: Komyyy <pol_tta@outlook.jp> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com>

906f7221

Diff

@@ -419,7 +419,7 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
     { toFun := fun g => ⟨kernel.ι f g, FunLike.congr_fun (kernel.condition f) g⟩
       map_zero' := by
         refine Subtype.ext ?_
-        simpa using (AddSubgroup.coe_zero _).symm
+        simp [(AddSubgroup.coe_zero _).symm]
       map_add' := fun g g' => by
         refine Subtype.ext ?_
         change _ = _ + _

70fd9563

feat: using UnivLE in constructing limits in Type (#5724)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Apurva <apurvnakade@gmail.com> Co-authored-by: Jon Eugster <eugster.jon@gmail.com> Co-authored-by: Joël Riou <joel.riou@universite-paris-saclay.fr> Co-authored-by: Johan Commelin <johan@commelin.net>

56112d4c

Diff

@@ -67,7 +67,7 @@ set_option linter.uppercaseLean3 false in
 #align AddGroup.sections_add_subgroup AddGroupCat.sectionsAddSubgroup
 
 @[to_additive]
-instance limitGroup (F : J ⥤ GroupCatMax.{v, u}) :
+noncomputable instance limitGroup (F : J ⥤ GroupCatMax.{v, u}) :
     Group (Types.limitCone.{v, u} (F ⋙ forget GroupCat)).pt := by
   change Group (sectionsSubgroup.{v, u} F)
   infer_instance

70fd9563

chore: remove occurrences of semicolon after space (#5713)

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

c795bd35

Diff

@@ -453,7 +453,7 @@ set_option linter.uppercaseLean3 false in
 
 @[simp]
 theorem kernelIsoKer_hom_comp_subtype {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
-    (kernelIsoKer f).hom ≫ AddSubgroup.subtype f.ker = kernel.ι f := by ext ; rfl
+    (kernelIsoKer f).hom ≫ AddSubgroup.subtype f.ker = kernel.ι f := by ext; rfl
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.kernel_iso_ker_hom_comp_subtype AddCommGroupCat.kernelIsoKer_hom_comp_subtype

70fd9563

feat: more consistent use of ext, and updating porting notes. (#5242)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

dbae2f17

Diff

@@ -431,6 +431,8 @@ def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
     rintro ⟨x, (hx : f _ = 0)⟩
     exact hx
   hom_inv_id := by
+    -- Porting note: it would be nice to do the next two steps by a single `ext`,
+    -- but this will require thinking carefully about the relative priorities of `@[ext]` lemmas.
     refine equalizer.hom_ext ?_
     ext x
     dsimp

70fd9563

chore: review of automation in category theory (#4793)

Clean up of automation in the category theory library. Leaving out unnecessary proof steps, or fields done by aesop_cat, and making more use of available autoparameters.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

5b958613

Diff

@@ -471,7 +471,7 @@ agrees with the `subtype` map.
 @[simps! hom_left_apply_coe inv_left_apply]
 def kernelIsoKerOver {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :
     Over.mk (kernel.ι f) ≅ @Over.mk _ _ G (AddCommGroupCat.of f.ker) (AddSubgroup.subtype f.ker) :=
-  Over.isoMk (kernelIsoKer f) <| by simp
+  Over.isoMk (kernelIsoKer f)
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.kernel_iso_ker_over AddCommGroupCat.kernelIsoKerOver

70fd9563

chore: tidy various files (#4304)

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

8214f469

Diff

@@ -24,9 +24,7 @@ the underlying types are just the limits in the category of types.
 -/
 
 
-open CategoryTheory
-
-open CategoryTheory.Limits
+open CategoryTheory CategoryTheory.Limits
 
 universe v u
 
@@ -52,15 +50,12 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddGroup.add_group_obj AddGroupCat.addGroupObj
 
-/-- The flat sections of a functor into `Group` form a subgroup of all sections.
+/-- The flat sections of a functor into `GroupCat` form a subgroup of all sections.
 -/
 @[to_additive
-  "The flat sections of a functor into `AddGroup` form an additive subgroup of all sections."]
+  "The flat sections of a functor into `AddGroupCat` form an additive subgroup of all sections."]
 def sectionsSubgroup (F : J ⥤ GroupCat) : Subgroup (∀ j, F.obj j) :=
-  {
-    MonCat.sectionsSubmonoid
-      (F ⋙ forget₂ GroupCat
-          MonCat) with
+  { MonCat.sectionsSubmonoid (F ⋙ forget₂ GroupCat MonCat) with
     carrier := (F ⋙ forget GroupCat).sections
     inv_mem' := fun {a} ah j j' f => by
       simp only [Functor.comp_map, Pi.inv_apply, MonoidHom.map_inv, inv_inj]
@@ -81,17 +76,17 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddGroup.limit_add_group AddGroupCat.limitAddGroup
 
-/-- We show that the forgetful functor `Group ⥤ Mon` creates limits.
+/-- We show that the forgetful functor `GroupCat ⥤ MonCat` creates limits.
 
-All we need to do is notice that the limit point has a `group` instance available, and then reuse
+All we need to do is notice that the limit point has a `Group` instance available, and then reuse
 the existing limit. -/
-@[to_additive "We show that the forgetful functor `AddGroup ⥤ AddMon` creates limits.
+@[to_additive "We show that the forgetful functor `AddGroupCat ⥤ AddMonCat` creates limits.
 
-All we need to do is notice that the limit point has an `add_group` instance available, and then
+All we need to do is notice that the limit point has an `AddGroup` instance available, and then
 reuse the existing limit."]
 noncomputable instance Forget₂.createsLimit (F : J ⥤ GroupCatMax.{v, u}) :
     CreatesLimit F (forget₂ GroupCatMax.{v, u} MonCatMax.{v, u}) :=
-  -- Porting note: need to add `forget₂ Grp Mon` reflects isomorphism
+  -- Porting note: need to add `forget₂ GrpCat MonCat` reflects isomorphism
   letI : ReflectsIsomorphisms (forget₂ GroupCatMax.{v, u} MonCatMax.{v, u}) :=
     CategoryTheory.reflectsIsomorphisms_forget₂ _ _
   createsLimitOfReflectsIso (K := F) (F := (forget₂ GroupCat.{max v u} MonCat.{max v u}))
@@ -112,10 +107,10 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddGroup.forget₂.creates_limit AddGroupCat.Forget₂.createsLimit
 
-/-- A choice of limit cone for a functor into `Group`.
+/-- A choice of limit cone for a functor into `GroupCat`.
 (Generally, you'll just want to use `limit F`.)
 -/
-@[to_additive "A choice of limit cone for a functor into `Group`.
+@[to_additive "A choice of limit cone for a functor into `GroupCat`.
   (Generally, you'll just want to use `limit F`.)"]
 noncomputable def limitCone (F : J ⥤ GroupCatMax.{v, u}) : Cone F :=
   -- Porting note: add this instance to help Lean unify universe levels
@@ -172,8 +167,8 @@ This means the underlying monoid of a limit can be computed as a limit in the ca
   This means the underlying additive monoid of a limit can be computed as a limit in the category of
   additive monoids."]
 noncomputable instance forget₂MonPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ GroupCatMax.{v, u} MonCat.{max v u})
-    where preservesLimitsOfShape {J _} := { preservesLimit := fun {F} =>
+    PreservesLimitsOfSize.{v, v} (forget₂ GroupCatMax.{v, u} MonCat.{max v u}) where
+  preservesLimitsOfShape {J _} := { preservesLimit := fun {F} =>
       -- Porting note: add this instance to help Lean unify universe levels
       letI : HasLimit (F ⋙ forget₂ GroupCatMax.{v, u} MonCat.{max v u}) :=
         (MonCat.hasLimitsOfSize.{v, u}.1 J).1 _
@@ -255,14 +250,14 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.limit_add_comm_group AddCommGroupCat.limitAddCommGroup
 
-/-- We show that the forgetful functor `CommGroup ⥤ Group` creates limits.
+/-- We show that the forgetful functor `CommGroupCat ⥤ GroupCat` creates limits.
 
-All we need to do is notice that the limit point has a `comm_group` instance available,
+All we need to do is notice that the limit point has a `CommGroup` instance available,
 and then reuse the existing limit.
 -/
-@[to_additive "We show that the forgetful functor `AddCommGroup ⥤ AddGroup` creates limits.
+@[to_additive "We show that the forgetful functor `AddCommGroupCat ⥤ AddGroupCat` creates limits.
 
-  All we need to do is notice that the limit point has an `add_comm_group` instance available,
+  All we need to do is notice that the limit point has an `AddCommGroup` instance available,
   and then reuse the existing limit."]
 noncomputable instance Forget₂.createsLimit (F : J ⥤ CommGroupCatMax.{v, u}) :
     CreatesLimit F (forget₂ CommGroupCat GroupCatMax.{v, u}) :=
@@ -284,11 +279,11 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.forget₂.creates_limit AddCommGroupCat.Forget₂.createsLimit
 
-/-- A choice of limit cone for a functor into `CommGroup`.
+/-- A choice of limit cone for a functor into `CommGroupCat`.
 (Generally, you'll just want to use `limit F`.)
 -/
 @[to_additive
-  "A choice of limit cone for a functor into `CommGroup`.
+  "A choice of limit cone for a functor into `AddCommGroupCat`.
   (Generally, you'll just want to use `limit F`.)"]
 noncomputable def limitCone (F : J ⥤ CommGroupCat.{max v u}) : Cone F :=
   liftLimit (limit.isLimit (F ⋙ forget₂ CommGroupCatMax.{v, u} GroupCatMax.{v, u}))
@@ -302,7 +297,7 @@ set_option linter.uppercaseLean3 false in
 -/
 @[to_additive
   "The chosen cone is a limit cone.
-  (Generally, you'll just wantto use `limit.cone F`.)"]
+  (Generally, you'll just want to use `limit.cone F`.)"]
 noncomputable def limitConeIsLimit (F : J ⥤ CommGroupCatMax.{v, u}) :
     IsLimit (limitCone.{v, u} F) :=
   liftedLimitIsLimit _
@@ -376,10 +371,9 @@ in the category of commutative monoids.)
   preserves all limits. (That is, the underlying additive commutative monoids could have been
   computed instead as limits in the category of additive commutative monoids.)"]
 noncomputable instance forget₂CommMonPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCat CommMonCat.{max v u})
-    where preservesLimitsOfShape :=
-    {
-      preservesLimit := fun {F} =>
+    PreservesLimitsOfSize.{v, v} (forget₂ CommGroupCat CommMonCat.{max v u}) where
+  preservesLimitsOfShape :=
+    { preservesLimit := fun {F} =>
         preservesLimitOfPreservesLimitCone (limitConeIsLimit.{v, u} F)
           (forget₂CommMonPreservesLimitsAux.{v, u} F) }
 set_option linter.uppercaseLean3 false in
@@ -395,8 +389,8 @@ underlying types could have been computed instead as limits in the category of t
   (That is, the underlying types could have been computed instead as limits in the category of
   types.)"]
 noncomputable instance forgetPreservesLimitsOfSize :
-    PreservesLimitsOfSize.{v, v} (forget CommGroupCatMax.{v, u})
-  where preservesLimitsOfShape {J _} :=
+    PreservesLimitsOfSize.{v, v} (forget CommGroupCatMax.{v, u}) where
+  preservesLimitsOfShape {J _} :=
   { preservesLimit := fun {F} =>
     -- Porting note : add these instance to help Lean unify universe levels
     letI : HasLimit (F ⋙ forget₂ CommGroupCatMax.{v, u} GroupCat.{max v u}) :=
@@ -416,7 +410,7 @@ end CommGroupCat
 
 namespace AddCommGroupCat
 
-/-- The categorical kernel of a morphism in `AddCommGroup`
+/-- The categorical kernel of a morphism in `AddCommGroupCat`
 agrees with the usual group-theoretical kernel.
 -/
 def kernelIsoKer {G H : AddCommGroupCat.{u}} (f : G ⟶ H) :

70fd9563

feat: port Algebra.Category.Group.Limits (#4148)

a85cea98

`algebra.category.Group.limits` ⟷ `Mathlib.Algebra.Category.GroupCat.Limits`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 4 + 347

algebra.category.Group.limits ⟷ Mathlib.Algebra.Category.GroupCat.Limits

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 4 + 347

`algebra.category.Group.limits` ⟷ `Mathlib.Algebra.Category.GroupCat.Limits`