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

524793de

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

cb3ceec8

bump to nightly-2024-04-14-09

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

f736ea6b

Diff

@@ -433,7 +433,8 @@ end CategoryTheory.Aut
 
 #print GroupCat.forget_reflects_isos /-
 @[to_additive]
-instance GroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget GroupCat.{u})
+instance GroupCat.forget_reflects_isos :
+    CategoryTheory.Functor.ReflectsIsomorphisms (forget GroupCat.{u})
     where reflects X Y f _ := by
     skip
     let i := as_iso ((forget GroupCat).map f)
@@ -445,7 +446,8 @@ instance GroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget GroupCat.{
 
 #print CommGroupCat.forget_reflects_isos /-
 @[to_additive]
-instance CommGroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget CommGroupCat.{u})
+instance CommGroupCat.forget_reflects_isos :
+    CategoryTheory.Functor.ReflectsIsomorphisms (forget CommGroupCat.{u})
     where reflects X Y f _ := by
     skip
     let i := as_iso ((forget CommGroupCat).map f)

cb3ceec8

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2018 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Algebra.Category.Mon.Basic
+import Algebra.Category.MonCat.Basic
 import CategoryTheory.Endomorphism
 
 #align_import algebra.category.Group.basic from "leanprover-community/mathlib"@"cb3ceec8485239a61ed51d944cb9a95b68c6bafc"

cb3ceec8

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2018 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
-import Mathbin.Algebra.Category.Mon.Basic
-import Mathbin.CategoryTheory.Endomorphism
+import Algebra.Category.Mon.Basic
+import CategoryTheory.Endomorphism
 
 #align_import algebra.category.Group.basic from "leanprover-community/mathlib"@"cb3ceec8485239a61ed51d944cb9a95b68c6bafc"

cb3ceec8

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module algebra.category.Group.basic
-! leanprover-community/mathlib commit cb3ceec8485239a61ed51d944cb9a95b68c6bafc
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Category.Mon.Basic
 import Mathbin.CategoryTheory.Endomorphism
 
+#align_import algebra.category.Group.basic from "leanprover-community/mathlib"@"cb3ceec8485239a61ed51d944cb9a95b68c6bafc"
+
 /-!
 # Category instances for group, add_group, comm_group, and add_comm_group.

cb3ceec8

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -80,11 +80,13 @@ def ofHom {X Y : Type u} [Group X] [Group Y] (f : X →* Y) : of X ⟶ of Y :=
 /-- Typecheck a `add_monoid_hom` as a morphism in `AddGroup`. -/
 add_decl_doc AddGroupCat.ofHom
 
+#print GroupCat.ofHom_apply /-
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) : ofHom f x = f x :=
   rfl
 #align Group.of_hom_apply GroupCat.ofHom_apply
 #align AddGroup.of_hom_apply AddGroupCat.ofHom_apply
+-/
 
 @[to_additive]
 instance (G : GroupCat) : Group G :=
@@ -110,22 +112,28 @@ instance ofUnique (G : Type _) [Group G] [i : Unique G] : Unique (GroupCat.of G)
 #align AddGroup.of_unique AddGroupCat.ofUnique
 -/
 
+#print GroupCat.one_apply /-
 @[simp, to_additive]
 theorem one_apply (G H : GroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
   rfl
 #align Group.one_apply GroupCat.one_apply
 #align AddGroup.zero_apply AddGroupCat.zero_apply
+-/
 
+#print GroupCat.ext /-
 @[ext, to_additive]
 theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ := by ext1; apply w
 #align Group.ext GroupCat.ext
 #align AddGroup.ext AddGroupCat.ext
+-/
 
+#print GroupCat.hasForgetToMonCat /-
 @[to_additive has_forget_to_AddMon]
 instance hasForgetToMonCat : HasForget₂ GroupCat MonCat :=
   BundledHom.forget₂ _ _
 #align Group.has_forget_to_Mon GroupCat.hasForgetToMonCat
 #align AddGroup.has_forget_to_AddMon AddGroupCat.hasForgetToAddMonCat
+-/
 
 @[to_additive]
 instance : Coe GroupCat.{u} MonCat.{u} where coe := (forget₂ GroupCat MonCat).obj
@@ -189,12 +197,14 @@ def ofHom {X Y : Type u} [CommGroup X] [CommGroup Y] (f : X →* Y) : of X ⟶ o
 /-- Typecheck a `add_monoid_hom` as a morphism in `AddCommGroup`. -/
 add_decl_doc AddCommGroupCat.ofHom
 
+#print CommGroupCat.ofHom_apply /-
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
     ofHom f x = f x :=
   rfl
 #align CommGroup.of_hom_apply CommGroupCat.ofHom_apply
 #align AddCommGroup.of_hom_apply AddCommGroupCat.ofHom_apply
+-/
 
 #print CommGroupCat.commGroupInstance /-
 @[to_additive]
@@ -224,32 +234,40 @@ instance ofUnique (G : Type _) [CommGroup G] [i : Unique G] : Unique (CommGroupC
 #align AddCommGroup.of_unique AddCommGroupCat.ofUnique
 -/
 
+#print CommGroupCat.one_apply /-
 @[simp, to_additive]
 theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
   rfl
 #align CommGroup.one_apply CommGroupCat.one_apply
 #align AddCommGroup.zero_apply AddCommGroupCat.zero_apply
+-/
 
+#print CommGroupCat.ext /-
 @[ext, to_additive]
 theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ := by ext1;
   apply w
 #align CommGroup.ext CommGroupCat.ext
 #align AddCommGroup.ext AddCommGroupCat.ext
+-/
 
+#print CommGroupCat.hasForgetToGroup /-
 @[to_additive has_forget_to_AddGroup]
 instance hasForgetToGroup : HasForget₂ CommGroupCat GroupCat :=
   BundledHom.forget₂ _ _
 #align CommGroup.has_forget_to_Group CommGroupCat.hasForgetToGroup
 #align AddCommGroup.has_forget_to_AddGroup AddCommGroupCat.hasForgetToAddGroup
+-/
 
 @[to_additive]
 instance : Coe CommGroupCat.{u} GroupCat.{u} where coe := (forget₂ CommGroupCat GroupCat).obj
 
+#print CommGroupCat.hasForgetToCommMonCat /-
 @[to_additive has_forget_to_AddCommMon]
 instance hasForgetToCommMonCat : HasForget₂ CommGroupCat CommMonCat :=
   InducedCategory.hasForget₂ fun G : CommGroupCat => CommMonCat.of G
 #align CommGroup.has_forget_to_CommMon CommGroupCat.hasForgetToCommMonCat
 #align AddCommGroup.has_forget_to_AddCommMon AddCommGroupCat.hasForgetToAddCommMonCat
+-/
 
 @[to_additive]
 instance : Coe CommGroupCat.{u} CommMonCat.{u} where coe := (forget₂ CommGroupCat CommMonCat).obj
@@ -265,6 +283,7 @@ example {R S : CommGroupCat} (i : R ⟶ S) (r : R) (h : r = 1) : i r = 1 := by s
 
 namespace AddCommGroupCat
 
+#print AddCommGroupCat.asHom /-
 -- Note that because `ℤ : Type 0`, this forces `G : AddCommGroup.{0}`,
 -- so we write this explicitly to be clear.
 -- TODO generalize this, requiring a `ulift_instances.lean` file
@@ -273,22 +292,30 @@ namespace AddCommGroupCat
 def asHom {G : AddCommGroupCat.{0}} (g : G) : AddCommGroupCat.of ℤ ⟶ G :=
   zmultiplesHom G g
 #align AddCommGroup.as_hom AddCommGroupCat.asHom
+-/
 
+#print AddCommGroupCat.asHom_apply /-
 @[simp]
 theorem asHom_apply {G : AddCommGroupCat.{0}} (g : G) (i : ℤ) : (asHom g) i = i • g :=
   rfl
 #align AddCommGroup.as_hom_apply AddCommGroupCat.asHom_apply
+-/
 
+#print AddCommGroupCat.asHom_injective /-
 theorem asHom_injective {G : AddCommGroupCat.{0}} : Function.Injective (@asHom G) := fun h k w => by
   convert congr_arg (fun k : AddCommGroupCat.of ℤ ⟶ G => (k : ℤ → G) (1 : ℤ)) w <;> simp
 #align AddCommGroup.as_hom_injective AddCommGroupCat.asHom_injective
+-/
 
+#print AddCommGroupCat.int_hom_ext /-
 @[ext]
 theorem int_hom_ext {G : AddCommGroupCat.{0}} (f g : AddCommGroupCat.of ℤ ⟶ G)
     (w : f (1 : ℤ) = g (1 : ℤ)) : f = g :=
   AddMonoidHom.ext_int w
 #align AddCommGroup.int_hom_ext AddCommGroupCat.int_hom_ext
+-/
 
+#print AddCommGroupCat.injective_of_mono /-
 -- TODO: this argument should be generalised to the situation where
 -- the forgetful functor is representable.
 theorem injective_of_mono {G H : AddCommGroupCat.{0}} (f : G ⟶ H) [Mono f] : Function.Injective f :=
@@ -300,9 +327,11 @@ theorem injective_of_mono {G H : AddCommGroupCat.{0}} (f : G ⟶ H) [Mono f] : F
   have t1 : as_hom g₁ = as_hom g₂ := (cancel_mono _).1 t0
   apply as_hom_injective t1
 #align AddCommGroup.injective_of_mono AddCommGroupCat.injective_of_mono
+-/
 
 end AddCommGroupCat
 
+#print MulEquiv.toGroupCatIso /-
 /-- Build an isomorphism in the category `Group` from a `mul_equiv` between `group`s. -/
 @[to_additive AddEquiv.toAddGroupCatIso, simps]
 def MulEquiv.toGroupCatIso {X Y : GroupCat} (e : X ≃* Y) : X ≅ Y
@@ -311,10 +340,12 @@ def MulEquiv.toGroupCatIso {X Y : GroupCat} (e : X ≃* Y) : X ≅ Y
   inv := e.symm.toMonoidHom
 #align mul_equiv.to_Group_iso MulEquiv.toGroupCatIso
 #align add_equiv.to_AddGroup_iso AddEquiv.toAddGroupCatIso
+-/
 
 /-- Build an isomorphism in the category `AddGroup` from an `add_equiv` between `add_group`s. -/
 add_decl_doc AddEquiv.toAddGroupCatIso
 
+#print MulEquiv.toCommGroupCatIso /-
 /-- Build an isomorphism in the category `CommGroup` from a `mul_equiv` between `comm_group`s. -/
 @[to_additive AddEquiv.toAddCommGroupCatIso, simps]
 def MulEquiv.toCommGroupCatIso {X Y : CommGroupCat} (e : X ≃* Y) : X ≅ Y
@@ -323,6 +354,7 @@ def MulEquiv.toCommGroupCatIso {X Y : CommGroupCat} (e : X ≃* Y) : X ≅ Y
   inv := e.symm.toMonoidHom
 #align mul_equiv.to_CommGroup_iso MulEquiv.toCommGroupCatIso
 #align add_equiv.to_AddCommGroup_iso AddEquiv.toAddCommGroupCatIso
+-/
 
 /-- Build an isomorphism in the category `AddCommGroup` from a `add_equiv` between
 `add_comm_group`s. -/
@@ -330,6 +362,7 @@ add_decl_doc AddEquiv.toAddCommGroupCatIso
 
 namespace CategoryTheory.Iso
 
+#print CategoryTheory.Iso.groupIsoToMulEquiv /-
 /-- Build a `mul_equiv` from an isomorphism in the category `Group`. -/
 @[to_additive AddGroup_iso_to_add_equiv
       "Build an `add_equiv` from an isomorphism in the category\n`AddGroup`.",
@@ -338,7 +371,9 @@ def groupIsoToMulEquiv {X Y : GroupCat} (i : X ≅ Y) : X ≃* Y :=
   i.Hom.toMulEquiv i.inv i.hom_inv_id i.inv_hom_id
 #align category_theory.iso.Group_iso_to_mul_equiv CategoryTheory.Iso.groupIsoToMulEquiv
 #align category_theory.iso.AddGroup_iso_to_add_equiv CategoryTheory.Iso.addGroupIsoToAddEquiv
+-/
 
+#print CategoryTheory.Iso.commGroupIsoToMulEquiv /-
 /-- Build a `mul_equiv` from an isomorphism in the category `CommGroup`. -/
 @[to_additive AddCommGroup_iso_to_add_equiv
       "Build an `add_equiv` from an isomorphism\nin the category `AddCommGroup`.",
@@ -347,9 +382,11 @@ def commGroupIsoToMulEquiv {X Y : CommGroupCat} (i : X ≅ Y) : X ≃* Y :=
   i.Hom.toMulEquiv i.inv i.hom_inv_id i.inv_hom_id
 #align category_theory.iso.CommGroup_iso_to_mul_equiv CategoryTheory.Iso.commGroupIsoToMulEquiv
 #align category_theory.iso.AddCommGroup_iso_to_add_equiv CategoryTheory.Iso.addCommGroupIsoToAddEquiv
+-/
 
 end CategoryTheory.Iso
 
+#print mulEquivIsoGroupIso /-
 /-- multiplicative equivalences between `group`s are the same as (isomorphic to) isomorphisms
 in `Group` -/
 @[to_additive addEquivIsoAddGroupIso
@@ -360,7 +397,9 @@ def mulEquivIsoGroupIso {X Y : GroupCat.{u}} : X ≃* Y ≅ X ≅ Y
   inv i := i.groupIsoToMulEquiv
 #align mul_equiv_iso_Group_iso mulEquivIsoGroupIso
 #align add_equiv_iso_AddGroup_iso addEquivIsoAddGroupIso
+-/
 
+#print mulEquivIsoCommGroupIso /-
 /-- multiplicative equivalences between `comm_group`s are the same as (isomorphic to) isomorphisms
 in `CommGroup` -/
 @[to_additive addEquivIsoAddCommGroupIso
@@ -371,9 +410,11 @@ def mulEquivIsoCommGroupIso {X Y : CommGroupCat.{u}} : X ≃* Y ≅ X ≅ Y
   inv i := i.commGroupIsoToMulEquiv
 #align mul_equiv_iso_CommGroup_iso mulEquivIsoCommGroupIso
 #align add_equiv_iso_AddCommGroup_iso addEquivIsoAddCommGroupIso
+-/
 
 namespace CategoryTheory.Aut
 
+#print CategoryTheory.Aut.isoPerm /-
 /-- The (bundled) group of automorphisms of a type is isomorphic to the (bundled) group
 of permutations. -/
 def isoPerm {α : Type u} : GroupCat.of (Aut α) ≅ GroupCat.of (Equiv.Perm α)
@@ -381,12 +422,15 @@ def isoPerm {α : Type u} : GroupCat.of (Aut α) ≅ GroupCat.of (Equiv.Perm α)
   Hom := ⟨fun g => g.toEquiv, by tidy, by tidy⟩
   inv := ⟨fun g => g.toIso, by tidy, by tidy⟩
 #align category_theory.Aut.iso_perm CategoryTheory.Aut.isoPerm
+-/
 
+#print CategoryTheory.Aut.mulEquivPerm /-
 /-- The (unbundled) group of automorphisms of a type is `mul_equiv` to the (unbundled) group
 of permutations. -/
 def mulEquivPerm {α : Type u} : Aut α ≃* Equiv.Perm α :=
   isoPerm.groupIsoToMulEquiv
 #align category_theory.Aut.mul_equiv_perm CategoryTheory.Aut.mulEquivPerm
+-/
 
 end CategoryTheory.Aut

cb3ceec8

bump to nightly-2023-06-11-17

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

e85a8bfe

Diff

@@ -121,13 +121,11 @@ theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x)
 #align Group.ext GroupCat.ext
 #align AddGroup.ext AddGroupCat.ext
 
-#print GroupCat.hasForgetToMonCat /-
 @[to_additive has_forget_to_AddMon]
 instance hasForgetToMonCat : HasForget₂ GroupCat MonCat :=
   BundledHom.forget₂ _ _
 #align Group.has_forget_to_Mon GroupCat.hasForgetToMonCat
 #align AddGroup.has_forget_to_AddMon AddGroupCat.hasForgetToAddMonCat
--/
 
 @[to_additive]
 instance : Coe GroupCat.{u} MonCat.{u} where coe := (forget₂ GroupCat MonCat).obj
@@ -238,24 +236,20 @@ theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂
 #align CommGroup.ext CommGroupCat.ext
 #align AddCommGroup.ext AddCommGroupCat.ext
 
-#print CommGroupCat.hasForgetToGroup /-
 @[to_additive has_forget_to_AddGroup]
 instance hasForgetToGroup : HasForget₂ CommGroupCat GroupCat :=
   BundledHom.forget₂ _ _
 #align CommGroup.has_forget_to_Group CommGroupCat.hasForgetToGroup
 #align AddCommGroup.has_forget_to_AddGroup AddCommGroupCat.hasForgetToAddGroup
--/
 
 @[to_additive]
 instance : Coe CommGroupCat.{u} GroupCat.{u} where coe := (forget₂ CommGroupCat GroupCat).obj
 
-#print CommGroupCat.hasForgetToCommMonCat /-
 @[to_additive has_forget_to_AddCommMon]
 instance hasForgetToCommMonCat : HasForget₂ CommGroupCat CommMonCat :=
   InducedCategory.hasForget₂ fun G : CommGroupCat => CommMonCat.of G
 #align CommGroup.has_forget_to_CommMon CommGroupCat.hasForgetToCommMonCat
 #align AddCommGroup.has_forget_to_AddCommMon AddCommGroupCat.hasForgetToAddCommMonCat
--/
 
 @[to_additive]
 instance : Coe CommGroupCat.{u} CommMonCat.{u} where coe := (forget₂ CommGroupCat CommMonCat).obj

cb3ceec8

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -80,9 +80,6 @@ def ofHom {X Y : Type u} [Group X] [Group Y] (f : X →* Y) : of X ⟶ of Y :=
 /-- Typecheck a `add_monoid_hom` as a morphism in `AddGroup`. -/
 add_decl_doc AddGroupCat.ofHom
 
-/- warning: Group.of_hom_apply -> GroupCat.ofHom_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align Group.of_hom_apply GroupCat.ofHom_applyₓ'. -/
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) : ofHom f x = f x :=
   rfl
@@ -113,18 +110,12 @@ instance ofUnique (G : Type _) [Group G] [i : Unique G] : Unique (GroupCat.of G)
 #align AddGroup.of_unique AddGroupCat.ofUnique
 -/
 
-/- warning: Group.one_apply -> GroupCat.one_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align Group.one_apply GroupCat.one_applyₓ'. -/
 @[simp, to_additive]
 theorem one_apply (G H : GroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
   rfl
 #align Group.one_apply GroupCat.one_apply
 #align AddGroup.zero_apply AddGroupCat.zero_apply
 
-/- warning: Group.ext -> GroupCat.ext is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align Group.ext GroupCat.extₓ'. -/
 @[ext, to_additive]
 theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ := by ext1; apply w
 #align Group.ext GroupCat.ext
@@ -200,9 +191,6 @@ def ofHom {X Y : Type u} [CommGroup X] [CommGroup Y] (f : X →* Y) : of X ⟶ o
 /-- Typecheck a `add_monoid_hom` as a morphism in `AddCommGroup`. -/
 add_decl_doc AddCommGroupCat.ofHom
 
-/- warning: CommGroup.of_hom_apply -> CommGroupCat.ofHom_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align CommGroup.of_hom_apply CommGroupCat.ofHom_applyₓ'. -/
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
     ofHom f x = f x :=
@@ -238,18 +226,12 @@ instance ofUnique (G : Type _) [CommGroup G] [i : Unique G] : Unique (CommGroupC
 #align AddCommGroup.of_unique AddCommGroupCat.ofUnique
 -/
 
-/- warning: CommGroup.one_apply -> CommGroupCat.one_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align CommGroup.one_apply CommGroupCat.one_applyₓ'. -/
 @[simp, to_additive]
 theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
   rfl
 #align CommGroup.one_apply CommGroupCat.one_apply
 #align AddCommGroup.zero_apply AddCommGroupCat.zero_apply
 
-/- warning: CommGroup.ext -> CommGroupCat.ext is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align CommGroup.ext CommGroupCat.extₓ'. -/
 @[ext, to_additive]
 theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ := by ext1;
   apply w
@@ -289,12 +271,6 @@ example {R S : CommGroupCat} (i : R ⟶ S) (r : R) (h : r = 1) : i r = 1 := by s
 
 namespace AddCommGroupCat
 
-/- warning: AddCommGroup.as_hom -> AddCommGroupCat.asHom is a dubious translation:
-lean 3 declaration is
-  forall {G : AddCommGroupCat.{0}}, (coeSort.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.hasCoeToSort.{0} G) -> (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G)
-but is expected to have type
-  forall {G : AddCommGroupCat.{0}}, (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) -> (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G)
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom AddCommGroupCat.asHomₓ'. -/
 -- Note that because `ℤ : Type 0`, this forces `G : AddCommGroup.{0}`,
 -- so we write this explicitly to be clear.
 -- TODO generalize this, requiring a `ulift_instances.lean` file
@@ -304,36 +280,21 @@ def asHom {G : AddCommGroupCat.{0}} (g : G) : AddCommGroupCat.of ℤ ⟶ G :=
   zmultiplesHom G g
 #align AddCommGroup.as_hom AddCommGroupCat.asHom
 
-/- warning: AddCommGroup.as_hom_apply -> AddCommGroupCat.asHom_apply is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom_apply AddCommGroupCat.asHom_applyₓ'. -/
 @[simp]
 theorem asHom_apply {G : AddCommGroupCat.{0}} (g : G) (i : ℤ) : (asHom g) i = i • g :=
   rfl
 #align AddCommGroup.as_hom_apply AddCommGroupCat.asHom_apply
 
-/- warning: AddCommGroup.as_hom_injective -> AddCommGroupCat.asHom_injective is a dubious translation:
-lean 3 declaration is
-  forall {G : AddCommGroupCat.{0}}, Function.Injective.{1, 1} (coeSort.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.hasCoeToSort.{0} G) (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (AddCommGroupCat.asHom G)
-but is expected to have type
-  forall {G : AddCommGroupCat.{0}}, Function.Injective.{1, 1} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (AddCommGroupCat.asHom G)
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom_injective AddCommGroupCat.asHom_injectiveₓ'. -/
 theorem asHom_injective {G : AddCommGroupCat.{0}} : Function.Injective (@asHom G) := fun h k w => by
   convert congr_arg (fun k : AddCommGroupCat.of ℤ ⟶ G => (k : ℤ → G) (1 : ℤ)) w <;> simp
 #align AddCommGroup.as_hom_injective AddCommGroupCat.asHom_injective
 
-/- warning: AddCommGroup.int_hom_ext -> AddCommGroupCat.int_hom_ext is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.int_hom_ext AddCommGroupCat.int_hom_extₓ'. -/
 @[ext]
 theorem int_hom_ext {G : AddCommGroupCat.{0}} (f g : AddCommGroupCat.of ℤ ⟶ G)
     (w : f (1 : ℤ) = g (1 : ℤ)) : f = g :=
   AddMonoidHom.ext_int w
 #align AddCommGroup.int_hom_ext AddCommGroupCat.int_hom_ext
 
-/- warning: AddCommGroup.injective_of_mono -> AddCommGroupCat.injective_of_mono is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align AddCommGroup.injective_of_mono AddCommGroupCat.injective_of_monoₓ'. -/
 -- TODO: this argument should be generalised to the situation where
 -- the forgetful functor is representable.
 theorem injective_of_mono {G H : AddCommGroupCat.{0}} (f : G ⟶ H) [Mono f] : Function.Injective f :=
@@ -348,12 +309,6 @@ theorem injective_of_mono {G H : AddCommGroupCat.{0}} (f : G ⟶ H) [Mono f] : F
 
 end AddCommGroupCat
 
-/- warning: mul_equiv.to_Group_iso -> MulEquiv.toGroupCatIso is a dubious translation:
-lean 3 declaration is
-  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (GroupCat.group.{u1} X))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (GroupCat.group.{u1} Y)))))) -> (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y)
-but is expected to have type
-  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (GroupCat.instGroupα.{u1} X))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (GroupCat.instGroupα.{u1} Y)))))) -> (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1} X Y)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.to_Group_iso MulEquiv.toGroupCatIsoₓ'. -/
 /-- Build an isomorphism in the category `Group` from a `mul_equiv` between `group`s. -/
 @[to_additive AddEquiv.toAddGroupCatIso, simps]
 def MulEquiv.toGroupCatIso {X Y : GroupCat} (e : X ≃* Y) : X ≅ Y
@@ -366,12 +321,6 @@ def MulEquiv.toGroupCatIso {X Y : GroupCat} (e : X ≃* Y) : X ≅ Y
 /-- Build an isomorphism in the category `AddGroup` from an `add_equiv` between `add_group`s. -/
 add_decl_doc AddEquiv.toAddGroupCatIso
 
-/- warning: mul_equiv.to_CommGroup_iso -> MulEquiv.toCommGroupCatIso is a dubious translation:
-lean 3 declaration is
-  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) -> (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y)
-but is expected to have type
-  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) -> (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1} X Y)
-Case conversion may be inaccurate. Consider using '#align mul_equiv.to_CommGroup_iso MulEquiv.toCommGroupCatIsoₓ'. -/
 /-- Build an isomorphism in the category `CommGroup` from a `mul_equiv` between `comm_group`s. -/
 @[to_additive AddEquiv.toAddCommGroupCatIso, simps]
 def MulEquiv.toCommGroupCatIso {X Y : CommGroupCat} (e : X ≃* Y) : X ≅ Y
@@ -387,12 +336,6 @@ add_decl_doc AddEquiv.toAddCommGroupCatIso
 
 namespace CategoryTheory.Iso
 
-/- warning: category_theory.iso.Group_iso_to_mul_equiv -> CategoryTheory.Iso.groupIsoToMulEquiv is a dubious translation:
-lean 3 declaration is
-  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (GroupCat.group.{u1} X))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (GroupCat.group.{u1} Y))))))
-but is expected to have type
-  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (GroupCat.instGroupα.{u1} X))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (GroupCat.instGroupα.{u1} Y))))))
-Case conversion may be inaccurate. Consider using '#align category_theory.iso.Group_iso_to_mul_equiv CategoryTheory.Iso.groupIsoToMulEquivₓ'. -/
 /-- Build a `mul_equiv` from an isomorphism in the category `Group`. -/
 @[to_additive AddGroup_iso_to_add_equiv
       "Build an `add_equiv` from an isomorphism in the category\n`AddGroup`.",
@@ -402,12 +345,6 @@ def groupIsoToMulEquiv {X Y : GroupCat} (i : X ≅ Y) : X ≃* Y :=
 #align category_theory.iso.Group_iso_to_mul_equiv CategoryTheory.Iso.groupIsoToMulEquiv
 #align category_theory.iso.AddGroup_iso_to_add_equiv CategoryTheory.Iso.addGroupIsoToAddEquiv
 
-/- warning: category_theory.iso.CommGroup_iso_to_mul_equiv -> CategoryTheory.Iso.commGroupIsoToMulEquiv is a dubious translation:
-lean 3 declaration is
-  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y)))))))
-but is expected to have type
-  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y)))))))
-Case conversion may be inaccurate. Consider using '#align category_theory.iso.CommGroup_iso_to_mul_equiv CategoryTheory.Iso.commGroupIsoToMulEquivₓ'. -/
 /-- Build a `mul_equiv` from an isomorphism in the category `CommGroup`. -/
 @[to_additive AddCommGroup_iso_to_add_equiv
       "Build an `add_equiv` from an isomorphism\nin the category `AddCommGroup`.",
@@ -419,12 +356,6 @@ def commGroupIsoToMulEquiv {X Y : CommGroupCat} (i : X ≅ Y) : X ≃* Y :=
 
 end CategoryTheory.Iso
 
-/- warning: mul_equiv_iso_Group_iso -> mulEquivIsoGroupIso is a dubious translation:
-lean 3 declaration is
-  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (GroupCat.group.{u1} X))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (GroupCat.group.{u1} Y)))))) (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y)
-but is expected to have type
-  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (GroupCat.instGroupα.{u1} X))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (GroupCat.instGroupα.{u1} Y)))))) (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1} X Y)
-Case conversion may be inaccurate. Consider using '#align mul_equiv_iso_Group_iso mulEquivIsoGroupIsoₓ'. -/
 /-- multiplicative equivalences between `group`s are the same as (isomorphic to) isomorphisms
 in `Group` -/
 @[to_additive addEquivIsoAddGroupIso
@@ -436,12 +367,6 @@ def mulEquivIsoGroupIso {X Y : GroupCat.{u}} : X ≃* Y ≅ X ≅ Y
 #align mul_equiv_iso_Group_iso mulEquivIsoGroupIso
 #align add_equiv_iso_AddGroup_iso addEquivIsoAddGroupIso
 
-/- warning: mul_equiv_iso_CommGroup_iso -> mulEquivIsoCommGroupIso is a dubious translation:
-lean 3 declaration is
-  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y)
-but is expected to have type
-  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1} X Y)
-Case conversion may be inaccurate. Consider using '#align mul_equiv_iso_CommGroup_iso mulEquivIsoCommGroupIsoₓ'. -/
 /-- multiplicative equivalences between `comm_group`s are the same as (isomorphic to) isomorphisms
 in `CommGroup` -/
 @[to_additive addEquivIsoAddCommGroupIso
@@ -455,12 +380,6 @@ def mulEquivIsoCommGroupIso {X Y : CommGroupCat.{u}} : X ≃* Y ≅ X ≅ Y
 
 namespace CategoryTheory.Aut
 
-/- warning: category_theory.Aut.iso_perm -> CategoryTheory.Aut.isoPerm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α)) (GroupCat.of.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}}, CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.instGroupAut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α)) (GroupCat.of.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))
-Case conversion may be inaccurate. Consider using '#align category_theory.Aut.iso_perm CategoryTheory.Aut.isoPermₓ'. -/
 /-- The (bundled) group of automorphisms of a type is isomorphic to the (bundled) group
 of permutations. -/
 def isoPerm {α : Type u} : GroupCat.of (Aut α) ≅ GroupCat.of (Equiv.Perm α)
@@ -469,12 +388,6 @@ def isoPerm {α : Type u} : GroupCat.of (Aut α) ≅ GroupCat.of (Equiv.Perm α)
   inv := ⟨fun g => g.toIso, by tidy, by tidy⟩
 #align category_theory.Aut.iso_perm CategoryTheory.Aut.isoPerm
 
-/- warning: category_theory.Aut.mul_equiv_perm -> CategoryTheory.Aut.mulEquivPerm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, MulEquiv.{u1, u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))) (GroupCat.group.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))))))) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))
-but is expected to have type
-  forall {α : Type.{u1}}, MulEquiv.{u1, u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (Monoid.toMulOneClass.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (Group.toDivInvMonoid.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.instGroupAut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))))) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))
-Case conversion may be inaccurate. Consider using '#align category_theory.Aut.mul_equiv_perm CategoryTheory.Aut.mulEquivPermₓ'. -/
 /-- The (unbundled) group of automorphisms of a type is `mul_equiv` to the (unbundled) group
 of permutations. -/
 def mulEquivPerm {α : Type u} : Aut α ≃* Equiv.Perm α :=

cb3ceec8

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -126,10 +126,7 @@ theorem one_apply (G H : GroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
 <too large>
 Case conversion may be inaccurate. Consider using '#align Group.ext GroupCat.extₓ'. -/
 @[ext, to_additive]
-theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
-  by
-  ext1
-  apply w
+theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ := by ext1; apply w
 #align Group.ext GroupCat.ext
 #align AddGroup.ext AddGroupCat.ext
 
@@ -254,9 +251,7 @@ theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
 <too large>
 Case conversion may be inaccurate. Consider using '#align CommGroup.ext CommGroupCat.extₓ'. -/
 @[ext, to_additive]
-theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
-  by
-  ext1
+theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ := by ext1;
   apply w
 #align CommGroup.ext CommGroupCat.ext
 #align AddCommGroup.ext AddCommGroupCat.ext

cb3ceec8

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -81,10 +81,7 @@ def ofHom {X Y : Type u} [Group X] [Group Y] (f : X →* Y) : of X ⟶ of Y :=
 add_decl_doc AddGroupCat.ofHom
 
 /- warning: Group.of_hom_apply -> GroupCat.ofHom_apply is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : Group.{u1} X] [_inst_2 : Group.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (x : X), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) (GroupCat.of.{u1} X _inst_1) (GroupCat.of.{u1} Y _inst_2)) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2))) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2))))) (GroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (fun (_x : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) => X -> Y) (MonoidHom.hasCoeToFun.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) f x)
-but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : Group.{u1} X] [_inst_2 : Group.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))))) (GroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1)))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))))) f x)
+<too large>
 Case conversion may be inaccurate. Consider using '#align Group.of_hom_apply GroupCat.ofHom_applyₓ'. -/
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) : ofHom f x = f x :=
@@ -117,10 +114,7 @@ instance ofUnique (G : Type _) [Group G] [i : Unique G] : Unique (GroupCat.of G)
 -/
 
 /- warning: Group.one_apply -> GroupCat.one_apply is a dubious translation:
-lean 3 declaration is
-  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (g : coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) 1 (OfNat.mk.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) 1 (One.one.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (MonoidHom.hasOne.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H))))))) g) (OfNat.ofNat.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) 1 (OfNat.mk.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) 1 (One.one.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (MulOneClass.toHasOne.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (GroupCat.group.{u1} H))))))))
-but is expected to have type
-  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (g : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) (GroupCat.instOneHomGroupCatToQuiverToCategoryStructInstGroupCatLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (InvOneClass.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (Group.toDivisionMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (GroupCat.instGroupα.{u1} H)))))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align Group.one_apply GroupCat.one_applyₓ'. -/
 @[simp, to_additive]
 theorem one_apply (G H : GroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
@@ -129,10 +123,7 @@ theorem one_apply (G H : GroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
 #align AddGroup.zero_apply AddGroupCat.zero_apply
 
 /- warning: Group.ext -> GroupCat.ext is a dubious translation:
-lean 3 declaration is
-  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H), (forall (x : coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) f₁ x) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) f₁ f₂)
-but is expected to have type
-  forall {G : GroupCat.{u1}} {H : GroupCat.{u1}} {f₁ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H} {f₂ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H}, (forall (x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) f₁ x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) f₁ f₂)
+<too large>
 Case conversion may be inaccurate. Consider using '#align Group.ext GroupCat.extₓ'. -/
 @[ext, to_additive]
 theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
@@ -213,10 +204,7 @@ def ofHom {X Y : Type u} [CommGroup X] [CommGroup Y] (f : X →* Y) : of X ⟶ o
 add_decl_doc AddCommGroupCat.ofHom
 
 /- warning: CommGroup.of_hom_apply -> CommGroupCat.ofHom_apply is a dubious translation:
-lean 3 declaration is
-  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : CommGroup.{u1} X] [_inst_2 : CommGroup.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (x : X), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) (CommGroupCat.of.{u1} X _inst_1) (CommGroupCat.of.{u1} Y _inst_2)) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2))) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) (CommGroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (fun (_x : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) => X -> Y) (MonoidHom.hasCoeToFun.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) f x)
-but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : CommGroup.{u1} X] [_inst_2 : CommGroup.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1))))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))))) (CommGroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1))))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2)))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))))) f x)
+<too large>
 Case conversion may be inaccurate. Consider using '#align CommGroup.of_hom_apply CommGroupCat.ofHom_applyₓ'. -/
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
@@ -254,10 +242,7 @@ instance ofUnique (G : Type _) [CommGroup G] [i : Unique G] : Unique (CommGroupC
 -/
 
 /- warning: CommGroup.one_apply -> CommGroupCat.one_apply is a dubious translation:
-lean 3 declaration is
-  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (g : coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) 1 (OfNat.mk.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) 1 (One.one.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (MonoidHom.hasOne.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H)))))))) g) (OfNat.ofNat.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) 1 (OfNat.mk.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) 1 (One.one.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (MulOneClass.toHasOne.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroupCat.commGroupInstance.{u1} H)))))))))
-but is expected to have type
-  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (g : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) (CommGroupCat.instOneHomCommGroupCatToQuiverToCategoryStructInstCommGroupCatLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (InvOneClass.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivisionCommMonoid.toDivisionMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (CommGroup.toDivisionCommMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (CommGroupCat.commGroupInstance.{u1} H))))))))
+<too large>
 Case conversion may be inaccurate. Consider using '#align CommGroup.one_apply CommGroupCat.one_applyₓ'. -/
 @[simp, to_additive]
 theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
@@ -266,10 +251,7 @@ theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
 #align AddCommGroup.zero_apply AddCommGroupCat.zero_apply
 
 /- warning: CommGroup.ext -> CommGroupCat.ext is a dubious translation:
-lean 3 declaration is
-  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H), (forall (x : coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) f₁ x) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) f₁ f₂)
-but is expected to have type
-  forall {G : CommGroupCat.{u1}} {H : CommGroupCat.{u1}} {f₁ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H} {f₂ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H}, (forall (x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) f₁ x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) f₁ f₂)
+<too large>
 Case conversion may be inaccurate. Consider using '#align CommGroup.ext CommGroupCat.extₓ'. -/
 @[ext, to_additive]
 theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
@@ -328,10 +310,7 @@ def asHom {G : AddCommGroupCat.{0}} (g : G) : AddCommGroupCat.of ℤ ⟶ G :=
 #align AddCommGroup.as_hom AddCommGroupCat.asHom
 
 /- warning: AddCommGroup.as_hom_apply -> AddCommGroupCat.asHom_apply is a dubious translation:
-lean 3 declaration is
-  forall {G : AddCommGroupCat.{0}} (g : coeSort.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.hasCoeToSort.{0} G) (i : Int), Eq.{1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) (AddCommGroupCat.asHom G g) i) (SMul.smul.{0, 0} Int (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (SubNegMonoid.SMulInt.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toSubNegMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroupCat.addCommGroupInstance.{0} G)))) i g)
-but is expected to have type
-  forall {G : AddCommGroupCat.{0}} (g : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (i : Int), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) i) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) (AddCommGroupCat.asHom G g) i) (HSMul.hSMul.{0, 0, 0} Int (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (instHSMul.{0, 0} Int (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.SMulInt.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) i g)
+<too large>
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom_apply AddCommGroupCat.asHom_applyₓ'. -/
 @[simp]
 theorem asHom_apply {G : AddCommGroupCat.{0}} (g : G) (i : ℤ) : (asHom g) i = i • g :=
@@ -349,10 +328,7 @@ theorem asHom_injective {G : AddCommGroupCat.{0}} : Function.Injective (@asHom G
 #align AddCommGroup.as_hom_injective AddCommGroupCat.asHom_injective
 
 /- warning: AddCommGroup.int_hom_ext -> AddCommGroupCat.int_hom_ext is a dubious translation:
-lean 3 declaration is
-  forall {G : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (g : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G), (Eq.{1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) f (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) g (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) -> (Eq.{1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) f g)
-but is expected to have type
-  forall {G : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (g : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G), (Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) f (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) g (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) -> (Eq.{1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) f g)
+<too large>
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.int_hom_ext AddCommGroupCat.int_hom_extₓ'. -/
 @[ext]
 theorem int_hom_ext {G : AddCommGroupCat.{0}} (f g : AddCommGroupCat.of ℤ ⟶ G)
@@ -361,10 +337,7 @@ theorem int_hom_ext {G : AddCommGroupCat.{0}} (f g : AddCommGroupCat.of ℤ ⟶
 #align AddCommGroup.int_hom_ext AddCommGroupCat.int_hom_ext
 
 /- warning: AddCommGroup.injective_of_mono -> AddCommGroupCat.injective_of_mono is a dubious translation:
-lean 3 declaration is
-  forall {G : AddCommGroupCat.{0}} {H : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) [_inst_1 : CategoryTheory.Mono.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0} G H f], Function.Injective.{1, 1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G)))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} H))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G)))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} H))))) f)
-but is expected to have type
-  forall {G : AddCommGroupCat.{0}} {H : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) G H) [_inst_1 : CategoryTheory.Mono.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0} G H f], Function.Injective.{1, 1} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))))) f)
+<too large>
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.injective_of_mono AddCommGroupCat.injective_of_monoₓ'. -/
 -- TODO: this argument should be generalised to the situation where
 -- the forgetful functor is representable.

cb3ceec8

bump to nightly-2023-05-19-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

a31df521

Diff

@@ -84,7 +84,7 @@ add_decl_doc AddGroupCat.ofHom
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : Group.{u1} X] [_inst_2 : Group.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (x : X), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) (GroupCat.of.{u1} X _inst_1) (GroupCat.of.{u1} Y _inst_2)) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2))) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2))))) (GroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (fun (_x : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) => X -> Y) (MonoidHom.hasCoeToFun.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) f x)
 but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : Group.{u1} X] [_inst_2 : Group.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))))) (GroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1)))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))))) f x)
+  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : Group.{u1} X] [_inst_2 : Group.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))))) (GroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1)))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))))) f x)
 Case conversion may be inaccurate. Consider using '#align Group.of_hom_apply GroupCat.ofHom_applyₓ'. -/
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) : ofHom f x = f x :=
@@ -120,7 +120,7 @@ instance ofUnique (G : Type _) [Group G] [i : Unique G] : Unique (GroupCat.of G)
 lean 3 declaration is
   forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (g : coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) 1 (OfNat.mk.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) 1 (One.one.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (MonoidHom.hasOne.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H))))))) g) (OfNat.ofNat.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) 1 (OfNat.mk.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) 1 (One.one.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (MulOneClass.toHasOne.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (GroupCat.group.{u1} H))))))))
 but is expected to have type
-  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (g : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) (GroupCat.instOneHomGroupCatToQuiverToCategoryStructInstGroupCatLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (InvOneClass.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (Group.toDivisionMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (GroupCat.instGroupα.{u1} H)))))))
+  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (g : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) (GroupCat.instOneHomGroupCatToQuiverToCategoryStructInstGroupCatLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (InvOneClass.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (Group.toDivisionMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (GroupCat.instGroupα.{u1} H)))))))
 Case conversion may be inaccurate. Consider using '#align Group.one_apply GroupCat.one_applyₓ'. -/
 @[simp, to_additive]
 theorem one_apply (G H : GroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
@@ -132,7 +132,7 @@ theorem one_apply (G H : GroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
 lean 3 declaration is
   forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H), (forall (x : coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) f₁ x) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) f₁ f₂)
 but is expected to have type
-  forall {G : GroupCat.{u1}} {H : GroupCat.{u1}} {f₁ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H} {f₂ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H}, (forall (x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) f₁ x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) f₁ f₂)
+  forall {G : GroupCat.{u1}} {H : GroupCat.{u1}} {f₁ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H} {f₂ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H}, (forall (x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) f₁ x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) f₁ f₂)
 Case conversion may be inaccurate. Consider using '#align Group.ext GroupCat.extₓ'. -/
 @[ext, to_additive]
 theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
@@ -216,7 +216,7 @@ add_decl_doc AddCommGroupCat.ofHom
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : CommGroup.{u1} X] [_inst_2 : CommGroup.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (x : X), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) (CommGroupCat.of.{u1} X _inst_1) (CommGroupCat.of.{u1} Y _inst_2)) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2))) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) (CommGroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (fun (_x : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) => X -> Y) (MonoidHom.hasCoeToFun.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) f x)
 but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : CommGroup.{u1} X] [_inst_2 : CommGroup.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1))))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))))) (CommGroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1))))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2)))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))))) f x)
+  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : CommGroup.{u1} X] [_inst_2 : CommGroup.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1))))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))))) (CommGroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1))))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2)))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))))) f x)
 Case conversion may be inaccurate. Consider using '#align CommGroup.of_hom_apply CommGroupCat.ofHom_applyₓ'. -/
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
@@ -257,7 +257,7 @@ instance ofUnique (G : Type _) [CommGroup G] [i : Unique G] : Unique (CommGroupC
 lean 3 declaration is
   forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (g : coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) 1 (OfNat.mk.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) 1 (One.one.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (MonoidHom.hasOne.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H)))))))) g) (OfNat.ofNat.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) 1 (OfNat.mk.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) 1 (One.one.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (MulOneClass.toHasOne.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroupCat.commGroupInstance.{u1} H)))))))))
 but is expected to have type
-  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (g : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) (CommGroupCat.instOneHomCommGroupCatToQuiverToCategoryStructInstCommGroupCatLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (InvOneClass.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivisionCommMonoid.toDivisionMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (CommGroup.toDivisionCommMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (CommGroupCat.commGroupInstance.{u1} H))))))))
+  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (g : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) (CommGroupCat.instOneHomCommGroupCatToQuiverToCategoryStructInstCommGroupCatLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (InvOneClass.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivisionCommMonoid.toDivisionMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (CommGroup.toDivisionCommMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (CommGroupCat.commGroupInstance.{u1} H))))))))
 Case conversion may be inaccurate. Consider using '#align CommGroup.one_apply CommGroupCat.one_applyₓ'. -/
 @[simp, to_additive]
 theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
@@ -269,7 +269,7 @@ theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
 lean 3 declaration is
   forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H), (forall (x : coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) f₁ x) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) f₁ f₂)
 but is expected to have type
-  forall {G : CommGroupCat.{u1}} {H : CommGroupCat.{u1}} {f₁ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H} {f₂ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H}, (forall (x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) f₁ x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) f₁ f₂)
+  forall {G : CommGroupCat.{u1}} {H : CommGroupCat.{u1}} {f₁ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H} {f₂ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H}, (forall (x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) f₁ x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) f₁ f₂)
 Case conversion may be inaccurate. Consider using '#align CommGroup.ext CommGroupCat.extₓ'. -/
 @[ext, to_additive]
 theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
@@ -331,7 +331,7 @@ def asHom {G : AddCommGroupCat.{0}} (g : G) : AddCommGroupCat.of ℤ ⟶ G :=
 lean 3 declaration is
   forall {G : AddCommGroupCat.{0}} (g : coeSort.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.hasCoeToSort.{0} G) (i : Int), Eq.{1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) (AddCommGroupCat.asHom G g) i) (SMul.smul.{0, 0} Int (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (SubNegMonoid.SMulInt.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toSubNegMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroupCat.addCommGroupInstance.{0} G)))) i g)
 but is expected to have type
-  forall {G : AddCommGroupCat.{0}} (g : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (i : Int), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) i) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) (AddCommGroupCat.asHom G g) i) (HSMul.hSMul.{0, 0, 0} Int (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (instHSMul.{0, 0} Int (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.SMulInt.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) i g)
+  forall {G : AddCommGroupCat.{0}} (g : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (i : Int), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) i) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) (AddCommGroupCat.asHom G g) i) (HSMul.hSMul.{0, 0, 0} Int (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (instHSMul.{0, 0} Int (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.SMulInt.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) i g)
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom_apply AddCommGroupCat.asHom_applyₓ'. -/
 @[simp]
 theorem asHom_apply {G : AddCommGroupCat.{0}} (g : G) (i : ℤ) : (asHom g) i = i • g :=
@@ -352,7 +352,7 @@ theorem asHom_injective {G : AddCommGroupCat.{0}} : Function.Injective (@asHom G
 lean 3 declaration is
   forall {G : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (g : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G), (Eq.{1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) f (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) g (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) -> (Eq.{1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) f g)
 but is expected to have type
-  forall {G : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (g : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G), (Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) f (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) g (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) -> (Eq.{1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) f g)
+  forall {G : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (g : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G), (Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) f (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) g (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) -> (Eq.{1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) f g)
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.int_hom_ext AddCommGroupCat.int_hom_extₓ'. -/
 @[ext]
 theorem int_hom_ext {G : AddCommGroupCat.{0}} (f g : AddCommGroupCat.of ℤ ⟶ G)
@@ -364,7 +364,7 @@ theorem int_hom_ext {G : AddCommGroupCat.{0}} (f g : AddCommGroupCat.of ℤ ⟶
 lean 3 declaration is
   forall {G : AddCommGroupCat.{0}} {H : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) [_inst_1 : CategoryTheory.Mono.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0} G H f], Function.Injective.{1, 1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G)))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} H))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G)))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} H))))) f)
 but is expected to have type
-  forall {G : AddCommGroupCat.{0}} {H : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) G H) [_inst_1 : CategoryTheory.Mono.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0} G H f], Function.Injective.{1, 1} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))))) f)
+  forall {G : AddCommGroupCat.{0}} {H : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) G H) [_inst_1 : CategoryTheory.Mono.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0} G H f], Function.Injective.{1, 1} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))))) f)
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.injective_of_mono AddCommGroupCat.injective_of_monoₓ'. -/
 -- TODO: this argument should be generalised to the situation where
 -- the forgetful functor is representable.

cb3ceec8

bump to nightly-2023-05-12-14

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

fab1af65

Diff

@@ -84,7 +84,7 @@ add_decl_doc AddGroupCat.ofHom
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : Group.{u1} X] [_inst_2 : Group.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (x : X), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) (GroupCat.of.{u1} X _inst_1) (GroupCat.of.{u1} Y _inst_2)) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2))) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2))))) (GroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (fun (_x : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) => X -> Y) (MonoidHom.hasCoeToFun.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) f x)
 but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : Group.{u1} X] [_inst_2 : Group.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (x : X), Eq.{succ u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} (GroupCat.of.{u1} Y _inst_2)) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) (GroupCat.of.{u1} X _inst_1) (GroupCat.of.{u1} Y _inst_2)) (fun (_x : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) (GroupCat.of.{u1} X _inst_1) (GroupCat.of.{u1} Y _inst_2)) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} (GroupCat.of.{u1} X _inst_1)) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} (GroupCat.of.{u1} Y _inst_2))) (GroupCat.instCoeFunHomGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortGroupCatType.{u1} (GroupCat.of.{u1} X _inst_1) (GroupCat.of.{u1} Y _inst_2)) (GroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1)))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))))) f x)
+  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : Group.{u1} X] [_inst_2 : Group.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2)) (GroupCat.instGroupα.{u1} (GroupCat.of.{u1} Y _inst_2)))))))) (GroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1)))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))))) f x)
 Case conversion may be inaccurate. Consider using '#align Group.of_hom_apply GroupCat.ofHom_applyₓ'. -/
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) : ofHom f x = f x :=
@@ -120,7 +120,7 @@ instance ofUnique (G : Type _) [Group G] [i : Unique G] : Unique (GroupCat.of G)
 lean 3 declaration is
   forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (g : coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) 1 (OfNat.mk.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) 1 (One.one.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (MonoidHom.hasOne.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H))))))) g) (OfNat.ofNat.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) 1 (OfNat.mk.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) 1 (One.one.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (MulOneClass.toHasOne.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (GroupCat.group.{u1} H))))))))
 but is expected to have type
-  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (g : CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} G), Eq.{succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) G H (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (GroupCat.instOneHomGroupCatToQuiverToCategoryStructLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) 1 (One.toOfNat1.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (InvOneClass.toOne.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (DivInvOneMonoid.toInvOneClass.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (DivisionMonoid.toDivInvOneMonoid.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (Group.toDivisionMonoid.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (GroupCat.instGroupObjGroupCatToQuiverToCategoryStructLargeCategoryTypeTypesToPrefunctorForgetConcreteCategory.{u1} H)))))))
+  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (g : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) (GroupCat.instOneHomGroupCatToQuiverToCategoryStructInstGroupCatLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (InvOneClass.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (Group.toDivisionMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) g) (GroupCat.instGroupα.{u1} H)))))))
 Case conversion may be inaccurate. Consider using '#align Group.one_apply GroupCat.one_applyₓ'. -/
 @[simp, to_additive]
 theorem one_apply (G H : GroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
@@ -132,7 +132,7 @@ theorem one_apply (G H : GroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
 lean 3 declaration is
   forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H), (forall (x : coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) f₁ x) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) f₁ f₂)
 but is expected to have type
-  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H), (forall (x : CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} G), Eq.{succ u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} H) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} G) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} H)) (GroupCat.instCoeFunHomGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortGroupCatType.{u1} G H) f₁ x) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} G) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} H)) (GroupCat.instCoeFunHomGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortGroupCatType.{u1} G H) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) f₁ f₂)
+  forall {G : GroupCat.{u1}} {H : GroupCat.{u1}} {f₁ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H} {f₂ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H}, (forall (x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) f₁ x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H)))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} G) (GroupCat.instGroupα.{u1} G)))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} H) (GroupCat.instGroupα.{u1} H))))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1})) G H) f₁ f₂)
 Case conversion may be inaccurate. Consider using '#align Group.ext GroupCat.extₓ'. -/
 @[ext, to_additive]
 theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
@@ -216,7 +216,7 @@ add_decl_doc AddCommGroupCat.ofHom
 lean 3 declaration is
   forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : CommGroup.{u1} X] [_inst_2 : CommGroup.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (x : X), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) (CommGroupCat.of.{u1} X _inst_1) (CommGroupCat.of.{u1} Y _inst_2)) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2))) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) (CommGroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (fun (_x : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) => X -> Y) (MonoidHom.hasCoeToFun.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) f x)
 but is expected to have type
-  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : CommGroup.{u1} X] [_inst_2 : CommGroup.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (x : X), Eq.{succ u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) (CommGroupCat.of.{u1} X _inst_1) (CommGroupCat.of.{u1} Y _inst_2)) (fun (_x : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) (CommGroupCat.of.{u1} X _inst_1) (CommGroupCat.of.{u1} Y _inst_2)) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} (CommGroupCat.of.{u1} X _inst_1)) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} (CommGroupCat.of.{u1} Y _inst_2))) (CommGroupCat.instCoeFunHomCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortCommGroupCatType.{u1} (CommGroupCat.of.{u1} X _inst_1) (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1))))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2)))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))))) f x)
+  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : CommGroup.{u1} X] [_inst_2 : CommGroup.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (x : X), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1))))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} X _inst_1)))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.commGroupInstance.{u1} (CommGroupCat.of.{u1} Y _inst_2))))))))) (CommGroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1))))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2)))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))))) f x)
 Case conversion may be inaccurate. Consider using '#align CommGroup.of_hom_apply CommGroupCat.ofHom_applyₓ'. -/
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
@@ -257,7 +257,7 @@ instance ofUnique (G : Type _) [CommGroup G] [i : Unique G] : Unique (CommGroupC
 lean 3 declaration is
   forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (g : coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) 1 (OfNat.mk.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) 1 (One.one.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (MonoidHom.hasOne.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H)))))))) g) (OfNat.ofNat.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) 1 (OfNat.mk.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) 1 (One.one.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (MulOneClass.toHasOne.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroupCat.commGroupInstance.{u1} H)))))))))
 but is expected to have type
-  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (g : CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} G), Eq.{succ u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} G) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H)) (CommGroupCat.instCoeFunHomCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortCommGroupCatType.{u1} G H) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (CommGroupCat.instOneHomCommGroupCatToQuiverToCategoryStructLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) 1 (One.toOfNat1.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (InvOneClass.toOne.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (DivInvOneMonoid.toInvOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (DivisionMonoid.toDivInvOneMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (DivisionCommMonoid.toDivisionMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (CommGroup.toDivisionCommMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))))))
+  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (g : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) (CommGroupCat.instOneHomCommGroupCatToQuiverToCategoryStructInstCommGroupCatLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) 1 (One.toOfNat1.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (InvOneClass.toOne.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivInvOneMonoid.toInvOneClass.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivisionMonoid.toDivInvOneMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (DivisionCommMonoid.toDivisionMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (CommGroup.toDivisionCommMonoid.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) g) (CommGroupCat.commGroupInstance.{u1} H))))))))
 Case conversion may be inaccurate. Consider using '#align CommGroup.one_apply CommGroupCat.one_applyₓ'. -/
 @[simp, to_additive]
 theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
@@ -269,7 +269,7 @@ theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
 lean 3 declaration is
   forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H), (forall (x : coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) f₁ x) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) f₁ f₂)
 but is expected to have type
-  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H), (forall (x : CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} G), Eq.{succ u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} G) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H)) (CommGroupCat.instCoeFunHomCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortCommGroupCatType.{u1} G H) f₁ x) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} G) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H)) (CommGroupCat.instCoeFunHomCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortCommGroupCatType.{u1} G H) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) f₁ f₂)
+  forall {G : CommGroupCat.{u1}} {H : CommGroupCat.{u1}} {f₁ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H} {f₂ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H}, (forall (x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G), Eq.{succ u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) f₁ x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (fun (_x : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) => CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))) (MonoidHom.monoidHomClass.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} G) (CommGroupCat.commGroupInstance.{u1} G))))) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} H) (CommGroupCat.commGroupInstance.{u1} H)))))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1})) G H) f₁ f₂)
 Case conversion may be inaccurate. Consider using '#align CommGroup.ext CommGroupCat.extₓ'. -/
 @[ext, to_additive]
 theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
@@ -316,7 +316,7 @@ namespace AddCommGroupCat
 lean 3 declaration is
   forall {G : AddCommGroupCat.{0}}, (coeSort.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.hasCoeToSort.{0} G) -> (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G)
 but is expected to have type
-  forall {G : AddCommGroupCat.{0}}, (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) -> (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G)
+  forall {G : AddCommGroupCat.{0}}, (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) -> (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G)
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom AddCommGroupCat.asHomₓ'. -/
 -- Note that because `ℤ : Type 0`, this forces `G : AddCommGroup.{0}`,
 -- so we write this explicitly to be clear.
@@ -331,7 +331,7 @@ def asHom {G : AddCommGroupCat.{0}} (g : G) : AddCommGroupCat.of ℤ ⟶ G :=
 lean 3 declaration is
   forall {G : AddCommGroupCat.{0}} (g : coeSort.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.hasCoeToSort.{0} G) (i : Int), Eq.{1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) (AddCommGroupCat.asHom G g) i) (SMul.smul.{0, 0} Int (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (SubNegMonoid.SMulInt.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toSubNegMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroupCat.addCommGroupInstance.{0} G)))) i g)
 but is expected to have type
-  forall {G : AddCommGroupCat.{0}} (g : CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (i : Int), Eq.{1} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (CoeFun.coe.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (fun (_x : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) => (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) -> (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G)) (AddCommGroupCat.instCoeFunHomAddCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (AddCommGroupCat.asHom G g) i) (HSMul.hSMul.{0, 0, 0} Int (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (instHSMul.{0, 0} Int (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (SubNegMonoid.SMulInt.{0} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (AddGroup.toSubNegMonoid.{0} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (AddCommGroup.toAddGroup.{0} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) i g)
+  forall {G : AddCommGroupCat.{0}} (g : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (i : Int), Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) i) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) (AddCommGroupCat.asHom G g) i) (HSMul.hSMul.{0, 0, 0} Int (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (instHSMul.{0, 0} Int (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.SMulInt.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) i g)
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom_apply AddCommGroupCat.asHom_applyₓ'. -/
 @[simp]
 theorem asHom_apply {G : AddCommGroupCat.{0}} (g : G) (i : ℤ) : (asHom g) i = i • g :=
@@ -342,7 +342,7 @@ theorem asHom_apply {G : AddCommGroupCat.{0}} (g : G) (i : ℤ) : (asHom g) i =
 lean 3 declaration is
   forall {G : AddCommGroupCat.{0}}, Function.Injective.{1, 1} (coeSort.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.hasCoeToSort.{0} G) (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (AddCommGroupCat.asHom G)
 but is expected to have type
-  forall {G : AddCommGroupCat.{0}}, Function.Injective.{1, 1} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (AddCommGroupCat.asHom G)
+  forall {G : AddCommGroupCat.{0}}, Function.Injective.{1, 1} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (AddCommGroupCat.asHom G)
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom_injective AddCommGroupCat.asHom_injectiveₓ'. -/
 theorem asHom_injective {G : AddCommGroupCat.{0}} : Function.Injective (@asHom G) := fun h k w => by
   convert congr_arg (fun k : AddCommGroupCat.of ℤ ⟶ G => (k : ℤ → G) (1 : ℤ)) w <;> simp
@@ -352,7 +352,7 @@ theorem asHom_injective {G : AddCommGroupCat.{0}} : Function.Injective (@asHom G
 lean 3 declaration is
   forall {G : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (g : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G), (Eq.{1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) f (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) g (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) -> (Eq.{1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) f g)
 but is expected to have type
-  forall {G : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (g : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G), (Eq.{1} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (CoeFun.coe.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (fun (_x : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) => (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) -> (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G)) (AddCommGroupCat.instCoeFunHomAddCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) f (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (CoeFun.coe.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (fun (_x : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) => (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) -> (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G)) (AddCommGroupCat.instCoeFunHomAddCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) g (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) -> (Eq.{1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) f g)
+  forall {G : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (g : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G), (Eq.{1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) f (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt))))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) (AddCommGroupCat.addCommGroupInstance.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))))) g (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) -> (Eq.{1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) f g)
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.int_hom_ext AddCommGroupCat.int_hom_extₓ'. -/
 @[ext]
 theorem int_hom_ext {G : AddCommGroupCat.{0}} (f g : AddCommGroupCat.of ℤ ⟶ G)
@@ -364,7 +364,7 @@ theorem int_hom_ext {G : AddCommGroupCat.{0}} (f g : AddCommGroupCat.of ℤ ⟶
 lean 3 declaration is
   forall {G : AddCommGroupCat.{0}} {H : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) [_inst_1 : CategoryTheory.Mono.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0} G H f], Function.Injective.{1, 1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G)))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} H))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G)))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} H))))) f)
 but is expected to have type
-  forall {G : AddCommGroupCat.{0}} {H : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) [_inst_1 : CategoryTheory.Mono.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0} G H f], Function.Injective.{1, 1} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} H) (CoeFun.coe.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) (fun (_x : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) => (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) -> (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} H)) (AddCommGroupCat.instCoeFunHomAddCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortAddCommGroupCatType.{0} G H) f)
+  forall {G : AddCommGroupCat.{0}} {H : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0})) G H) [_inst_1 : CategoryTheory.Mono.{0, 1} AddCommGroupCat.{0} instAddCommGroupCatLargeCategory.{0} G H f], Function.Injective.{1, 1} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (FunLike.coe.{1, 1, 1} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (fun (_x : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) => CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) _x) (AddHomClass.toFunLike.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G)))))) (AddZeroClass.toAdd.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (AddMonoidHomClass.toAddHomClass.{0, 0, 0} (AddMonoidHom.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H))))) (AddMonoidHom.addMonoidHomClass.{0, 0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) (AddMonoid.toAddZeroClass.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (SubNegMonoid.toAddMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddGroup.toSubNegMonoid.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroup.toAddGroup.{0} (CategoryTheory.Bundled.α.{0, 0} AddCommGroup.{0} H) (AddCommGroupCat.addCommGroupInstance.{0} H)))))))) f)
 Case conversion may be inaccurate. Consider using '#align AddCommGroup.injective_of_mono AddCommGroupCat.injective_of_monoₓ'. -/
 -- TODO: this argument should be generalised to the situation where
 -- the forgetful functor is representable.
@@ -384,7 +384,7 @@ end AddCommGroupCat
 lean 3 declaration is
   forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (GroupCat.group.{u1} X))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (GroupCat.group.{u1} Y)))))) -> (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y)
 but is expected to have type
-  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} X))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} Y)))))) -> (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y)
+  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (GroupCat.instGroupα.{u1} X))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (GroupCat.instGroupα.{u1} Y)))))) -> (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1} X Y)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.to_Group_iso MulEquiv.toGroupCatIsoₓ'. -/
 /-- Build an isomorphism in the category `Group` from a `mul_equiv` between `group`s. -/
 @[to_additive AddEquiv.toAddGroupCatIso, simps]
@@ -402,7 +402,7 @@ add_decl_doc AddEquiv.toAddGroupCatIso
 lean 3 declaration is
   forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) -> (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y)
 but is expected to have type
-  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) -> (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y)
+  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) -> (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1} X Y)
 Case conversion may be inaccurate. Consider using '#align mul_equiv.to_CommGroup_iso MulEquiv.toCommGroupCatIsoₓ'. -/
 /-- Build an isomorphism in the category `CommGroup` from a `mul_equiv` between `comm_group`s. -/
 @[to_additive AddEquiv.toAddCommGroupCatIso, simps]
@@ -423,7 +423,7 @@ namespace CategoryTheory.Iso
 lean 3 declaration is
   forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (GroupCat.group.{u1} X))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (GroupCat.group.{u1} Y))))))
 but is expected to have type
-  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} X))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} Y))))))
+  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (GroupCat.instGroupα.{u1} X))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (GroupCat.instGroupα.{u1} Y))))))
 Case conversion may be inaccurate. Consider using '#align category_theory.iso.Group_iso_to_mul_equiv CategoryTheory.Iso.groupIsoToMulEquivₓ'. -/
 /-- Build a `mul_equiv` from an isomorphism in the category `Group`. -/
 @[to_additive AddGroup_iso_to_add_equiv
@@ -438,7 +438,7 @@ def groupIsoToMulEquiv {X Y : GroupCat} (i : X ≅ Y) : X ≃* Y :=
 lean 3 declaration is
   forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y)))))))
 but is expected to have type
-  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y)))))))
+  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y)))))))
 Case conversion may be inaccurate. Consider using '#align category_theory.iso.CommGroup_iso_to_mul_equiv CategoryTheory.Iso.commGroupIsoToMulEquivₓ'. -/
 /-- Build a `mul_equiv` from an isomorphism in the category `CommGroup`. -/
 @[to_additive AddCommGroup_iso_to_add_equiv
@@ -455,7 +455,7 @@ end CategoryTheory.Iso
 lean 3 declaration is
   forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (GroupCat.group.{u1} X))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (GroupCat.group.{u1} Y)))))) (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y)
 but is expected to have type
-  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} X))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} Y)))))) (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y)
+  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} X) (GroupCat.instGroupα.{u1} X))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} Group.{u1} Y) (GroupCat.instGroupα.{u1} Y)))))) (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1} X Y)
 Case conversion may be inaccurate. Consider using '#align mul_equiv_iso_Group_iso mulEquivIsoGroupIsoₓ'. -/
 /-- multiplicative equivalences between `group`s are the same as (isomorphic to) isomorphisms
 in `Group` -/
@@ -472,7 +472,7 @@ def mulEquivIsoGroupIso {X Y : GroupCat.{u}} : X ≃* Y ≅ X ≅ Y
 lean 3 declaration is
   forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y)
 but is expected to have type
-  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y)
+  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Monoid.toMulOneClass.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (Group.toDivInvMonoid.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroup.toGroup.{u1} (CategoryTheory.Bundled.α.{u1, u1} CommGroup.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} instCommGroupCatLargeCategory.{u1} X Y)
 Case conversion may be inaccurate. Consider using '#align mul_equiv_iso_CommGroup_iso mulEquivIsoCommGroupIsoₓ'. -/
 /-- multiplicative equivalences between `comm_group`s are the same as (isomorphic to) isomorphisms
 in `CommGroup` -/
@@ -491,7 +491,7 @@ namespace CategoryTheory.Aut
 lean 3 declaration is
   forall {α : Type.{u1}}, CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α)) (GroupCat.of.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))
 but is expected to have type
-  forall {α : Type.{u1}}, CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.instGroupAut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α)) (GroupCat.of.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))
+  forall {α : Type.{u1}}, CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} instGroupCatLargeCategory.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.instGroupAut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α)) (GroupCat.of.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))
 Case conversion may be inaccurate. Consider using '#align category_theory.Aut.iso_perm CategoryTheory.Aut.isoPermₓ'. -/
 /-- The (bundled) group of automorphisms of a type is isomorphic to the (bundled) group
 of permutations. -/

cb3ceec8

bump to nightly-2023-03-26-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/55d771df074d0dd020139ee1cd4b95521422df9f

ca5de00c

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 
 ! This file was ported from Lean 3 source module algebra.category.Group.basic
-! leanprover-community/mathlib commit 524793de15bc4c52ee32d254e7d7867c7176b3af
+! leanprover-community/mathlib commit cb3ceec8485239a61ed51d944cb9a95b68c6bafc
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.CategoryTheory.Endomorphism
 /-!
 # Category instances for group, add_group, comm_group, and add_comm_group.
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 We introduce the bundled categories:
 * `Group`
 * `AddGroup`

524793de

bump to nightly-2023-03-23-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/57e09a1296bfb4330ddf6624f1028ba186117d82

53b827ba

Diff

@@ -27,12 +27,14 @@ universe u v
 
 open CategoryTheory
 
+#print GroupCat /-
 /-- The category of groups and group morphisms. -/
 @[to_additive AddGroupCat]
 def GroupCat : Type (u + 1) :=
   Bundled Group
 #align Group GroupCat
 #align AddGroup AddGroupCat
+-/
 
 /-- The category of additive groups and group morphisms -/
 add_decl_doc AddGroupCat
@@ -51,26 +53,36 @@ attribute [to_additive] GroupCat.largeCategory GroupCat.concreteCategory
 instance : CoeSort GroupCat (Type _) :=
   Bundled.hasCoeToSort
 
+#print GroupCat.of /-
 /-- Construct a bundled `Group` from the underlying type and typeclass. -/
 @[to_additive]
 def of (X : Type u) [Group X] : GroupCat :=
   Bundled.of X
 #align Group.of GroupCat.of
 #align AddGroup.of AddGroupCat.of
+-/
 
 /-- Construct a bundled `AddGroup` from the underlying type and typeclass. -/
 add_decl_doc AddGroupCat.of
 
+#print GroupCat.ofHom /-
 /-- Typecheck a `monoid_hom` as a morphism in `Group`. -/
 @[to_additive]
 def ofHom {X Y : Type u} [Group X] [Group Y] (f : X →* Y) : of X ⟶ of Y :=
   f
 #align Group.of_hom GroupCat.ofHom
 #align AddGroup.of_hom AddGroupCat.ofHom
+-/
 
 /-- Typecheck a `add_monoid_hom` as a morphism in `AddGroup`. -/
 add_decl_doc AddGroupCat.ofHom
 
+/- warning: Group.of_hom_apply -> GroupCat.ofHom_apply is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : Group.{u1} X] [_inst_2 : Group.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (x : X), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) (GroupCat.of.{u1} X _inst_1) (GroupCat.of.{u1} Y _inst_2)) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2))) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) (GroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} (GroupCat.of.{u1} Y _inst_2))))) (GroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (fun (_x : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) => X -> Y) (MonoidHom.hasCoeToFun.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) f x)
+but is expected to have type
+  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : Group.{u1} X] [_inst_2 : Group.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (x : X), Eq.{succ u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} (GroupCat.of.{u1} Y _inst_2)) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) (GroupCat.of.{u1} X _inst_1) (GroupCat.of.{u1} Y _inst_2)) (fun (_x : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) (GroupCat.of.{u1} X _inst_1) (GroupCat.of.{u1} Y _inst_2)) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} (GroupCat.of.{u1} X _inst_1)) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} (GroupCat.of.{u1} Y _inst_2))) (GroupCat.instCoeFunHomGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortGroupCatType.{u1} (GroupCat.of.{u1} X _inst_1) (GroupCat.of.{u1} Y _inst_2)) (GroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1)))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X _inst_1))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y _inst_2)))))) f x)
+Case conversion may be inaccurate. Consider using '#align Group.of_hom_apply GroupCat.ofHom_applyₓ'. -/
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) : ofHom f x = f x :=
   rfl
@@ -81,28 +93,44 @@ theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) :
 instance (G : GroupCat) : Group G :=
   G.str
 
+#print GroupCat.coe_of /-
 @[simp, to_additive]
 theorem coe_of (R : Type u) [Group R] : (GroupCat.of R : Type u) = R :=
   rfl
 #align Group.coe_of GroupCat.coe_of
 #align AddGroup.coe_of AddGroupCat.coe_of
+-/
 
 @[to_additive]
 instance : Inhabited GroupCat :=
   ⟨GroupCat.of PUnit⟩
 
+#print GroupCat.ofUnique /-
 @[to_additive]
 instance ofUnique (G : Type _) [Group G] [i : Unique G] : Unique (GroupCat.of G) :=
   i
 #align Group.of_unique GroupCat.ofUnique
 #align AddGroup.of_unique AddGroupCat.ofUnique
+-/
 
+/- warning: Group.one_apply -> GroupCat.one_apply is a dubious translation:
+lean 3 declaration is
+  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (g : coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) 1 (OfNat.mk.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) 1 (One.one.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (MonoidHom.hasOne.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H))))))) g) (OfNat.ofNat.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) 1 (OfNat.mk.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) 1 (One.one.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (MulOneClass.toHasOne.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (GroupCat.group.{u1} H))))))))
+but is expected to have type
+  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (g : CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} G), Eq.{succ u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (Prefunctor.map.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) G H (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (GroupCat.instOneHomGroupCatToQuiverToCategoryStructLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) 1 (One.toOfNat1.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (InvOneClass.toOne.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (DivInvOneMonoid.toInvOneClass.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (DivisionMonoid.toDivInvOneMonoid.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (Group.toDivisionMonoid.{u1} (Prefunctor.obj.{succ u1, succ u1, succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) Type.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} Type.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1})) (CategoryTheory.Functor.toPrefunctor.{u1, u1, succ u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} Type.{u1} CategoryTheory.types.{u1} (CategoryTheory.forget.{succ u1, u1, u1} GroupCat.{u1} GroupCat.largeCategory.{u1} GroupCat.concreteCategory.{u1})) H) (GroupCat.instGroupObjGroupCatToQuiverToCategoryStructLargeCategoryTypeTypesToPrefunctorForgetConcreteCategory.{u1} H)))))))
+Case conversion may be inaccurate. Consider using '#align Group.one_apply GroupCat.one_applyₓ'. -/
 @[simp, to_additive]
 theorem one_apply (G H : GroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
   rfl
 #align Group.one_apply GroupCat.one_apply
 #align AddGroup.zero_apply AddGroupCat.zero_apply
 
+/- warning: Group.ext -> GroupCat.ext is a dubious translation:
+lean 3 declaration is
+  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H), (forall (x : coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) f₁ x) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} G))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} Group.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} Group.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} Group.{u1} H)))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) f₁ f₂)
+but is expected to have type
+  forall (G : GroupCat.{u1}) (H : GroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H), (forall (x : CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} G), Eq.{succ u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} H) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} G) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} H)) (GroupCat.instCoeFunHomGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortGroupCatType.{u1} G H) f₁ x) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) (fun (_x : Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} G) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} H)) (GroupCat.instCoeFunHomGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortGroupCatType.{u1} G H) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} GroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} GroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1})) G H) f₁ f₂)
+Case conversion may be inaccurate. Consider using '#align Group.ext GroupCat.extₓ'. -/
 @[ext, to_additive]
 theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
   by
@@ -111,31 +139,37 @@ theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x)
 #align Group.ext GroupCat.ext
 #align AddGroup.ext AddGroupCat.ext
 
+#print GroupCat.hasForgetToMonCat /-
 @[to_additive has_forget_to_AddMon]
-instance hasForgetToMon : HasForget₂ GroupCat MonCat :=
+instance hasForgetToMonCat : HasForget₂ GroupCat MonCat :=
   BundledHom.forget₂ _ _
-#align Group.has_forget_to_Mon GroupCat.hasForgetToMon
-#align AddGroup.has_forget_to_AddMon AddGroupCat.hasForgetToAddMon
+#align Group.has_forget_to_Mon GroupCat.hasForgetToMonCat
+#align AddGroup.has_forget_to_AddMon AddGroupCat.hasForgetToAddMonCat
+-/
 
 @[to_additive]
 instance : Coe GroupCat.{u} MonCat.{u} where coe := (forget₂ GroupCat MonCat).obj
 
 end GroupCat
 
+#print CommGroupCat /-
 /-- The category of commutative groups and group morphisms. -/
 @[to_additive AddCommGroupCat]
 def CommGroupCat : Type (u + 1) :=
   Bundled CommGroup
 #align CommGroup CommGroupCat
 #align AddCommGroup AddCommGroupCat
+-/
 
 /-- The category of additive commutative groups and group morphisms. -/
 add_decl_doc AddCommGroupCat
 
+#print Ab /-
 /-- `Ab` is an abbreviation for `AddCommGroup`, for the sake of mathematicians' sanity. -/
 abbrev Ab :=
   AddCommGroupCat
 #align Ab Ab
+-/
 
 namespace CommGroupCat
 
@@ -151,26 +185,36 @@ attribute [to_additive] CommGroupCat.largeCategory CommGroupCat.concreteCategory
 instance : CoeSort CommGroupCat (Type _) :=
   Bundled.hasCoeToSort
 
+#print CommGroupCat.of /-
 /-- Construct a bundled `CommGroup` from the underlying type and typeclass. -/
 @[to_additive]
 def of (G : Type u) [CommGroup G] : CommGroupCat :=
   Bundled.of G
 #align CommGroup.of CommGroupCat.of
 #align AddCommGroup.of AddCommGroupCat.of
+-/
 
 /-- Construct a bundled `AddCommGroup` from the underlying type and typeclass. -/
 add_decl_doc AddCommGroupCat.of
 
+#print CommGroupCat.ofHom /-
 /-- Typecheck a `monoid_hom` as a morphism in `CommGroup`. -/
 @[to_additive]
 def ofHom {X Y : Type u} [CommGroup X] [CommGroup Y] (f : X →* Y) : of X ⟶ of Y :=
   f
 #align CommGroup.of_hom CommGroupCat.ofHom
 #align AddCommGroup.of_hom AddCommGroupCat.ofHom
+-/
 
 /-- Typecheck a `add_monoid_hom` as a morphism in `AddCommGroup`. -/
 add_decl_doc AddCommGroupCat.ofHom
 
+/- warning: CommGroup.of_hom_apply -> CommGroupCat.ofHom_apply is a dubious translation:
+lean 3 declaration is
+  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : CommGroup.{u1} X] [_inst_2 : CommGroup.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (x : X), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) (CommGroupCat.of.{u1} X _inst_1) (CommGroupCat.of.{u1} Y _inst_2)) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2))) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} X _inst_1)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} X _inst_1))))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) (CommGroupCat.of.{u1} Y _inst_2)) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} (CommGroupCat.of.{u1} Y _inst_2)))))) (CommGroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (coeFn.{succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (fun (_x : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) => X -> Y) (MonoidHom.hasCoeToFun.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) f x)
+but is expected to have type
+  forall {X : Type.{u1}} {Y : Type.{u1}} [_inst_1 : CommGroup.{u1} X] [_inst_2 : CommGroup.{u1} Y] (f : MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (x : X), Eq.{succ u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} (CommGroupCat.of.{u1} Y _inst_2)) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) (CommGroupCat.of.{u1} X _inst_1) (CommGroupCat.of.{u1} Y _inst_2)) (fun (_x : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) (CommGroupCat.of.{u1} X _inst_1) (CommGroupCat.of.{u1} Y _inst_2)) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} (CommGroupCat.of.{u1} X _inst_1)) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} (CommGroupCat.of.{u1} Y _inst_2))) (CommGroupCat.instCoeFunHomCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortCommGroupCatType.{u1} (CommGroupCat.of.{u1} X _inst_1) (CommGroupCat.of.{u1} Y _inst_2)) (CommGroupCat.ofHom.{u1} X Y _inst_1 _inst_2 f) x) (FunLike.coe.{succ u1, succ u1, succ u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X (fun (_x : X) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : X) => Y) _x) (MulHomClass.toFunLike.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (MulOneClass.toMul.{u1} X (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1))))) (MulOneClass.toMul.{u1} Y (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) (MonoidHomClass.toMulHomClass.{u1, u1, u1} (MonoidHom.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))) X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2)))) (MonoidHom.monoidHomClass.{u1, u1} X Y (Monoid.toMulOneClass.{u1} X (DivInvMonoid.toMonoid.{u1} X (Group.toDivInvMonoid.{u1} X (CommGroup.toGroup.{u1} X _inst_1)))) (Monoid.toMulOneClass.{u1} Y (DivInvMonoid.toMonoid.{u1} Y (Group.toDivInvMonoid.{u1} Y (CommGroup.toGroup.{u1} Y _inst_2))))))) f x)
+Case conversion may be inaccurate. Consider using '#align CommGroup.of_hom_apply CommGroupCat.ofHom_applyₓ'. -/
 @[simp, to_additive]
 theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
     ofHom f x = f x :=
@@ -178,34 +222,52 @@ theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x
 #align CommGroup.of_hom_apply CommGroupCat.ofHom_apply
 #align AddCommGroup.of_hom_apply AddCommGroupCat.ofHom_apply
 
+#print CommGroupCat.commGroupInstance /-
 @[to_additive]
 instance commGroupInstance (G : CommGroupCat) : CommGroup G :=
   G.str
 #align CommGroup.comm_group_instance CommGroupCat.commGroupInstance
 #align AddCommGroup.add_comm_group_instance AddCommGroupCat.addCommGroupInstance
+-/
 
+#print CommGroupCat.coe_of /-
 @[simp, to_additive]
 theorem coe_of (R : Type u) [CommGroup R] : (CommGroupCat.of R : Type u) = R :=
   rfl
 #align CommGroup.coe_of CommGroupCat.coe_of
 #align AddCommGroup.coe_of AddCommGroupCat.coe_of
+-/
 
 @[to_additive]
 instance : Inhabited CommGroupCat :=
   ⟨CommGroupCat.of PUnit⟩
 
+#print CommGroupCat.ofUnique /-
 @[to_additive]
 instance ofUnique (G : Type _) [CommGroup G] [i : Unique G] : Unique (CommGroupCat.of G) :=
   i
 #align CommGroup.of_unique CommGroupCat.ofUnique
 #align AddCommGroup.of_unique AddCommGroupCat.ofUnique
+-/
 
+/- warning: CommGroup.one_apply -> CommGroupCat.one_apply is a dubious translation:
+lean 3 declaration is
+  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (g : coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) 1 (OfNat.mk.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) 1 (One.one.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (MonoidHom.hasOne.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H)))))))) g) (OfNat.ofNat.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) 1 (OfNat.mk.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) 1 (One.one.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (MulOneClass.toHasOne.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroupCat.commGroupInstance.{u1} H)))))))))
+but is expected to have type
+  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (g : CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} G), Eq.{succ u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} G) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H)) (CommGroupCat.instCoeFunHomCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortCommGroupCatType.{u1} G H) (OfNat.ofNat.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) 1 (One.toOfNat1.{u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (CommGroupCat.instOneHomCommGroupCatToQuiverToCategoryStructLargeCategory.{u1} G H))) g) (OfNat.ofNat.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) 1 (One.toOfNat1.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (InvOneClass.toOne.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (DivInvOneMonoid.toInvOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (DivisionMonoid.toDivInvOneMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (DivisionCommMonoid.toDivisionMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (CommGroup.toDivisionCommMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (CommGroupCat.commGroupInstance.{u1} H))))))))
+Case conversion may be inaccurate. Consider using '#align CommGroup.one_apply CommGroupCat.one_applyₓ'. -/
 @[simp, to_additive]
 theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
   rfl
 #align CommGroup.one_apply CommGroupCat.one_apply
 #align AddCommGroup.zero_apply AddCommGroupCat.zero_apply
 
+/- warning: CommGroup.ext -> CommGroupCat.ext is a dubious translation:
+lean 3 declaration is
+  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H), (forall (x : coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G), Eq.{succ u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) f₁ x) (coeFn.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : MonoidHom.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) => (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) -> (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H)) (MonoidHom.hasCoeToFun.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) G) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} G)))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (Group.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} (CategoryTheory.Bundled.{u1, u1} CommGroup.{u1}) Type.{u1} (CategoryTheory.Bundled.hasCoeToSort.{u1, u1} CommGroup.{u1}) H) (CategoryTheory.Bundled.str.{u1, u1} CommGroup.{u1} H))))) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) f₁ f₂)
+but is expected to have type
+  forall (G : CommGroupCat.{u1}) (H : CommGroupCat.{u1}) (f₁ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (f₂ : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H), (forall (x : CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} G), Eq.{succ u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} G) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H)) (CommGroupCat.instCoeFunHomCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortCommGroupCatType.{u1} G H) f₁ x) (CoeFun.coe.{succ u1, succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) (fun (_x : Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) => (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} G) -> (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} H)) (CommGroupCat.instCoeFunHomCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortCommGroupCatType.{u1} G H) f₂ x)) -> (Eq.{succ u1} (Quiver.Hom.{succ u1, succ u1} CommGroupCat.{u1} (CategoryTheory.CategoryStruct.toQuiver.{u1, succ u1} CommGroupCat.{u1} (CategoryTheory.Category.toCategoryStruct.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1})) G H) f₁ f₂)
+Case conversion may be inaccurate. Consider using '#align CommGroup.ext CommGroupCat.extₓ'. -/
 @[ext, to_additive]
 theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
   by
@@ -214,20 +276,24 @@ theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂
 #align CommGroup.ext CommGroupCat.ext
 #align AddCommGroup.ext AddCommGroupCat.ext
 
+#print CommGroupCat.hasForgetToGroup /-
 @[to_additive has_forget_to_AddGroup]
 instance hasForgetToGroup : HasForget₂ CommGroupCat GroupCat :=
   BundledHom.forget₂ _ _
 #align CommGroup.has_forget_to_Group CommGroupCat.hasForgetToGroup
 #align AddCommGroup.has_forget_to_AddGroup AddCommGroupCat.hasForgetToAddGroup
+-/
 
 @[to_additive]
 instance : Coe CommGroupCat.{u} GroupCat.{u} where coe := (forget₂ CommGroupCat GroupCat).obj
 
+#print CommGroupCat.hasForgetToCommMonCat /-
 @[to_additive has_forget_to_AddCommMon]
-instance hasForgetToCommMon : HasForget₂ CommGroupCat CommMonCat :=
+instance hasForgetToCommMonCat : HasForget₂ CommGroupCat CommMonCat :=
   InducedCategory.hasForget₂ fun G : CommGroupCat => CommMonCat.of G
-#align CommGroup.has_forget_to_CommMon CommGroupCat.hasForgetToCommMon
-#align AddCommGroup.has_forget_to_AddCommMon AddCommGroupCat.hasForgetToAddCommMon
+#align CommGroup.has_forget_to_CommMon CommGroupCat.hasForgetToCommMonCat
+#align AddCommGroup.has_forget_to_AddCommMon AddCommGroupCat.hasForgetToAddCommMonCat
+-/
 
 @[to_additive]
 instance : Coe CommGroupCat.{u} CommMonCat.{u} where coe := (forget₂ CommGroupCat CommMonCat).obj
@@ -243,6 +309,12 @@ example {R S : CommGroupCat} (i : R ⟶ S) (r : R) (h : r = 1) : i r = 1 := by s
 
 namespace AddCommGroupCat
 
+/- warning: AddCommGroup.as_hom -> AddCommGroupCat.asHom is a dubious translation:
+lean 3 declaration is
+  forall {G : AddCommGroupCat.{0}}, (coeSort.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.hasCoeToSort.{0} G) -> (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G)
+but is expected to have type
+  forall {G : AddCommGroupCat.{0}}, (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) -> (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G)
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom AddCommGroupCat.asHomₓ'. -/
 -- Note that because `ℤ : Type 0`, this forces `G : AddCommGroup.{0}`,
 -- so we write this explicitly to be clear.
 -- TODO generalize this, requiring a `ulift_instances.lean` file
@@ -252,21 +324,45 @@ def asHom {G : AddCommGroupCat.{0}} (g : G) : AddCommGroupCat.of ℤ ⟶ G :=
   zmultiplesHom G g
 #align AddCommGroup.as_hom AddCommGroupCat.asHom
 
+/- warning: AddCommGroup.as_hom_apply -> AddCommGroupCat.asHom_apply is a dubious translation:
+lean 3 declaration is
+  forall {G : AddCommGroupCat.{0}} (g : coeSort.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.hasCoeToSort.{0} G) (i : Int), Eq.{1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) (AddCommGroupCat.asHom G g) i) (SMul.smul.{0, 0} Int (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (SubNegMonoid.SMulInt.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toSubNegMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroupCat.addCommGroupInstance.{0} G)))) i g)
+but is expected to have type
+  forall {G : AddCommGroupCat.{0}} (g : CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (i : Int), Eq.{1} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (CoeFun.coe.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (fun (_x : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) => (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) -> (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G)) (AddCommGroupCat.instCoeFunHomAddCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (AddCommGroupCat.asHom G g) i) (HSMul.hSMul.{0, 0, 0} Int (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (instHSMul.{0, 0} Int (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (SubNegMonoid.SMulInt.{0} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (AddGroup.toSubNegMonoid.{0} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (AddCommGroup.toAddGroup.{0} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (AddCommGroupCat.addCommGroupInstance.{0} G))))) i g)
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom_apply AddCommGroupCat.asHom_applyₓ'. -/
 @[simp]
 theorem asHom_apply {G : AddCommGroupCat.{0}} (g : G) (i : ℤ) : (asHom g) i = i • g :=
   rfl
 #align AddCommGroup.as_hom_apply AddCommGroupCat.asHom_apply
 
+/- warning: AddCommGroup.as_hom_injective -> AddCommGroupCat.asHom_injective is a dubious translation:
+lean 3 declaration is
+  forall {G : AddCommGroupCat.{0}}, Function.Injective.{1, 1} (coeSort.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.hasCoeToSort.{0} G) (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (AddCommGroupCat.asHom G)
+but is expected to have type
+  forall {G : AddCommGroupCat.{0}}, Function.Injective.{1, 1} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (AddCommGroupCat.asHom G)
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.as_hom_injective AddCommGroupCat.asHom_injectiveₓ'. -/
 theorem asHom_injective {G : AddCommGroupCat.{0}} : Function.Injective (@asHom G) := fun h k w => by
   convert congr_arg (fun k : AddCommGroupCat.of ℤ ⟶ G => (k : ℤ → G) (1 : ℤ)) w <;> simp
 #align AddCommGroup.as_hom_injective AddCommGroupCat.asHom_injective
 
+/- warning: AddCommGroup.int_hom_ext -> AddCommGroupCat.int_hom_ext is a dubious translation:
+lean 3 declaration is
+  forall {G : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (g : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G), (Eq.{1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) f (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne)))) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) (AddCommGroupCat.of.{0} Int Int.addCommGroup)) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} (AddCommGroupCat.of.{0} Int Int.addCommGroup))))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G))))) g (OfNat.ofNat.{0} Int 1 (OfNat.mk.{0} Int 1 (One.one.{0} Int Int.hasOne))))) -> (Eq.{1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.addCommGroup) G) f g)
+but is expected to have type
+  forall {G : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (g : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G), (Eq.{1} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (CoeFun.coe.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (fun (_x : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) => (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) -> (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G)) (AddCommGroupCat.instCoeFunHomAddCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) f (OfNat.ofNat.{0} Int 1 (instOfNatInt 1))) (CoeFun.coe.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) (fun (_x : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) => (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt)) -> (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G)) (AddCommGroupCat.instCoeFunHomAddCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortAddCommGroupCatType.{0} (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) g (OfNat.ofNat.{0} Int 1 (instOfNatInt 1)))) -> (Eq.{1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) (AddCommGroupCat.of.{0} Int Int.instAddCommGroupInt) G) f g)
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.int_hom_ext AddCommGroupCat.int_hom_extₓ'. -/
 @[ext]
 theorem int_hom_ext {G : AddCommGroupCat.{0}} (f g : AddCommGroupCat.of ℤ ⟶ G)
     (w : f (1 : ℤ) = g (1 : ℤ)) : f = g :=
   AddMonoidHom.ext_int w
 #align AddCommGroup.int_hom_ext AddCommGroupCat.int_hom_ext
 
+/- warning: AddCommGroup.injective_of_mono -> AddCommGroupCat.injective_of_mono is a dubious translation:
+lean 3 declaration is
+  forall {G : AddCommGroupCat.{0}} {H : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) [_inst_1 : CategoryTheory.Mono.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0} G H f], Function.Injective.{1, 1} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (coeFn.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) (fun (_x : AddMonoidHom.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G)))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} H))))) => (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) -> (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H)) (AddMonoidHom.hasCoeToFun.{0, 0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) G) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} G)))) (AddMonoid.toAddZeroClass.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddGroup.toAddMonoid.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (AddCommGroup.toAddGroup.{0} (coeSort.{2, 2} (CategoryTheory.Bundled.{0, 0} AddCommGroup.{0}) Type (CategoryTheory.Bundled.hasCoeToSort.{0, 0} AddCommGroup.{0}) H) (CategoryTheory.Bundled.str.{0, 0} AddCommGroup.{0} H))))) f)
+but is expected to have type
+  forall {G : AddCommGroupCat.{0}} {H : AddCommGroupCat.{0}} (f : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) [_inst_1 : CategoryTheory.Mono.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0} G H f], Function.Injective.{1, 1} (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} H) (CoeFun.coe.{1, 1} (Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) (fun (_x : Quiver.Hom.{1, 1} AddCommGroupCat.{0} (CategoryTheory.CategoryStruct.toQuiver.{0, 1} AddCommGroupCat.{0} (CategoryTheory.Category.toCategoryStruct.{0, 1} AddCommGroupCat.{0} AddCommGroupCat.largeCategory.{0})) G H) => (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} G) -> (CoeSort.coe.{2, 2} AddCommGroupCat.{0} Type AddCommGroupCat.instCoeSortAddCommGroupCatType.{0} H)) (AddCommGroupCat.instCoeFunHomAddCommGroupCatToQuiverToCategoryStructLargeCategoryForAllCoeTypeInstCoeSortAddCommGroupCatType.{0} G H) f)
+Case conversion may be inaccurate. Consider using '#align AddCommGroup.injective_of_mono AddCommGroupCat.injective_of_monoₓ'. -/
 -- TODO: this argument should be generalised to the situation where
 -- the forgetful functor is representable.
 theorem injective_of_mono {G H : AddCommGroupCat.{0}} (f : G ⟶ H) [Mono f] : Function.Injective f :=
@@ -281,33 +377,51 @@ theorem injective_of_mono {G H : AddCommGroupCat.{0}} (f : G ⟶ H) [Mono f] : F
 
 end AddCommGroupCat
 
+/- warning: mul_equiv.to_Group_iso -> MulEquiv.toGroupCatIso is a dubious translation:
+lean 3 declaration is
+  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (GroupCat.group.{u1} X))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (GroupCat.group.{u1} Y)))))) -> (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y)
+but is expected to have type
+  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} X))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} Y)))))) -> (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y)
+Case conversion may be inaccurate. Consider using '#align mul_equiv.to_Group_iso MulEquiv.toGroupCatIsoₓ'. -/
 /-- Build an isomorphism in the category `Group` from a `mul_equiv` between `group`s. -/
-@[to_additive AddEquiv.toAddGroupIso, simps]
-def MulEquiv.toGroupIso {X Y : GroupCat} (e : X ≃* Y) : X ≅ Y
+@[to_additive AddEquiv.toAddGroupCatIso, simps]
+def MulEquiv.toGroupCatIso {X Y : GroupCat} (e : X ≃* Y) : X ≅ Y
     where
   Hom := e.toMonoidHom
   inv := e.symm.toMonoidHom
-#align mul_equiv.to_Group_iso MulEquiv.toGroupIso
-#align add_equiv.to_AddGroup_iso AddEquiv.toAddGroupIso
+#align mul_equiv.to_Group_iso MulEquiv.toGroupCatIso
+#align add_equiv.to_AddGroup_iso AddEquiv.toAddGroupCatIso
 
 /-- Build an isomorphism in the category `AddGroup` from an `add_equiv` between `add_group`s. -/
-add_decl_doc AddEquiv.toAddGroupIso
-
+add_decl_doc AddEquiv.toAddGroupCatIso
+
+/- warning: mul_equiv.to_CommGroup_iso -> MulEquiv.toCommGroupCatIso is a dubious translation:
+lean 3 declaration is
+  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) -> (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y)
+but is expected to have type
+  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) -> (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y)
+Case conversion may be inaccurate. Consider using '#align mul_equiv.to_CommGroup_iso MulEquiv.toCommGroupCatIsoₓ'. -/
 /-- Build an isomorphism in the category `CommGroup` from a `mul_equiv` between `comm_group`s. -/
-@[to_additive AddEquiv.toAddCommGroupIso, simps]
-def MulEquiv.toCommGroupIso {X Y : CommGroupCat} (e : X ≃* Y) : X ≅ Y
+@[to_additive AddEquiv.toAddCommGroupCatIso, simps]
+def MulEquiv.toCommGroupCatIso {X Y : CommGroupCat} (e : X ≃* Y) : X ≅ Y
     where
   Hom := e.toMonoidHom
   inv := e.symm.toMonoidHom
-#align mul_equiv.to_CommGroup_iso MulEquiv.toCommGroupIso
-#align add_equiv.to_AddCommGroup_iso AddEquiv.toAddCommGroupIso
+#align mul_equiv.to_CommGroup_iso MulEquiv.toCommGroupCatIso
+#align add_equiv.to_AddCommGroup_iso AddEquiv.toAddCommGroupCatIso
 
 /-- Build an isomorphism in the category `AddCommGroup` from a `add_equiv` between
 `add_comm_group`s. -/
-add_decl_doc AddEquiv.toAddCommGroupIso
+add_decl_doc AddEquiv.toAddCommGroupCatIso
 
 namespace CategoryTheory.Iso
 
+/- warning: category_theory.iso.Group_iso_to_mul_equiv -> CategoryTheory.Iso.groupIsoToMulEquiv is a dubious translation:
+lean 3 declaration is
+  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (GroupCat.group.{u1} X))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (GroupCat.group.{u1} Y))))))
+but is expected to have type
+  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} X))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} Y))))))
+Case conversion may be inaccurate. Consider using '#align category_theory.iso.Group_iso_to_mul_equiv CategoryTheory.Iso.groupIsoToMulEquivₓ'. -/
 /-- Build a `mul_equiv` from an isomorphism in the category `Group`. -/
 @[to_additive AddGroup_iso_to_add_equiv
       "Build an `add_equiv` from an isomorphism in the category\n`AddGroup`.",
@@ -317,6 +431,12 @@ def groupIsoToMulEquiv {X Y : GroupCat} (i : X ≅ Y) : X ≃* Y :=
 #align category_theory.iso.Group_iso_to_mul_equiv CategoryTheory.Iso.groupIsoToMulEquiv
 #align category_theory.iso.AddGroup_iso_to_add_equiv CategoryTheory.Iso.addGroupIsoToAddEquiv
 
+/- warning: category_theory.iso.CommGroup_iso_to_mul_equiv -> CategoryTheory.Iso.commGroupIsoToMulEquiv is a dubious translation:
+lean 3 declaration is
+  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y)))))))
+but is expected to have type
+  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y) -> (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y)))))))
+Case conversion may be inaccurate. Consider using '#align category_theory.iso.CommGroup_iso_to_mul_equiv CategoryTheory.Iso.commGroupIsoToMulEquivₓ'. -/
 /-- Build a `mul_equiv` from an isomorphism in the category `CommGroup`. -/
 @[to_additive AddCommGroup_iso_to_add_equiv
       "Build an `add_equiv` from an isomorphism\nin the category `AddCommGroup`.",
@@ -328,30 +448,48 @@ def commGroupIsoToMulEquiv {X Y : CommGroupCat} (i : X ≅ Y) : X ≃* Y :=
 
 end CategoryTheory.Iso
 
+/- warning: mul_equiv_iso_Group_iso -> mulEquivIsoGroupIso is a dubious translation:
+lean 3 declaration is
+  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} X) (GroupCat.group.{u1} X))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} Y) (GroupCat.group.{u1} Y)))))) (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y)
+but is expected to have type
+  forall {X : GroupCat.{u1}} {Y : GroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} X) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} X))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.instCoeSortGroupCatType.{u1} Y) (GroupCat.instGroupCoeGroupCatTypeInstCoeSortGroupCatType.{u1} Y)))))) (CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} X Y)
+Case conversion may be inaccurate. Consider using '#align mul_equiv_iso_Group_iso mulEquivIsoGroupIsoₓ'. -/
 /-- multiplicative equivalences between `group`s are the same as (isomorphic to) isomorphisms
 in `Group` -/
 @[to_additive addEquivIsoAddGroupIso
       "additive equivalences between `add_group`s are the same\nas (isomorphic to) isomorphisms in `AddGroup`"]
 def mulEquivIsoGroupIso {X Y : GroupCat.{u}} : X ≃* Y ≅ X ≅ Y
     where
-  Hom e := e.toGroupIso
+  Hom e := e.toGroupCatIso
   inv i := i.groupIsoToMulEquiv
 #align mul_equiv_iso_Group_iso mulEquivIsoGroupIso
 #align add_equiv_iso_AddGroup_iso addEquivIsoAddGroupIso
 
+/- warning: mul_equiv_iso_CommGroup_iso -> mulEquivIsoCommGroupIso is a dubious translation:
+lean 3 declaration is
+  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroup.toGroup.{u1} (coeSort.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.hasCoeToSort.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y)
+but is expected to have type
+  forall {X : CommGroupCat.{u1}} {Y : CommGroupCat.{u1}}, CategoryTheory.Iso.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} (MulEquiv.{u1, u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} X) (CommGroupCat.commGroupInstance.{u1} X)))))) (MulOneClass.toMul.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Monoid.toMulOneClass.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (DivInvMonoid.toMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (Group.toDivInvMonoid.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroup.toGroup.{u1} (CoeSort.coe.{succ (succ u1), succ (succ u1)} CommGroupCat.{u1} Type.{u1} CommGroupCat.instCoeSortCommGroupCatType.{u1} Y) (CommGroupCat.commGroupInstance.{u1} Y))))))) (CategoryTheory.Iso.{u1, succ u1} CommGroupCat.{u1} CommGroupCat.largeCategory.{u1} X Y)
+Case conversion may be inaccurate. Consider using '#align mul_equiv_iso_CommGroup_iso mulEquivIsoCommGroupIsoₓ'. -/
 /-- multiplicative equivalences between `comm_group`s are the same as (isomorphic to) isomorphisms
 in `CommGroup` -/
 @[to_additive addEquivIsoAddCommGroupIso
       "additive equivalences between `add_comm_group`s are\nthe same as (isomorphic to) isomorphisms in `AddCommGroup`"]
 def mulEquivIsoCommGroupIso {X Y : CommGroupCat.{u}} : X ≃* Y ≅ X ≅ Y
     where
-  Hom e := e.toCommGroupIso
+  Hom e := e.toCommGroupCatIso
   inv i := i.commGroupIsoToMulEquiv
 #align mul_equiv_iso_CommGroup_iso mulEquivIsoCommGroupIso
 #align add_equiv_iso_AddCommGroup_iso addEquivIsoAddCommGroupIso
 
 namespace CategoryTheory.Aut
 
+/- warning: category_theory.Aut.iso_perm -> CategoryTheory.Aut.isoPerm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}}, CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α)) (GroupCat.of.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))
+but is expected to have type
+  forall {α : Type.{u1}}, CategoryTheory.Iso.{u1, succ u1} GroupCat.{u1} GroupCat.largeCategory.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.instGroupAut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α)) (GroupCat.of.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α))
+Case conversion may be inaccurate. Consider using '#align category_theory.Aut.iso_perm CategoryTheory.Aut.isoPermₓ'. -/
 /-- The (bundled) group of automorphisms of a type is isomorphic to the (bundled) group
 of permutations. -/
 def isoPerm {α : Type u} : GroupCat.of (Aut α) ≅ GroupCat.of (Equiv.Perm α)
@@ -360,6 +498,12 @@ def isoPerm {α : Type u} : GroupCat.of (Aut α) ≅ GroupCat.of (Equiv.Perm α)
   inv := ⟨fun g => g.toIso, by tidy, by tidy⟩
 #align category_theory.Aut.iso_perm CategoryTheory.Aut.isoPerm
 
+/- warning: category_theory.Aut.mul_equiv_perm -> CategoryTheory.Aut.mulEquivPerm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}}, MulEquiv.{u1, u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (Equiv.Perm.{succ u1} α) (MulOneClass.toHasMul.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))) (Monoid.toMulOneClass.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))) (DivInvMonoid.toMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))) (Group.toDivInvMonoid.{u1} (coeSort.{succ (succ u1), succ (succ u1)} GroupCat.{u1} Type.{u1} GroupCat.hasCoeToSort.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))) (GroupCat.group.{u1} (GroupCat.of.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.group.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))))))) (MulOneClass.toHasMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))
+but is expected to have type
+  forall {α : Type.{u1}}, MulEquiv.{u1, u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (Equiv.Perm.{succ u1} α) (MulOneClass.toMul.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (Monoid.toMulOneClass.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (DivInvMonoid.toMonoid.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (Group.toDivInvMonoid.{u1} (CategoryTheory.Aut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α) (CategoryTheory.Aut.instGroupAut.{u1, succ u1} Type.{u1} CategoryTheory.types.{u1} α))))) (MulOneClass.toMul.{u1} (Equiv.Perm.{succ u1} α) (Monoid.toMulOneClass.{u1} (Equiv.Perm.{succ u1} α) (DivInvMonoid.toMonoid.{u1} (Equiv.Perm.{succ u1} α) (Group.toDivInvMonoid.{u1} (Equiv.Perm.{succ u1} α) (Equiv.Perm.permGroup.{u1} α)))))
+Case conversion may be inaccurate. Consider using '#align category_theory.Aut.mul_equiv_perm CategoryTheory.Aut.mulEquivPermₓ'. -/
 /-- The (unbundled) group of automorphisms of a type is `mul_equiv` to the (unbundled) group
 of permutations. -/
 def mulEquivPerm {α : Type u} : Aut α ≃* Equiv.Perm α :=
@@ -368,6 +512,7 @@ def mulEquivPerm {α : Type u} : Aut α ≃* Equiv.Perm α :=
 
 end CategoryTheory.Aut
 
+#print GroupCat.forget_reflects_isos /-
 @[to_additive]
 instance GroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget GroupCat.{u})
     where reflects X Y f _ := by
@@ -377,7 +522,9 @@ instance GroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget GroupCat.{
     exact ⟨(is_iso.of_iso e.to_Group_iso).1⟩
 #align Group.forget_reflects_isos GroupCat.forget_reflects_isos
 #align AddGroup.forget_reflects_isos AddGroupCat.forget_reflects_isos
+-/
 
+#print CommGroupCat.forget_reflects_isos /-
 @[to_additive]
 instance CommGroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget CommGroupCat.{u})
     where reflects X Y f _ := by
@@ -387,4 +534,5 @@ instance CommGroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget CommGr
     exact ⟨(is_iso.of_iso e.to_CommGroup_iso).1⟩
 #align CommGroup.forget_reflects_isos CommGroupCat.forget_reflects_isos
 #align AddCommGroup.forget_reflects_isos AddCommGroupCat.forget_reflects_isos
+-/

524793de

bump to nightly-2023-03-21-14

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

4b782568

Diff

@@ -112,13 +112,13 @@ theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x)
 #align AddGroup.ext AddGroupCat.ext
 
 @[to_additive has_forget_to_AddMon]
-instance hasForgetToMon : HasForget₂ GroupCat Mon :=
+instance hasForgetToMon : HasForget₂ GroupCat MonCat :=
   BundledHom.forget₂ _ _
 #align Group.has_forget_to_Mon GroupCat.hasForgetToMon
 #align AddGroup.has_forget_to_AddMon AddGroupCat.hasForgetToAddMon
 
 @[to_additive]
-instance : Coe GroupCat.{u} Mon.{u} where coe := (forget₂ GroupCat Mon).obj
+instance : Coe GroupCat.{u} MonCat.{u} where coe := (forget₂ GroupCat MonCat).obj
 
 end GroupCat
 
@@ -224,13 +224,13 @@ instance hasForgetToGroup : HasForget₂ CommGroupCat GroupCat :=
 instance : Coe CommGroupCat.{u} GroupCat.{u} where coe := (forget₂ CommGroupCat GroupCat).obj
 
 @[to_additive has_forget_to_AddCommMon]
-instance hasForgetToCommMon : HasForget₂ CommGroupCat CommMon :=
-  InducedCategory.hasForget₂ fun G : CommGroupCat => CommMon.of G
+instance hasForgetToCommMon : HasForget₂ CommGroupCat CommMonCat :=
+  InducedCategory.hasForget₂ fun G : CommGroupCat => CommMonCat.of G
 #align CommGroup.has_forget_to_CommMon CommGroupCat.hasForgetToCommMon
 #align AddCommGroup.has_forget_to_AddCommMon AddCommGroupCat.hasForgetToAddCommMon
 
 @[to_additive]
-instance : Coe CommGroupCat.{u} CommMon.{u} where coe := (forget₂ CommGroupCat CommMon).obj
+instance : Coe CommGroupCat.{u} CommMonCat.{u} where coe := (forget₂ CommGroupCat CommMonCat).obj
 
 end CommGroupCat

524793de

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

524793de

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

@@ -485,7 +485,7 @@ set_option linter.uppercaseLean3 false in
 end CategoryTheory.Aut
 
 @[to_additive]
-instance GroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget GroupCat.{u}) where
+instance GroupCat.forget_reflects_isos : (forget GroupCat.{u}).ReflectsIsomorphisms where
   reflects {X Y} f _ := by
     let i := asIso ((forget GroupCat).map f)
     let e : X ≃* Y := { i.toEquiv with map_mul' := map_mul _ }
@@ -496,7 +496,7 @@ set_option linter.uppercaseLean3 false in
 #align AddGroup.forget_reflects_isos AddGroupCat.forget_reflects_isos
 
 @[to_additive]
-instance CommGroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget CommGroupCat.{u}) where
+instance CommGroupCat.forget_reflects_isos : (forget CommGroupCat.{u}).ReflectsIsomorphisms where
   reflects {X Y} f _ := by
     let i := asIso ((forget CommGroupCat).map f)
     let e : X ≃* Y := { i.toEquiv with map_mul' := map_mul _}

524793de

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

Mostly automatic, with a few manual corrections.

11516514

Diff

@@ -440,12 +440,12 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align add_equiv_iso_AddGroup_iso addEquivIsoAddGroupIso
 
-/-- "additive equivalences between `add_group`s are the same
-as (isomorphic to) isomorphisms in `AddGroup` -/
+/-- Additive equivalences between `AddGroup`s are the same
+as (isomorphic to) isomorphisms in `AddGroupCat`. -/
 add_decl_doc addEquivIsoAddGroupIso
 
-/-- multiplicative equivalences between `comm_group`s are the same as (isomorphic to) isomorphisms
-in `CommGroup` -/
+/-- Multiplicative equivalences between `CommGroup`s are the same as (isomorphic to) isomorphisms
+in `CommGroupCat`. -/
 @[to_additive]
 def mulEquivIsoCommGroupIso {X Y : CommGroupCat.{u}} : X ≃* Y ≅ X ≅ Y where
   hom e := e.toCommGroupCatIso
@@ -455,8 +455,8 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align add_equiv_iso_AddCommGroup_iso addEquivIsoAddCommGroupIso
 
-/-- additive equivalences between `AddCommGroup`s are
-the same as (isomorphic to) isomorphisms in `AddCommGroup` -/
+/-- Additive equivalences between `AddCommGroup`s are
+the same as (isomorphic to) isomorphisms in `AddCommGroupCat`. -/
 add_decl_doc addEquivIsoAddCommGroupIso
 
 namespace CategoryTheory.Aut
@@ -475,7 +475,7 @@ def isoPerm {α : Type u} : GroupCat.of (Aut α) ≅ GroupCat.of (Equiv.Perm α)
 set_option linter.uppercaseLean3 false in
 #align category_theory.Aut.iso_perm CategoryTheory.Aut.isoPerm
 
-/-- The (unbundled) group of automorphisms of a type is `mul_equiv` to the (unbundled) group
+/-- The (unbundled) group of automorphisms of a type is `MulEquiv` to the (unbundled) group
 of permutations. -/
 def mulEquivPerm {α : Type u} : Aut α ≃* Equiv.Perm α :=
   isoPerm.groupIsoToMulEquiv

524793de

chore: remove more autoImplicit (#11336)

... or reduce its scope (the full removal is not as obvious).

59f72a90

Diff

@@ -19,9 +19,6 @@ We introduce the bundled categories:
 along with the relevant forgetful functors between them, and to the bundled monoid categories.
 -/
 
-set_option autoImplicit true
-
-
 universe u v
 
 open CategoryTheory
@@ -80,7 +77,7 @@ lemma coe_comp {X Y Z : GroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X →
 lemma comp_def {X Y Z : GroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f := rfl
 
 -- porting note (#10756): added lemma
-@[simp] lemma forget_map (f : X ⟶ Y) : (forget GroupCat).map f = (f : X → Y) := rfl
+@[simp] lemma forget_map {X Y : GroupCat} (f : X ⟶ Y) : (forget GroupCat).map f = (f : X → Y) := rfl
 
 @[to_additive (attr := ext)]
 lemma ext {X Y : GroupCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g :=

524793de

chore: classify added lemma porting notes (#10791)

Classifies by adding number (#10756) to porting notes claiming added lemma.

10e929a2

Diff

@@ -68,18 +68,18 @@ instance {X Y : GroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
 instance instFunLike (X Y : GroupCat) : FunLike (X ⟶ Y) X Y :=
   show FunLike (X →* Y) X Y from inferInstance
 
--- porting note: added
+-- porting note (#10756): added lemma
 @[to_additive (attr := simp)]
 lemma coe_id {X : GroupCat} : (𝟙 X : X → X) = id := rfl
 
--- porting note: added
+-- porting note (#10756): added lemma
 @[to_additive (attr := simp)]
 lemma coe_comp {X Y Z : GroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f := rfl
 
 @[to_additive]
 lemma comp_def {X Y Z : GroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f := rfl
 
--- porting note: added
+-- porting note (#10756): added lemma
 @[simp] lemma forget_map (f : X ⟶ Y) : (forget GroupCat).map f = (f : X → Y) := rfl
 
 @[to_additive (attr := ext)]
@@ -217,18 +217,18 @@ instance {X Y : CommGroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
 instance instFunLike (X Y : CommGroupCat) : FunLike (X ⟶ Y) X Y :=
   show FunLike (X →* Y) X Y from inferInstance
 
--- porting note: added
+-- porting note (#10756): added lemma
 @[to_additive (attr := simp)]
 lemma coe_id {X : CommGroupCat} : (𝟙 X : X → X) = id := rfl
 
--- porting note: added
+-- porting note (#10756): added lemma
 @[to_additive (attr := simp)]
 lemma coe_comp {X Y Z : CommGroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f := rfl
 
 @[to_additive]
 lemma comp_def {X Y Z : CommGroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f := rfl
 
--- porting note: added
+-- porting note (#10756): added lemma
 @[to_additive (attr := simp)]
 lemma forget_map {X Y : CommGroupCat} (f : X ⟶ Y) :
     (forget CommGroupCat).map f = (f : X → Y) :=

524793de

chore: add issue number to instance was not necessary porting notes (#10671)

Adds issue number (#10670) to porting notes claiming instance was not necessary.

dcfd3b10

Diff

@@ -59,7 +59,7 @@ instance : CoeSort GroupCat (Type*) where
 @[to_additive]
 instance (X : GroupCat) : Group X := X.str
 
--- porting note: this instance was not necessary in mathlib
+-- porting note (#10670): this instance was not necessary in mathlib
 @[to_additive]
 instance {X Y : GroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
   coe (f : X →* Y) := f
@@ -121,7 +121,7 @@ set_option linter.uppercaseLean3 false in
 @[to_additive]
 instance : Coe GroupCat.{u} MonCat.{u} where coe := (forget₂ GroupCat MonCat).obj
 
--- porting note: this instance was not necessary in mathlib
+-- porting note (#10670): this instance was not necessary in mathlib
 @[to_additive]
 instance (G H : GroupCat) : One (G ⟶ H) := (inferInstance : One (MonoidHom G H))
 
@@ -208,7 +208,7 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.add_comm_group_instance AddCommGroupCat.addCommGroupInstance
 
--- porting note: this instance was not necessary in mathlib
+-- porting note (#10670): this instance was not necessary in mathlib
 @[to_additive]
 instance {X Y : CommGroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
   coe (f : X →* Y) := f
@@ -295,7 +295,7 @@ set_option linter.uppercaseLean3 false in
 @[to_additive]
 instance : Coe CommGroupCat.{u} CommMonCat.{u} where coe := (forget₂ CommGroupCat CommMonCat).obj
 
--- porting note: this instance was not necessary in mathlib
+-- porting note (#10670): this instance was not necessary in mathlib
 @[to_additive]
 instance (G H : CommGroupCat) : One (G ⟶ H) := (inferInstance : One (MonoidHom G H))

524793de

chore: tidy various files (#10453)

678a9b1b

Diff

@@ -65,7 +65,7 @@ instance {X Y : GroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
   coe (f : X →* Y) := f
 
 @[to_additive]
-instance FunLike_instance (X Y : GroupCat) : FunLike (X ⟶ Y) X Y :=
+instance instFunLike (X Y : GroupCat) : FunLike (X ⟶ Y) X Y :=
   show FunLike (X →* Y) X Y from inferInstance
 
 -- porting note: added
@@ -214,7 +214,7 @@ instance {X Y : CommGroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
   coe (f : X →* Y) := f
 
 @[to_additive]
-instance FunLike_instance (X Y : CommGroupCat) : FunLike (X ⟶ Y) X Y :=
+instance instFunLike (X Y : CommGroupCat) : FunLike (X ⟶ Y) X Y :=
   show FunLike (X →* Y) X Y from inferInstance
 
 -- porting note: added

524793de

chore: move to v4.6.0-rc1, merging adaptations from bump/v4.6.0 (#10176)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Joachim Breitner <mail@joachim-breitner.de>

490d2d48

Diff

@@ -491,7 +491,7 @@ end CategoryTheory.Aut
 instance GroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget GroupCat.{u}) where
   reflects {X Y} f _ := by
     let i := asIso ((forget GroupCat).map f)
-    let e : X ≃* Y := { i.toEquiv with map_mul' := by aesop }
+    let e : X ≃* Y := { i.toEquiv with map_mul' := map_mul _ }
     exact IsIso.of_iso e.toGroupCatIso
 set_option linter.uppercaseLean3 false in
 #align Group.forget_reflects_isos GroupCat.forget_reflects_isos
@@ -502,7 +502,7 @@ set_option linter.uppercaseLean3 false in
 instance CommGroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget CommGroupCat.{u}) where
   reflects {X Y} f _ := by
     let i := asIso ((forget CommGroupCat).map f)
-    let e : X ≃* Y := { i.toEquiv with map_mul' := by aesop }
+    let e : X ≃* Y := { i.toEquiv with map_mul' := map_mul _}
     exact IsIso.of_iso e.toCommGroupCatIso
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget_reflects_isos CommGroupCat.forget_reflects_isos

524793de

refactor: Delete Algebra.GroupPower.Lemmas (#9411)

Algebra.GroupPower.Lemmas used to be a big bag of lemmas that made it there on the criterion that they needed "more imports". This was completely untrue, as all lemmas could be moved to earlier files in PRs:

There are several reasons for this:

Necessary lemmas have been moved to earlier files since lemmas were dumped in Algebra.GroupPower.Lemmas
In the Lean 3 → Lean 4 transition, Std acquired basic Int and Nat lemmas which let us shortcircuit the part of the algebraic order hierarchy on which the corresponding general lemmas rest
Some proofs were overpowered
Some earlier files were tangled and I have untangled them

This PR finishes the job by moving the last few lemmas out of Algebra.GroupPower.Lemmas, which is therefore deleted.

6eb43dc3

Diff

@@ -4,7 +4,6 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
 import Mathlib.Algebra.Category.MonCat.Basic
-import Mathlib.Algebra.GroupPower.Lemmas
 import Mathlib.CategoryTheory.Endomorphism
 
 #align_import algebra.category.Group.basic from "leanprover-community/mathlib"@"524793de15bc4c52ee32d254e7d7867c7176b3af"

524793de

refactor(*): abbreviation for non-dependent FunLike (#9833)

This follows up from #9785, which renamed FunLike to DFunLike, by introducing a new abbreviation FunLike F α β := DFunLike F α (fun _ => β), to make the non-dependent use of FunLike easier.

I searched for the pattern DFunLike.*fun and DFunLike.*λ in all files to replace expressions of the form DFunLike F α (fun _ => β) with FunLike F α β. I did this everywhere except for extends clauses for two reasons: it would conflict with #8386, and more importantly extends must directly refer to a structure with no unfolding of defs or abbrevs.

54792e9e

Diff

@@ -66,8 +66,8 @@ instance {X Y : GroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
   coe (f : X →* Y) := f
 
 @[to_additive]
-instance DFunLike_instance (X Y : GroupCat) : DFunLike (X ⟶ Y) X (fun _ => Y) :=
-  show DFunLike (X →* Y) X (fun _ => Y) from inferInstance
+instance FunLike_instance (X Y : GroupCat) : FunLike (X ⟶ Y) X Y :=
+  show FunLike (X →* Y) X Y from inferInstance
 
 -- porting note: added
 @[to_additive (attr := simp)]
@@ -215,8 +215,8 @@ instance {X Y : CommGroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
   coe (f : X →* Y) := f
 
 @[to_additive]
-instance DFunLike_instance (X Y : CommGroupCat) : DFunLike (X ⟶ Y) X (fun _ => Y) :=
-  show DFunLike (X →* Y) X (fun _ => Y) from inferInstance
+instance FunLike_instance (X Y : CommGroupCat) : FunLike (X ⟶ Y) X Y :=
+  show FunLike (X →* Y) X Y from inferInstance
 
 -- porting note: added
 @[to_additive (attr := simp)]

524793de

chore: Move order lemmas about zpow (#9805)

These lemmas can be proved earlier.

Part of #9411

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

91ac6909

Diff

@@ -4,6 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
 -/
 import Mathlib.Algebra.Category.MonCat.Basic
+import Mathlib.Algebra.GroupPower.Lemmas
 import Mathlib.CategoryTheory.Endomorphism
 
 #align_import algebra.category.Group.basic from "leanprover-community/mathlib"@"524793de15bc4c52ee32d254e7d7867c7176b3af"

524793de

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

@@ -65,8 +65,8 @@ instance {X Y : GroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
   coe (f : X →* Y) := f
 
 @[to_additive]
-instance FunLike_instance (X Y : GroupCat) : FunLike (X ⟶ Y) X (fun _ => Y) :=
-  show FunLike (X →* Y) X (fun _ => Y) from inferInstance
+instance DFunLike_instance (X Y : GroupCat) : DFunLike (X ⟶ Y) X (fun _ => Y) :=
+  show DFunLike (X →* Y) X (fun _ => Y) from inferInstance
 
 -- porting note: added
 @[to_additive (attr := simp)]
@@ -214,8 +214,8 @@ instance {X Y : CommGroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
   coe (f : X →* Y) := f
 
 @[to_additive]
-instance FunLike_instance (X Y : CommGroupCat) : FunLike (X ⟶ Y) X (fun _ => Y) :=
-  show FunLike (X →* Y) X (fun _ => Y) from inferInstance
+instance DFunLike_instance (X Y : CommGroupCat) : DFunLike (X ⟶ Y) X (fun _ => Y) :=
+  show DFunLike (X →* Y) X (fun _ => Y) from inferInstance
 
 -- porting note: added
 @[to_additive (attr := simp)]

524793de

fix: resolve some nolint simpNF commands (#7929)

220023c1

Diff

@@ -145,7 +145,7 @@ set_option linter.uppercaseLean3 false in
 /-- Typecheck an `AddMonoidHom` as a morphism in `AddGroup`. -/
 add_decl_doc AddGroupCat.ofHom
 
-@[to_additive (attr := simp)]
+@[to_additive]
 theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) :
     (ofHom f) x = f x :=
   rfl
@@ -154,9 +154,6 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddGroup.of_hom_apply AddGroupCat.ofHom_apply
 
--- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
-attribute [nolint simpNF] AddGroupCat.ofHom_apply GroupCat.ofHom_apply
-
 @[to_additive]
 instance ofUnique (G : Type*) [Group G] [i : Unique G] : Unique (GroupCat.of G) := i
 set_option linter.uppercaseLean3 false in

524793de

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

This reverts commit f3695eb2.

ab56fa28

Diff

@@ -154,6 +154,9 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddGroup.of_hom_apply AddGroupCat.ofHom_apply
 
+-- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
+attribute [nolint simpNF] AddGroupCat.ofHom_apply GroupCat.ofHom_apply
+
 @[to_additive]
 instance ofUnique (G : Type*) [Group G] [i : Unique G] : Unique (GroupCat.of G) := i
 set_option linter.uppercaseLean3 false in

524793de

chore: revert #7703 (#7710)

This reverts commit 26eb2b0a.

f3695eb2

Diff

@@ -154,9 +154,6 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddGroup.of_hom_apply AddGroupCat.ofHom_apply
 
--- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
-attribute [nolint simpNF] AddGroupCat.ofHom_apply GroupCat.ofHom_apply
-
 @[to_additive]
 instance ofUnique (G : Type*) [Group G] [i : Unique G] : Unique (GroupCat.of G) := i
 set_option linter.uppercaseLean3 false in

524793de

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

@@ -154,6 +154,9 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddGroup.of_hom_apply AddGroupCat.ofHom_apply
 
+-- These lemmas have always been bad (#7657), but lean4#2644 made `simp` start noticing
+attribute [nolint simpNF] AddGroupCat.ofHom_apply GroupCat.ofHom_apply
+
 @[to_additive]
 instance ofUnique (G : Type*) [Group G] [i : Unique G] : Unique (GroupCat.of G) := i
 set_option linter.uppercaseLean3 false in

524793de

chore: replace anonymous morphism constructors with named fields (#7015)

This makes it easier to refactor the order or inheritance structure of morphisms without having to change all of the anonymous constructors.

This is far from exhaustive.

2bffb702

Diff

@@ -491,9 +491,7 @@ end CategoryTheory.Aut
 instance GroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget GroupCat.{u}) where
   reflects {X Y} f _ := by
     let i := asIso ((forget GroupCat).map f)
-    let e : X ≃* Y := MulEquiv.mk i.toEquiv
-      -- Porting note: this would ideally be `by aesop`, as in `MonCat.forget_reflects_isos`
-      (MonoidHom.map_mul (show MonoidHom X Y from f))
+    let e : X ≃* Y := { i.toEquiv with map_mul' := by aesop }
     exact IsIso.of_iso e.toGroupCatIso
 set_option linter.uppercaseLean3 false in
 #align Group.forget_reflects_isos GroupCat.forget_reflects_isos
@@ -504,9 +502,7 @@ set_option linter.uppercaseLean3 false in
 instance CommGroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget CommGroupCat.{u}) where
   reflects {X Y} f _ := by
     let i := asIso ((forget CommGroupCat).map f)
-    let e : X ≃* Y := MulEquiv.mk i.toEquiv
-      -- Porting note: this would ideally be `by aesop`, as in `MonCat.forget_reflects_isos`
-      (MonoidHom.map_mul (show MonoidHom X Y from f))
+    let e : X ≃* Y := { i.toEquiv with map_mul' := by aesop }
     exact IsIso.of_iso e.toCommGroupCatIso
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget_reflects_isos CommGroupCat.forget_reflects_isos

524793de

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

@@ -512,3 +512,23 @@ set_option linter.uppercaseLean3 false in
 #align CommGroup.forget_reflects_isos CommGroupCat.forget_reflects_isos
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.forget_reflects_isos AddCommGroupCat.forget_reflects_isos
+
+-- note: in the following definitions, there is a problem with `@[to_additive]`
+-- as the `Category` instance is not found on the additive variant
+-- this variant is then renamed with a `Aux` suffix
+
+/-- An alias for `GroupCat.{max u v}`, to deal around unification issues. -/
+@[to_additive (attr := nolint checkUnivs) GroupCatMaxAux
+  "An alias for `AddGroupCat.{max u v}`, to deal around unification issues."]
+abbrev GroupCatMax.{u1, u2} := GroupCat.{max u1 u2}
+/-- An alias for `AddGroupCat.{max u v}`, to deal around unification issues. -/
+@[nolint checkUnivs]
+abbrev AddGroupCatMax.{u1, u2} := AddGroupCat.{max u1 u2}
+
+/-- An alias for `CommGroupCat.{max u v}`, to deal around unification issues. -/
+@[to_additive (attr := nolint checkUnivs) AddCommGroupCatMaxAux
+  "An alias for `AddCommGroupCat.{max u v}`, to deal around unification issues."]
+abbrev CommGroupCatMax.{u1, u2} := CommGroupCat.{max u1 u2}
+/-- An alias for `AddCommGroupCat.{max u v}`, to deal around unification issues. -/
+@[nolint checkUnivs]
+abbrev AddCommGroupCatMax.{u1, u2} := AddCommGroupCat.{max u1 u2}

524793de

fix: disable autoImplicit globally (#6528)

Autoimplicits are highly controversial and also defeat the performance-improving work in #6474.

The intent of this PR is to make autoImplicit opt-in on a per-file basis, by disabling it in the lakefile and enabling it again with set_option autoImplicit true in the few files that rely on it.

That also keeps this PR small, as opposed to attempting to "fix" files to not need it any more.

I claim that many of the uses of autoImplicit in these files are accidental; situations such as:

Assuming variables are in scope, but pasting the lemma in the wrong section
Pasting in a lemma from a scratch file without checking to see if the variable names are consistent with the rest of the file
Making a copy-paste error between lemmas and forgetting to add an explicit arguments.

Having set_option autoImplicit false as the default prevents these types of mistake being made in the 90% of files where autoImplicits are not used at all, and causes them to be caught by CI during review.

I think there were various points during the port where we encouraged porters to delete the universes u v lines; I think having autoparams for universe variables only would cover a lot of the cases we actually use them, while avoiding any real shortcomings.

A Zulip poll (after combining overlapping votes accordingly) was in favor of this change with 5:5:18 as the no:dontcare:yes vote ratio.

While this PR was being reviewed, a handful of files gained some more likely-accidental autoImplicits. In these places, set_option autoImplicit true has been placed locally within a section, rather than at the top of the file.

0c24f831

Diff

@@ -19,6 +19,8 @@ We introduce the bundled categories:
 along with the relevant forgetful functors between them, and to the bundled monoid categories.
 -/
 
+set_option autoImplicit true
+
 
 universe u v

524793de

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

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

This has nice performance benefits.

32de3f67

Diff

@@ -40,7 +40,7 @@ namespace GroupCat
 
 @[to_additive]
 instance : BundledHom.ParentProjection
-  (fun {α : Type _} (h : Group α) => h.toDivInvMonoid.toMonoid) := ⟨⟩
+  (fun {α : Type*} (h : Group α) => h.toDivInvMonoid.toMonoid) := ⟨⟩
 
 deriving instance LargeCategory for GroupCat
 attribute [to_additive] instGroupCatLargeCategory
@@ -51,7 +51,7 @@ instance concreteCategory : ConcreteCategory GroupCat := by
   infer_instance
 
 @[to_additive]
-instance : CoeSort GroupCat (Type _) where
+instance : CoeSort GroupCat (Type*) where
   coe X := X.α
 
 @[to_additive]
@@ -153,7 +153,7 @@ set_option linter.uppercaseLean3 false in
 #align AddGroup.of_hom_apply AddGroupCat.ofHom_apply
 
 @[to_additive]
-instance ofUnique (G : Type _) [Group G] [i : Unique G] : Unique (GroupCat.of G) := i
+instance ofUnique (G : Type*) [Group G] [i : Unique G] : Unique (GroupCat.of G) := i
 set_option linter.uppercaseLean3 false in
 #align Group.of_unique GroupCat.ofUnique
 set_option linter.uppercaseLean3 false in
@@ -196,7 +196,7 @@ instance concreteCategory : ConcreteCategory CommGroupCat := by
   infer_instance
 
 @[to_additive]
-instance : CoeSort CommGroupCat (Type _) where
+instance : CoeSort CommGroupCat (Type*) where
   coe X := X.α
 
 @[to_additive]
@@ -264,7 +264,7 @@ set_option linter.uppercaseLean3 false in
 #align AddCommGroup.coe_of AddCommGroupCat.coe_of
 
 @[to_additive]
-instance ofUnique (G : Type _) [CommGroup G] [i : Unique G] : Unique (CommGroupCat.of G) :=
+instance ofUnique (G : Type*) [CommGroup G] [i : Unique G] : Unique (CommGroupCat.of G) :=
   i
 set_option linter.uppercaseLean3 false in
 #align CommGroup.of_unique CommGroupCat.ofUnique

524793de

feat(Algebra/Category/GroupCat/Abelian): prove AddCommGroupCat is AB5 (#5597)

This work was done during the 2023 Copenhagen masterclass on formalisation of condensed mathematics. Numerous participants contributed.

Co-authored-by: Moritz Firsching <moritz.firsching@gmail.com> Co-authored-by: Nikolas Kuhn <nikolaskuhn@gmx.de> Co-authored-by: Amelia Livingston <101damnations@github.com>

Co-authored-by: Markus Himmel <markus@himmel-villmar.de> Co-authored-by: Moritz Firsching <firsching@google.com> Co-authored-by: adamtopaz <github@adamtopaz.com> Co-authored-by: nick-kuhn <nikolaskuhn@gmx.de>

4773f928

Diff

@@ -74,6 +74,9 @@ lemma coe_id {X : GroupCat} : (𝟙 X : X → X) = id := rfl
 @[to_additive (attr := simp)]
 lemma coe_comp {X Y Z : GroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f := rfl
 
+@[to_additive]
+lemma comp_def {X Y Z : GroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f := rfl
+
 -- porting note: added
 @[simp] lemma forget_map (f : X ⟶ Y) : (forget GroupCat).map f = (f : X → Y) := rfl
 
@@ -220,6 +223,9 @@ lemma coe_id {X : CommGroupCat} : (𝟙 X : X → X) = id := rfl
 @[to_additive (attr := simp)]
 lemma coe_comp {X Y Z : CommGroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f := rfl
 
+@[to_additive]
+lemma comp_def {X Y Z : CommGroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : f ≫ g = g.comp f := rfl
+
 -- porting note: added
 @[to_additive (attr := simp)]
 lemma forget_map {X Y : CommGroupCat} (f : X ⟶ Y) :

524793de

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2018 Johan Commelin. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johan Commelin
-
-! This file was ported from Lean 3 source module algebra.category.Group.basic
-! leanprover-community/mathlib commit 524793de15bc4c52ee32d254e7d7867c7176b3af
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Category.MonCat.Basic
 import Mathlib.CategoryTheory.Endomorphism
 
+#align_import algebra.category.Group.basic from "leanprover-community/mathlib"@"524793de15bc4c52ee32d254e7d7867c7176b3af"
+
 /-!
 # Category instances for Group, AddGroup, CommGroup, and AddCommGroup.

524793de

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

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

dbae2f17

Diff

@@ -363,9 +363,7 @@ set_option linter.uppercaseLean3 false in
 -- the forgetful functor is representable.
 theorem injective_of_mono {G H : AddCommGroupCat.{0}} (f : G ⟶ H) [Mono f] : Function.Injective f :=
   fun g₁ g₂ h => by
-  have t0 : asHom g₁ ≫ f = asHom g₂ ≫ f := by
-    apply int_hom_ext
-    simpa using h
+  have t0 : asHom g₁ ≫ f = asHom g₂ ≫ f := by aesop_cat
   have t1 : asHom g₁ = asHom g₂ := (cancel_mono _).1 t0
   apply asHom_injective t1
 set_option linter.uppercaseLean3 false in

524793de

chore: fix grammar 1/3 (#5001)

All of these are doc fixes

d8caa37d

Diff

@@ -140,7 +140,7 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddGroup.of_hom AddGroupCat.ofHom
 
-/-- Typecheck a `AddMonoidHom` as a morphism in `AddGroup`. -/
+/-- Typecheck an `AddMonoidHom` as a morphism in `AddGroup`. -/
 add_decl_doc AddGroupCat.ofHom
 
 @[to_additive (attr := simp)]
@@ -311,7 +311,7 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.of_hom AddCommGroupCat.ofHom
 
-/-- Typecheck a `AddMonoidHom` as a morphism in `AddCommGroup`. -/
+/-- Typecheck an `AddMonoidHom` as a morphism in `AddCommGroup`. -/
 add_decl_doc AddCommGroupCat.ofHom
 
 @[to_additive (attr := simp)]
@@ -397,7 +397,7 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align add_equiv.to_AddCommGroup_iso AddEquiv.toAddCommGroupCatIso
 
-/-- Build an isomorphism in the category `AddCommGroupCat` from a `AddEquiv`
+/-- Build an isomorphism in the category `AddCommGroupCat` from an `AddEquiv`
 between `AddCommGroup`s. -/
 add_decl_doc AddEquiv.toAddCommGroupCatIso

524793de

chore: formatting issues (#4947)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

5068808d

Diff

@@ -67,7 +67,7 @@ instance {X Y : GroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
 
 @[to_additive]
 instance FunLike_instance (X Y : GroupCat) : FunLike (X ⟶ Y) X (fun _ => Y) :=
-show FunLike (X →* Y) X (fun _ => Y) from inferInstance
+  show FunLike (X →* Y) X (fun _ => Y) from inferInstance
 
 -- porting note: added
 @[to_additive (attr := simp)]
@@ -213,7 +213,7 @@ instance {X Y : CommGroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
 
 @[to_additive]
 instance FunLike_instance (X Y : CommGroupCat) : FunLike (X ⟶ Y) X (fun _ => Y) :=
-show FunLike (X →* Y) X (fun _ => Y) from inferInstance
+  show FunLike (X →* Y) X (fun _ => Y) from inferInstance
 
 -- porting note: added
 @[to_additive (attr := simp)]

524793de

chore: fix typos (#4518)

I ran codespell Mathlib and got tired halfway through the suggestions.

92beef58

Diff

@@ -424,7 +424,7 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align category_theory.iso.AddCommGroup_iso_to_add_equiv CategoryTheory.Iso.addCommGroupIsoToAddEquiv
 
-/-- Build an `AddEquiv` from an isomorphism\nin the category `AddCommGroup`. -/
+/-- Build an `AddEquiv` from an isomorphism in the category `AddCommGroup`. -/
 add_decl_doc addCommGroupIsoToAddEquiv
 
 end CategoryTheory.Iso

524793de

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

a85cea98

Diff

@@ -65,6 +65,10 @@ instance (X : GroupCat) : Group X := X.str
 instance {X Y : GroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
   coe (f : X →* Y) := f
 
+@[to_additive]
+instance FunLike_instance (X Y : GroupCat) : FunLike (X ⟶ Y) X (fun _ => Y) :=
+show FunLike (X →* Y) X (fun _ => Y) from inferInstance
+
 -- porting note: added
 @[to_additive (attr := simp)]
 lemma coe_id {X : GroupCat} : (𝟙 X : X → X) = id := rfl
@@ -207,6 +211,10 @@ set_option linter.uppercaseLean3 false in
 instance {X Y : CommGroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
   coe (f : X →* Y) := f
 
+@[to_additive]
+instance FunLike_instance (X Y : CommGroupCat) : FunLike (X ⟶ Y) X (fun _ => Y) :=
+show FunLike (X →* Y) X (fun _ => Y) from inferInstance
+
 -- porting note: added
 @[to_additive (attr := simp)]
 lemma coe_id {X : CommGroupCat} : (𝟙 X : X → X) = id := rfl

524793de

chore: refactor of concrete categories (#3900)

I think the ports

https://github.com/leanprover-community/mathlib4/pull/2902 (MonCat)
https://github.com/leanprover-community/mathlib4/pull/3036 (GroupCat)
https://github.com/leanprover-community/mathlib4/pull/3260 (ModuleCat)

didn't quite get things right, and also have some variation between them. This PR tries to straighten things out.

Major changes:

Have the coercion to type be via X.\a, and put attribute @[coe] on this.

Make sure the coercion from morphisms to functions means that simp lemmas about the underlying bundled morphisms apply directly.

This means we drop lemmas like

lemma Hom.map_mul {X Y : MonCat} (f : X ⟶ Y) (x y : X) : ((forget MonCat).map f) (x * y) = f x * f y

But at the expense of adding lemmas like

lemma coe_comp {X Y Z : MonCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f := rfl

Overall I'm pretty happy, and it allows me to unstick the long stuck https://github.com/leanprover-community/mathlib4/pull/3105.

This is not everything I want to do to refactor these files, but once I was satisfied that I can move forward with RingCat, I want to get this merged so we can unblock porting progress. I'll promise to come back to this soon! :-)

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

237c33e0

Diff

@@ -45,20 +45,40 @@ namespace GroupCat
 instance : BundledHom.ParentProjection
   (fun {α : Type _} (h : Group α) => h.toDivInvMonoid.toMonoid) := ⟨⟩
 
-instance largeCategory : LargeCategory GroupCat := by
-  dsimp only [GroupCat]
-  infer_instance
+deriving instance LargeCategory for GroupCat
+attribute [to_additive] instGroupCatLargeCategory
 
+@[to_additive]
 instance concreteCategory : ConcreteCategory GroupCat := by
   dsimp only [GroupCat]
   infer_instance
 
-attribute [to_additive] GroupCat.largeCategory GroupCat.concreteCategory
+@[to_additive]
+instance : CoeSort GroupCat (Type _) where
+  coe X := X.α
 
 @[to_additive]
-instance : CoeSort GroupCat (Type _) := by
-  dsimp only [GroupCat]
-  infer_instance
+instance (X : GroupCat) : Group X := X.str
+
+-- porting note: this instance was not necessary in mathlib
+@[to_additive]
+instance {X Y : GroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
+  coe (f : X →* Y) := f
+
+-- porting note: added
+@[to_additive (attr := simp)]
+lemma coe_id {X : GroupCat} : (𝟙 X : X → X) = id := rfl
+
+-- porting note: added
+@[to_additive (attr := simp)]
+lemma coe_comp {X Y Z : GroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f := rfl
+
+-- porting note: added
+@[simp] lemma forget_map (f : X ⟶ Y) : (forget GroupCat).map f = (f : X → Y) := rfl
+
+@[to_additive (attr := ext)]
+lemma ext {X Y : GroupCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g :=
+  MonoidHom.ext w
 
 /-- Construct a bundled `Group` from the underlying type and typeclass. -/
 @[to_additive]
@@ -72,53 +92,7 @@ set_option linter.uppercaseLean3 false in
 /-- Construct a bundled `AddGroup` from the underlying type and typeclass. -/
 add_decl_doc AddGroupCat.of
 
-/-- Typecheck a `MonoidHom` as a morphism in `GroupCat`. -/
-@[to_additive]
-def ofHom {X Y : Type u} [Group X] [Group Y] (f : X →* Y) : of X ⟶ of Y :=
-  f
-set_option linter.uppercaseLean3 false in
-#align Group.of_hom GroupCat.ofHom
-set_option linter.uppercaseLean3 false in
-#align AddGroup.of_hom AddGroupCat.ofHom
-
-/-- Typecheck a `AddMonoidHom` as a morphism in `AddGroup`. -/
-add_decl_doc AddGroupCat.ofHom
-
--- porting note: this instance was not necessary in mathlib
-@[to_additive]
-instance {X Y : GroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y :=
-  ConcreteCategory.hasCoeToFun
-
--- porting note: this was added to ease automation
-@[to_additive (attr := simp)]
-lemma id_apply {X : GroupCat} (x : X) :
-  (𝟙 X) x = x := rfl
-
--- porting note: this was added to ease automation
 @[to_additive (attr := simp)]
-lemma comp_apply {X Y Z : GroupCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) :
-  (f ≫ g) x = g (f x) := rfl
-
-@[to_additive (attr := simp)]
-theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) :
-    (ofHom f) x = f x :=
-  rfl
-set_option linter.uppercaseLean3 false in
-#align Group.of_hom_apply GroupCat.ofHom_apply
-set_option linter.uppercaseLean3 false in
-#align AddGroup.of_hom_apply AddGroupCat.ofHom_apply
-
-@[to_additive]
-instance (G : GroupCat) : Group G :=
-  G.str
-
--- porting note: added to make `one_apply` work
-@[to_additive]
-instance (G : GroupCat) : Group ((forget GroupCat).obj G) :=
-  G.str
-
--- porting note: simp attribute was removed to please the linter
-@[to_additive]
 theorem coe_of (R : Type u) [Group R] : ↑(GroupCat.of R) = R :=
   rfl
 set_option linter.uppercaseLean3 false in
@@ -130,66 +104,60 @@ set_option linter.uppercaseLean3 false in
 instance : Inhabited GroupCat :=
   ⟨GroupCat.of PUnit⟩
 
-@[to_additive]
-instance ofUnique (G : Type _) [Group G] [i : Unique G] : Unique (GroupCat.of G) :=
-  i
+@[to_additive hasForgetToAddMonCat]
+instance hasForgetToMonCat : HasForget₂ GroupCat MonCat :=
+  BundledHom.forget₂ _ _
 set_option linter.uppercaseLean3 false in
-#align Group.of_unique GroupCat.ofUnique
+#align Group.has_forget_to_Mon GroupCat.hasForgetToMonCat
 set_option linter.uppercaseLean3 false in
-#align AddGroup.of_unique AddGroupCat.ofUnique
+#align AddGroup.has_forget_to_AddMon AddGroupCat.hasForgetToAddMonCat
+
+@[to_additive]
+instance : Coe GroupCat.{u} MonCat.{u} where coe := (forget₂ GroupCat MonCat).obj
 
 -- porting note: this instance was not necessary in mathlib
 @[to_additive]
 instance (G H : GroupCat) : One (G ⟶ H) := (inferInstance : One (MonoidHom G H))
 
 @[to_additive (attr := simp)]
-theorem one_apply (G H : GroupCat) (g : G) : ((forget GroupCat).map (1 : G ⟶ H)) g = 1 :=
+theorem one_apply (G H : GroupCat) (g : G) : ((1 : G ⟶ H) : G → H) g = 1 :=
   rfl
 set_option linter.uppercaseLean3 false in
 #align Group.one_apply GroupCat.one_apply
 set_option linter.uppercaseLean3 false in
 #align AddGroup.zero_apply AddGroupCat.zero_apply
 
-@[to_additive (attr := ext)]
-theorem ext (G H : GroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ (x : ↑G), f₁ x = f₂ x) : f₁ = f₂ :=
-  ConcreteCategory.hom_ext _ _ w
+/-- Typecheck a `MonoidHom` as a morphism in `GroupCat`. -/
+@[to_additive]
+def ofHom {X Y : Type u} [Group X] [Group Y] (f : X →* Y) : of X ⟶ of Y :=
+  f
 set_option linter.uppercaseLean3 false in
-#align Group.ext GroupCat.ext
+#align Group.of_hom GroupCat.ofHom
 set_option linter.uppercaseLean3 false in
-#align AddGroup.ext AddGroupCat.ext
+#align AddGroup.of_hom AddGroupCat.ofHom
 
-@[to_additive hasForgetToAddMonCat]
-instance hasForgetToMonCat : HasForget₂ GroupCat MonCat :=
-  BundledHom.forget₂ _ _
+/-- Typecheck a `AddMonoidHom` as a morphism in `AddGroup`. -/
+add_decl_doc AddGroupCat.ofHom
+
+@[to_additive (attr := simp)]
+theorem ofHom_apply {X Y : Type _} [Group X] [Group Y] (f : X →* Y) (x : X) :
+    (ofHom f) x = f x :=
+  rfl
 set_option linter.uppercaseLean3 false in
-#align Group.has_forget_to_Mon GroupCat.hasForgetToMonCat
+#align Group.of_hom_apply GroupCat.ofHom_apply
 set_option linter.uppercaseLean3 false in
-#align AddGroup.has_forget_to_AddMon AddGroupCat.hasForgetToAddMonCat
+#align AddGroup.of_hom_apply AddGroupCat.ofHom_apply
 
 @[to_additive]
-instance : Coe GroupCat.{u} MonCat.{u} where coe := (forget₂ GroupCat MonCat).obj
+instance ofUnique (G : Type _) [Group G] [i : Unique G] : Unique (GroupCat.of G) := i
+set_option linter.uppercaseLean3 false in
+#align Group.of_unique GroupCat.ofUnique
+set_option linter.uppercaseLean3 false in
+#align AddGroup.of_unique AddGroupCat.ofUnique
 
--- porting note: this was added to ease the port
-/-- the morphism in `GroupCat` associated to a `MonoidHom` -/
+-- We verify that simp lemmas apply when coercing morphisms to functions.
 @[to_additive]
-def Hom.mk {X Y : GroupCat} (f : X →* Y) : X ⟶ Y := f
-
-/-- the morphism in `AddGroupCat` associated to a `AddMonoidHom` -/
-add_decl_doc AddGroupCat.Hom.mk
-
-@[to_additive (attr := simp)]
-lemma Hom.mk_apply {X Y : GroupCat} (f : X →* Y) (x : X) :
-  (Hom.mk f) x = f x := rfl
-
--- porting note: added to ease automation
-@[to_additive (attr := simp)]
-lemma Hom.map_mul {X Y : GroupCat} (f : X ⟶ Y) (x y : X) : f (x * y) = f x * f y := by
-  apply MonoidHom.map_mul (show MonoidHom X Y from f)
-
--- porting note: added to ease automation
-@[to_additive (attr := simp)]
-lemma Hom.map_one {X Y : GroupCat} (f : X ⟶ Y) : f (1 : X) = 1 := by
-  apply MonoidHom.map_one (show MonoidHom X Y from f)
+example {R S : GroupCat} (i : R ⟶ S) (r : R) (h : r = 1) : i r = 1 := by simp [h]
 
 end GroupCat
 
@@ -206,89 +174,76 @@ set_option linter.uppercaseLean3 false in
 add_decl_doc AddCommGroupCat
 
 /-- `Ab` is an abbreviation for `AddCommGroup`, for the sake of mathematicians' sanity. -/
-abbrev Ab :=
-  AddCommGroupCat
+abbrev Ab := AddCommGroupCat
 set_option linter.uppercaseLean3 false in
 #align Ab Ab
 
 namespace CommGroupCat
 
 @[to_additive]
-instance : BundledHom.ParentProjection @CommGroup.toGroup :=
-  ⟨⟩
+instance : BundledHom.ParentProjection @CommGroup.toGroup := ⟨⟩
 
-instance largeCategory : LargeCategory CommGroupCat := by
-  dsimp only [CommGroupCat]
-  infer_instance
-
-instance concreteCategory : ConcreteCategory CommGroupCat := by
-  dsimp only [CommGroupCat]
-  infer_instance
-
-attribute [to_additive] CommGroupCat.largeCategory CommGroupCat.concreteCategory
+deriving instance LargeCategory for CommGroupCat
+attribute [to_additive] instCommGroupCatLargeCategory
 
 @[to_additive]
-instance : CoeSort CommGroupCat (Type _) := by
+instance concreteCategory : ConcreteCategory CommGroupCat := by
   dsimp only [CommGroupCat]
   infer_instance
 
-/-- Construct a bundled `CommGroup` from the underlying type and typeclass. -/
 @[to_additive]
-def of (G : Type u) [CommGroup G] : CommGroupCat :=
-  Bundled.of G
-set_option linter.uppercaseLean3 false in
-#align CommGroup.of CommGroupCat.of
-set_option linter.uppercaseLean3 false in
-#align AddCommGroup.of AddCommGroupCat.of
-
-/-- Construct a bundled `AddCommGroup` from the underlying type and typeclass. -/
-add_decl_doc AddCommGroupCat.of
+instance : CoeSort CommGroupCat (Type _) where
+  coe X := X.α
 
-/-- Typecheck a `MonoidHom` as a morphism in `CommGroup`. -/
 @[to_additive]
-def ofHom {X Y : Type u} [CommGroup X] [CommGroup Y] (f : X →* Y) : of X ⟶ of Y :=
-  f
+instance commGroupInstance (X : CommGroupCat) : CommGroup X := X.str
 set_option linter.uppercaseLean3 false in
-#align CommGroup.of_hom CommGroupCat.ofHom
+#align CommGroup.comm_group_instance CommGroupCat.commGroupInstance
 set_option linter.uppercaseLean3 false in
-#align AddCommGroup.of_hom AddCommGroupCat.ofHom
-
-/-- Typecheck a `AddMonoidHom` as a morphism in `AddCommGroup`. -/
-add_decl_doc AddCommGroupCat.ofHom
+#align AddCommGroup.add_comm_group_instance AddCommGroupCat.addCommGroupInstance
 
 -- porting note: this instance was not necessary in mathlib
 @[to_additive]
-instance {X Y : CommGroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y :=
-  ConcreteCategory.hasCoeToFun
+instance {X Y : CommGroupCat} : CoeFun (X ⟶ Y) fun _ => X → Y where
+  coe (f : X →* Y) := f
 
--- porting note: added to ease automation
+-- porting note: added
 @[to_additive (attr := simp)]
-lemma id_apply {X : CommGroupCat} (x : X) :
-  (𝟙 X) x = x := rfl
+lemma coe_id {X : CommGroupCat} : (𝟙 X : X → X) = id := rfl
 
--- porting note: added to ease automation
+-- porting note: added
 @[to_additive (attr := simp)]
-lemma comp_apply {X Y Z : CommGroupCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : X) :
-  (f ≫ g) x = g (f x) := by apply CategoryTheory.comp_apply
+lemma coe_comp {X Y Z : CommGroupCat} {f : X ⟶ Y} {g : Y ⟶ Z} : (f ≫ g : X → Z) = g ∘ f := rfl
 
+-- porting note: added
 @[to_additive (attr := simp)]
-theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
-    (ofHom f) x = f x :=
+lemma forget_map {X Y : CommGroupCat} (f : X ⟶ Y) :
+    (forget CommGroupCat).map f = (f : X → Y) :=
   rfl
-set_option linter.uppercaseLean3 false in
-#align CommGroup.of_hom_apply CommGroupCat.ofHom_apply
-set_option linter.uppercaseLean3 false in
-#align AddCommGroup.of_hom_apply AddCommGroupCat.ofHom_apply
 
+@[to_additive (attr := ext)]
+lemma ext {X Y : CommGroupCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g :=
+  MonoidHom.ext w
+
+/-- Construct a bundled `CommGroup` from the underlying type and typeclass. -/
 @[to_additive]
-instance commGroupInstance (G : CommGroupCat) : CommGroup G :=
-  G.str
+def of (G : Type u) [CommGroup G] : CommGroupCat :=
+  Bundled.of G
 set_option linter.uppercaseLean3 false in
-#align CommGroup.comm_group_instance CommGroupCat.commGroupInstance
+#align CommGroup.of CommGroupCat.of
 set_option linter.uppercaseLean3 false in
-#align AddCommGroup.add_comm_group_instance AddCommGroupCat.addCommGroupInstance
+#align AddCommGroup.of AddCommGroupCat.of
+
+/-- Construct a bundled `AddCommGroup` from the underlying type and typeclass. -/
+add_decl_doc AddCommGroupCat.of
+
+@[to_additive]
+instance : Inhabited CommGroupCat :=
+  ⟨CommGroupCat.of PUnit⟩
 
--- porting note: simp attribute was removed to please the linter
+-- Porting note: removed `@[simp]` here, as it makes it harder to tell when to apply
+-- bundled or unbundled lemmas.
+-- (This change seems dangerous!)
 @[to_additive]
 theorem coe_of (R : Type u) [CommGroup R] : (CommGroupCat.of R : Type u) = R :=
   rfl
@@ -297,10 +252,6 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.coe_of AddCommGroupCat.coe_of
 
-@[to_additive]
-instance : Inhabited CommGroupCat :=
-  ⟨CommGroupCat.of PUnit⟩
-
 @[to_additive]
 instance ofUnique (G : Type _) [CommGroup G] [i : Unique G] : Unique (CommGroupCat.of G) :=
   i
@@ -309,26 +260,6 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddCommGroup.of_unique AddCommGroupCat.ofUnique
 
--- porting note: this instance was not necessary in mathlib
-@[to_additive]
-instance (G H : CommGroupCat) : One (G ⟶ H) := (inferInstance : One (MonoidHom G H))
-
-@[to_additive (attr := simp)]
-theorem one_apply (G H : CommGroupCat) (g : G) : (1 : G ⟶ H) g = 1 :=
-  rfl
-set_option linter.uppercaseLean3 false in
-#align CommGroup.one_apply CommGroupCat.one_apply
-set_option linter.uppercaseLean3 false in
-#align AddCommGroup.zero_apply AddCommGroupCat.zero_apply
-
-@[to_additive (attr := ext)]
-theorem ext (G H : CommGroupCat) (f₁ f₂ : G ⟶ H) (w : ∀ x, f₁ x = f₂ x) : f₁ = f₂ :=
-  ConcreteCategory.hom_ext _ _ w
-set_option linter.uppercaseLean3 false in
-#align CommGroup.ext CommGroupCat.ext
-set_option linter.uppercaseLean3 false in
-#align AddCommGroup.ext AddCommGroupCat.ext
-
 @[to_additive]
 instance hasForgetToGroup : HasForget₂ CommGroupCat GroupCat :=
   BundledHom.forget₂ _ _
@@ -351,33 +282,40 @@ set_option linter.uppercaseLean3 false in
 @[to_additive]
 instance : Coe CommGroupCat.{u} CommMonCat.{u} where coe := (forget₂ CommGroupCat CommMonCat).obj
 
--- porting note: this was added to ease the port
-/-- the morphism in `CommGroupCat` associated to a `MonoidHom` -/
+-- porting note: this instance was not necessary in mathlib
 @[to_additive]
-def Hom.mk {X Y : CommGroupCat} (f : X →* Y) : X ⟶ Y := f
-
-/-- the morphism in `AddCommGroupCat` associated to a `AddMonoidHom` -/
-add_decl_doc AddCommGroupCat.Hom.mk
+instance (G H : CommGroupCat) : One (G ⟶ H) := (inferInstance : One (MonoidHom G H))
 
 @[to_additive (attr := simp)]
-lemma Hom.mk_apply {X Y : CommGroupCat} (f : X →* Y) (x : X) :
-  (Hom.mk f) x = f x := rfl
+theorem one_apply (G H : CommGroupCat) (g : G) : ((1 : G ⟶ H) : G → H) g = 1 :=
+  rfl
+set_option linter.uppercaseLean3 false in
+#align CommGroup.one_apply CommGroupCat.one_apply
+set_option linter.uppercaseLean3 false in
+#align AddCommGroup.zero_apply AddCommGroupCat.zero_apply
 
--- porting note: added to ease automation
-@[to_additive (attr := simp)]
-lemma Hom.map_mul {X Y : CommGroupCat} (f : X ⟶ Y) (x y : X) : f (x * y) = f x * f y := by
-  apply MonoidHom.map_mul (show MonoidHom X Y from f)
+/-- Typecheck a `MonoidHom` as a morphism in `CommGroup`. -/
+@[to_additive]
+def ofHom {X Y : Type u} [CommGroup X] [CommGroup Y] (f : X →* Y) : of X ⟶ of Y :=
+  f
+set_option linter.uppercaseLean3 false in
+#align CommGroup.of_hom CommGroupCat.ofHom
+set_option linter.uppercaseLean3 false in
+#align AddCommGroup.of_hom AddCommGroupCat.ofHom
+
+/-- Typecheck a `AddMonoidHom` as a morphism in `AddCommGroup`. -/
+add_decl_doc AddCommGroupCat.ofHom
 
--- porting note: added to ease automation
 @[to_additive (attr := simp)]
-lemma Hom.map_one {X Y : CommGroupCat} (f : X ⟶ Y) : f (1 : X) = 1 := by
-  apply MonoidHom.map_one (show MonoidHom X Y from f)
+theorem ofHom_apply {X Y : Type _} [CommGroup X] [CommGroup Y] (f : X →* Y) (x : X) :
+    (ofHom f) x = f x :=
+  rfl
+set_option linter.uppercaseLean3 false in
+#align CommGroup.of_hom_apply CommGroupCat.ofHom_apply
+set_option linter.uppercaseLean3 false in
+#align AddCommGroup.of_hom_apply AddCommGroupCat.ofHom_apply
 
--- Porting note: is this still relevant?
--- This example verifies an improvement possible in Lean 3.8.
--- Before that, to have `MonoidHom.map_map` usable by `simp` here,
--- we had to mark all the concrete category `CoeSort` instances reducible.
--- Now, it just works.
+-- We verify that simp lemmas apply when coercing morphisms to functions.
 @[to_additive]
 example {R S : CommGroupCat} (i : R ⟶ S) (r : R) (h : r = 1) : i r = 1 := by simp [h]
 
@@ -430,8 +368,8 @@ end AddCommGroupCat
 /-- Build an isomorphism in the category `GroupCat` from a `MulEquiv` between `Group`s. -/
 @[to_additive (attr := simps)]
 def MulEquiv.toGroupCatIso {X Y : GroupCat} (e : X ≃* Y) : X ≅ Y where
-  hom := GroupCat.Hom.mk e.toMonoidHom
-  inv := GroupCat.Hom.mk e.symm.toMonoidHom
+  hom := e.toMonoidHom
+  inv := e.symm.toMonoidHom
 set_option linter.uppercaseLean3 false in
 #align mul_equiv.to_Group_iso MulEquiv.toGroupCatIso
 set_option linter.uppercaseLean3 false in
@@ -444,8 +382,8 @@ add_decl_doc AddEquiv.toAddGroupCatIso
 between `CommGroup`s. -/
 @[to_additive (attr := simps)]
 def MulEquiv.toCommGroupCatIso {X Y : CommGroupCat} (e : X ≃* Y) : X ≅ Y where
-  hom := CommGroupCat.Hom.mk e.toMonoidHom
-  inv := CommGroupCat.Hom.mk e.symm.toMonoidHom
+  hom := e.toMonoidHom
+  inv := e.symm.toMonoidHom
 set_option linter.uppercaseLean3 false in
 #align mul_equiv.to_CommGroup_iso MulEquiv.toCommGroupCatIso
 set_option linter.uppercaseLean3 false in
@@ -518,11 +456,11 @@ namespace CategoryTheory.Aut
 /-- The (bundled) group of automorphisms of a type is isomorphic to the (bundled) group
 of permutations. -/
 def isoPerm {α : Type u} : GroupCat.of (Aut α) ≅ GroupCat.of (Equiv.Perm α) where
-  hom := GroupCat.Hom.mk
+  hom :=
     { toFun := fun g => g.toEquiv
       map_one' := by aesop
       map_mul' := by aesop }
-  inv := GroupCat.Hom.mk
+  inv :=
     { toFun := fun g => g.toIso
       map_one' := by aesop
       map_mul' := by aesop }
@@ -542,7 +480,9 @@ end CategoryTheory.Aut
 instance GroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget GroupCat.{u}) where
   reflects {X Y} f _ := by
     let i := asIso ((forget GroupCat).map f)
-    let e : X ≃* Y := MulEquiv.mk i.toEquiv (by apply GroupCat.Hom.map_mul)
+    let e : X ≃* Y := MulEquiv.mk i.toEquiv
+      -- Porting note: this would ideally be `by aesop`, as in `MonCat.forget_reflects_isos`
+      (MonoidHom.map_mul (show MonoidHom X Y from f))
     exact IsIso.of_iso e.toGroupCatIso
 set_option linter.uppercaseLean3 false in
 #align Group.forget_reflects_isos GroupCat.forget_reflects_isos
@@ -553,7 +493,9 @@ set_option linter.uppercaseLean3 false in
 instance CommGroupCat.forget_reflects_isos : ReflectsIsomorphisms (forget CommGroupCat.{u}) where
   reflects {X Y} f _ := by
     let i := asIso ((forget CommGroupCat).map f)
-    let e : X ≃* Y := MulEquiv.mk i.toEquiv (by apply CommGroupCat.Hom.map_mul)
+    let e : X ≃* Y := MulEquiv.mk i.toEquiv
+      -- Porting note: this would ideally be `by aesop`, as in `MonCat.forget_reflects_isos`
+      (MonoidHom.map_mul (show MonoidHom X Y from f))
     exact IsIso.of_iso e.toCommGroupCatIso
 set_option linter.uppercaseLean3 false in
 #align CommGroup.forget_reflects_isos CommGroupCat.forget_reflects_isos

524793de

chore: tidy various files (#3358)

5cedfb5e

Diff

@@ -12,7 +12,7 @@ import Mathlib.Algebra.Category.MonCat.Basic
 import Mathlib.CategoryTheory.Endomorphism
 
 /-!
-# Category instances for group, add_group, comm_group, and add_comm_group.
+# Category instances for Group, AddGroup, CommGroup, and AddCommGroup.
 
 We introduce the bundled categories:
 * `GroupCat`
@@ -81,7 +81,7 @@ set_option linter.uppercaseLean3 false in
 set_option linter.uppercaseLean3 false in
 #align AddGroup.of_hom AddGroupCat.ofHom
 
-/-- Typecheck a `add_monoid_hom` as a morphism in `AddGroup`. -/
+/-- Typecheck a `AddMonoidHom` as a morphism in `AddGroup`. -/
 add_decl_doc AddGroupCat.ofHom
 
 -- porting note: this instance was not necessary in mathlib
@@ -373,9 +373,10 @@ lemma Hom.map_mul {X Y : CommGroupCat} (f : X ⟶ Y) (x y : X) : f (x * y) = f x
 lemma Hom.map_one {X Y : CommGroupCat} (f : X ⟶ Y) : f (1 : X) = 1 := by
   apply MonoidHom.map_one (show MonoidHom X Y from f)
 
+-- Porting note: is this still relevant?
 -- This example verifies an improvement possible in Lean 3.8.
--- Before that, to have `monoid_hom.map_map` usable by `simp` here,
--- we had to mark all the concrete category `has_coe_to_sort` instances reducible.
+-- Before that, to have `MonoidHom.map_map` usable by `simp` here,
+-- we had to mark all the concrete category `CoeSort` instances reducible.
 -- Now, it just works.
 @[to_additive]
 example {R S : CommGroupCat} (i : R ⟶ S) (r : R) (h : r = 1) : i r = 1 := by simp [h]
@@ -386,7 +387,7 @@ namespace AddCommGroupCat
 
 -- Note that because `ℤ : Type 0`, this forces `G : AddCommGroup.{0}`,
 -- so we write this explicitly to be clear.
--- TODO generalize this, requiring a `ulift_instances.lean` file
+-- TODO generalize this, requiring a `ULiftInstances.lean` file
 /-- Any element of an abelian group gives a unique morphism from `ℤ` sending
 `1` to that element. -/
 def asHom {G : AddCommGroupCat.{0}} (g : G) : AddCommGroupCat.of ℤ ⟶ G :=
@@ -442,8 +443,7 @@ add_decl_doc AddEquiv.toAddGroupCatIso
 /-- Build an isomorphism in the category `CommGroupCat` from a `MulEquiv`
 between `CommGroup`s. -/
 @[to_additive (attr := simps)]
-def MulEquiv.toCommGroupCatIso {X Y : CommGroupCat} (e : X ≃* Y) : X ≅ Y
-    where
+def MulEquiv.toCommGroupCatIso {X Y : CommGroupCat} (e : X ≃* Y) : X ≅ Y where
   hom := CommGroupCat.Hom.mk e.toMonoidHom
   inv := CommGroupCat.Hom.mk e.symm.toMonoidHom
 set_option linter.uppercaseLean3 false in
@@ -501,8 +501,7 @@ add_decl_doc addEquivIsoAddGroupIso
 /-- multiplicative equivalences between `comm_group`s are the same as (isomorphic to) isomorphisms
 in `CommGroup` -/
 @[to_additive]
-def mulEquivIsoCommGroupIso {X Y : CommGroupCat.{u}} : X ≃* Y ≅ X ≅ Y
-    where
+def mulEquivIsoCommGroupIso {X Y : CommGroupCat.{u}} : X ≃* Y ≅ X ≅ Y where
   hom e := e.toCommGroupCatIso
   inv i := i.commGroupIsoToMulEquiv
 set_option linter.uppercaseLean3 false in

524793de

feat: port Algebra.Category.Group.Basic (#3036)

b1d3f2ca

`algebra.category.Group.basic` ⟷ `Mathlib.Algebra.Category.GroupCat.Basic`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 3 + 229

algebra.category.Group.basic ⟷ Mathlib.Algebra.Category.GroupCat.Basic

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 3 + 229

`algebra.category.Group.basic` ⟷ `Mathlib.Algebra.Category.GroupCat.Basic`