File: Mathlib/Algebra/Category/Grp/Limits.lean

full_name: AddGrp.addGroupObj
code: @[to_additive]
instance groupObj (j) : Group ((F ⋙ forget Grp).obj j) 
goal: AddGroup ((F ⋙ CategoryTheory.forget AddGrp).obj j)

full_name: Grp.groupObj
code: @[to_additive]
instance groupObj (j) : Group ((F ⋙ forget Grp).obj j) 
goal: Group ((F ⋙ CategoryTheory.forget Grp).obj j)

full_name: AddGrp.sectionsAddSubgroup
code: /-- The flat sections of a functor into `Grp` form a subgroup of all sections.
-/
@[to_additive
  "The flat sections of a functor into `AddGrp` form an additive subgroup of all sections."]
def sectionsSubgroup : Subgroup (∀ j, F.obj j) 
goal: AddSubgroup ((j : J) → ↑(F.obj j))

full_name: Grp.sectionsSubgroup
code: /-- The flat sections of a functor into `Grp` form a subgroup of all sections.
-/
@[to_additive
  "The flat sections of a functor into `AddGrp` form an additive subgroup of all sections."]
def sectionsSubgroup : Subgroup (∀ j, F.obj j) 
goal: Subgroup ((j : J) → ↑(F.obj j))

full_name: AddGrp.sectionsAddGroup
code: @[to_additive]
instance sectionsGroup : Group (F ⋙ forget Grp.{u}).sections 
goal: AddGroup ↑(F ⋙ CategoryTheory.forget AddGrp).sections

full_name: Grp.sectionsGroup
code: @[to_additive]
instance sectionsGroup : Group (F ⋙ forget Grp.{u}).sections 
goal: Group ↑(F ⋙ CategoryTheory.forget Grp).sections

full_name: AddGrp.sectionsπAddMonoidHom
code: /-- The projection from `Functor.sections` to a factor as a `MonoidHom`. -/
@[to_additive "The projection from `Functor.sections` to a factor as an `AddMonoidHom`."]
def sectionsπMonoidHom (j : J) : (F ⋙ forget Grp.{u}).sections →* F.obj j 
goal: ↑(F ⋙ CategoryTheory.forget AddGrp).sections →+ ↑(F.obj j)

full_name: Grp.sectionsπMonoidHom
code: /-- The projection from `Functor.sections` to a factor as a `MonoidHom`. -/
@[to_additive "The projection from `Functor.sections` to a factor as an `AddMonoidHom`."]
def sectionsπMonoidHom (j : J) : (F ⋙ forget Grp.{u}).sections →* F.obj j 
goal: ↑(F ⋙ CategoryTheory.forget Grp).sections →* ↑(F.obj j)

full_name: Grp.limitGroup
code: @[to_additive]
noncomputable instance limitGroup :
    Group (Types.Small.limitCone.{v, u} (F ⋙ forget Grp.{u})).pt 
goal: Group (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget Grp)).pt

full_name: AddGrp.limitAddGroup
code: @[to_additive]
noncomputable instance limitGroup :
    Group (Types.Small.limitCone.{v, u} (F ⋙ forget Grp.{u})).pt 
goal: AddGroup (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget AddGrp)).pt

full_name: Grp.instSmallElemForallObjCompMonCatForget₂ForgetSections
code: @[to_additive]
instance : Small.{u} (Functor.sections ((F ⋙ forget₂ Grp MonCat) ⋙ forget MonCat)) 
goal: Small.{u, max u v} ↑((F ⋙ CategoryTheory.forget₂ Grp MonCat) ⋙ CategoryTheory.forget MonCat).sections

full_name: AddGrp.instSmallElemForallObjCompMonCatForget₂ForgetSections
code: @[to_additive]
instance : Small.{u} (Functor.sections ((F ⋙ forget₂ Grp MonCat) ⋙ forget MonCat)) 
goal: Small.{u, max u v} ↑((F ⋙ CategoryTheory.forget₂ AddGrp AddMonCat) ⋙ CategoryTheory.forget AddMonCat).sections

full_name: AddGrp.Forget₂.createsLimit
code: /-- We show that the forgetful functor `Grp ⥤ MonCat` creates limits.

All we need to do is notice that the limit point has a `Group` instance available, and then reuse
the existing limit. -/
@[to_additive "We show that the forgetful functor `AddGrp ⥤ AddMonCat` creates limits.

All we need to do is notice that the limit point has an `AddGroup` instance available, and then
reuse the existing limit."]
noncomputable instance Forget₂.createsLimit :
    CreatesLimit F (forget₂ Grp.{u} MonCat.{u}) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ AddGrp AddMonCat)

full_name: Grp.Forget₂.createsLimit
code: /-- We show that the forgetful functor `Grp ⥤ MonCat` creates limits.

All we need to do is notice that the limit point has a `Group` instance available, and then reuse
the existing limit. -/
@[to_additive "We show that the forgetful functor `AddGrp ⥤ AddMonCat` creates limits.

All we need to do is notice that the limit point has an `AddGroup` instance available, and then
reuse the existing limit."]
noncomputable instance Forget₂.createsLimit :
    CreatesLimit F (forget₂ Grp.{u} MonCat.{u}) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ Grp MonCat)

full_name: AddGrp.limitCone
code: /-- A choice of limit cone for a functor into `Grp`.
(Generally, you'll just want to use `limit F`.)
-/
@[to_additive "A choice of limit cone for a functor into `Grp`.
  (Generally, you'll just want to use `limit F`.)"]
noncomputable def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: Grp.limitCone
code: /-- A choice of limit cone for a functor into `Grp`.
(Generally, you'll just want to use `limit F`.)
-/
@[to_additive "A choice of limit cone for a functor into `Grp`.
  (Generally, you'll just want to use `limit F`.)"]
noncomputable def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: Grp.limitConeIsLimit
code: /-- The chosen cone is a limit cone.
(Generally, you'll just want to use `limit.cone F`.)
-/
@[to_additive "The chosen cone is a limit cone.
  (Generally, you'll just want to use `limit.cone F`.)"]
noncomputable def limitConeIsLimit : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (Grp.limitCone F)

full_name: AddGrp.limitConeIsLimit
code: /-- The chosen cone is a limit cone.
(Generally, you'll just want to use `limit.cone F`.)
-/
@[to_additive "The chosen cone is a limit cone.
  (Generally, you'll just want to use `limit.cone F`.)"]
noncomputable def limitConeIsLimit : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (AddGrp.limitCone F)

full_name: AddGrp.hasLimit
code: /-- If `(F ⋙ forget Grp).sections` is `u`-small, `F` has a limit. -/
@[to_additive "If `(F ⋙ forget AddGrp).sections` is `u`-small, `F` has a limit."]
instance hasLimit : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: Grp.hasLimit
code: /-- If `(F ⋙ forget Grp).sections` is `u`-small, `F` has a limit. -/
@[to_additive "If `(F ⋙ forget AddGrp).sections` is `u`-small, `F` has a limit."]
instance hasLimit : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: AddGrp.hasLimit_iff_small_sections
code: /-- A functor `F : J ⥤ Grp.{u}` has a limit iff `(F ⋙ forget Grp).sections` is
`u`-small.  -/
@[to_additive "A functor `F : J ⥤ AddGrp.{u}` has a limit iff
`(F ⋙ forget AddGrp).sections` is `u`-small."]
lemma hasLimit_iff_small_sections :
    HasLimit F ↔ Small.{u} (F ⋙ forget Grp).sections 
goal: CategoryTheory.Limits.HasLimit F ↔ Small.{u, max u v} ↑(F ⋙ CategoryTheory.forget AddGrp).sections

full_name: Grp.hasLimit_iff_small_sections
code: /-- A functor `F : J ⥤ Grp.{u}` has a limit iff `(F ⋙ forget Grp).sections` is
`u`-small.  -/
@[to_additive "A functor `F : J ⥤ AddGrp.{u}` has a limit iff
`(F ⋙ forget AddGrp).sections` is `u`-small."]
lemma hasLimit_iff_small_sections :
    HasLimit F ↔ Small.{u} (F ⋙ forget Grp).sections 
goal: CategoryTheory.Limits.HasLimit F ↔ Small.{u, max u v} ↑(F ⋙ CategoryTheory.forget Grp).sections

full_name: Grp.hasLimitsOfShape
code: /-- If `J` is `u`-small, `Grp.{u}` has limits of shape `J`. -/
@[to_additive "If `J` is `u`-small, `AddGrp.{u}` has limits of shape `J`."]
instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J Grp.{u} 
goal: CategoryTheory.Limits.HasLimitsOfShape J Grp

full_name: AddGrp.hasLimitsOfShape
code: /-- If `J` is `u`-small, `Grp.{u}` has limits of shape `J`. -/
@[to_additive "If `J` is `u`-small, `AddGrp.{u}` has limits of shape `J`."]
instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J Grp.{u} 
goal: CategoryTheory.Limits.HasLimitsOfShape J AddGrp

full_name: AddGrp.hasLimitsOfSize
code: /-- The category of groups has all limits. -/
@[to_additive "The category of additive groups has all limits.",
  to_additive_relevant_arg 2]
instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} Grp.{u} 
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} AddGrp

full_name: Grp.hasLimitsOfSize
code: /-- The category of groups has all limits. -/
@[to_additive "The category of additive groups has all limits.",
  to_additive_relevant_arg 2]
instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} Grp.{u} 
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} Grp

full_name: Grp.hasLimits
code: @[to_additive]
instance hasLimits : HasLimits Grp.{u} 
goal: CategoryTheory.Limits.HasLimits Grp

full_name: AddGrp.hasLimits
code: @[to_additive]
instance hasLimits : HasLimits Grp.{u} 
goal: CategoryTheory.Limits.HasLimits AddGrp

full_name: Grp.forget₂MonPreservesLimitsOfSize
code: /-- The forgetful functor from groups to monoids preserves all limits.

This means the underlying monoid of a limit can be computed as a limit in the category of monoids.
-/
@[to_additive AddGrp.forget₂AddMonPreservesLimitsOfSize
  "The forgetful functor from additive groups to additive monoids preserves all limits.

  This means the underlying additive monoid of a limit can be computed as a limit in the category of
  additive monoids.",
  to_additive_relevant_arg 2]
noncomputable instance forget₂MonPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ Grp.{u} MonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ Grp MonCat)

full_name: AddGrp.forget₂AddMonPreservesLimitsOfSize
code: /-- The forgetful functor from groups to monoids preserves all limits.

This means the underlying monoid of a limit can be computed as a limit in the category of monoids.
-/
@[to_additive AddGrp.forget₂AddMonPreservesLimitsOfSize
  "The forgetful functor from additive groups to additive monoids preserves all limits.

  This means the underlying additive monoid of a limit can be computed as a limit in the category of
  additive monoids.",
  to_additive_relevant_arg 2]
noncomputable instance forget₂MonPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ Grp.{u} MonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ AddGrp AddMonCat)

full_name: AddGrp.forget₂MonPreservesLimits
code: @[to_additive]
noncomputable instance forget₂MonPreservesLimits :
  PreservesLimits (forget₂ Grp.{u} MonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ AddGrp AddMonCat)

full_name: Grp.forget₂MonPreservesLimits
code: @[to_additive]
noncomputable instance forget₂MonPreservesLimits :
  PreservesLimits (forget₂ Grp.{u} MonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ Grp MonCat)

full_name: AddGrp.forgetPreservesLimitsOfShape
code: /-- If `J` is `u`-small, the forgetful functor from `Grp.{u}` preserves limits of shape `J`. -/
@[to_additive "If `J` is `u`-small, the forgetful functor from `AddGrp.{u}`\n
preserves limits of shape `J`."]
noncomputable instance forgetPreservesLimitsOfShape [Small.{u} J] :
    PreservesLimitsOfShape J (forget Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget AddGrp)

full_name: Grp.forgetPreservesLimitsOfShape
code: /-- If `J` is `u`-small, the forgetful functor from `Grp.{u}` preserves limits of shape `J`. -/
@[to_additive "If `J` is `u`-small, the forgetful functor from `AddGrp.{u}`\n
preserves limits of shape `J`."]
noncomputable instance forgetPreservesLimitsOfShape [Small.{u} J] :
    PreservesLimitsOfShape J (forget Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget Grp)

full_name: AddGrp.forgetPreservesLimitsOfSize
code: /-- The forgetful functor from groups to types preserves all limits.

This means the underlying type of a limit can be computed as a limit in the category of types. -/
@[to_additive
  "The forgetful functor from additive groups to types preserves all limits.

  This means the underlying type of a limit can be computed as a limit in the category of types.",
  to_additive_relevant_arg 2]
noncomputable instance forgetPreservesLimitsOfSize :
    PreservesLimitsOfSize.{w, v} (forget Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget AddGrp)

full_name: Grp.forgetPreservesLimitsOfSize
code: /-- The forgetful functor from groups to types preserves all limits.

This means the underlying type of a limit can be computed as a limit in the category of types. -/
@[to_additive
  "The forgetful functor from additive groups to types preserves all limits.

  This means the underlying type of a limit can be computed as a limit in the category of types.",
  to_additive_relevant_arg 2]
noncomputable instance forgetPreservesLimitsOfSize :
    PreservesLimitsOfSize.{w, v} (forget Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget Grp)

full_name: AddGrp.forgetPreservesLimits
code: @[to_additive]
noncomputable instance forgetPreservesLimits : PreservesLimits (forget Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget AddGrp)

full_name: Grp.forgetPreservesLimits
code: @[to_additive]
noncomputable instance forgetPreservesLimits : PreservesLimits (forget Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget Grp)

full_name: CommGrp.commGroupObj
code: @[to_additive]
instance commGroupObj (j) : CommGroup ((F ⋙ forget CommGrp).obj j) 
goal: CommGroup ((F ⋙ CategoryTheory.forget CommGrp).obj j)

full_name: AddCommGrp.addCommGroupObj
code: @[to_additive]
instance commGroupObj (j) : CommGroup ((F ⋙ forget CommGrp).obj j) 
goal: AddCommGroup ((F ⋙ CategoryTheory.forget AddCommGrp).obj j)

full_name: AddCommGrp.limitAddCommGroup
code: @[to_additive]
noncomputable instance limitCommGroup
    [Small.{u} (Functor.sections (F ⋙ forget CommGrp))] :
    CommGroup (Types.Small.limitCone.{v, u} (F ⋙ forget CommGrp.{u})).pt 
goal: AddCommGroup (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget AddCommGrp)).pt

full_name: CommGrp.limitCommGroup
code: @[to_additive]
noncomputable instance limitCommGroup
    [Small.{u} (Functor.sections (F ⋙ forget CommGrp))] :
    CommGroup (Types.Small.limitCone.{v, u} (F ⋙ forget CommGrp.{u})).pt 
goal: CommGroup (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget CommGrp)).pt

full_name: AddCommGrp.instReflectsIsomorphismsAddGrpForget₂
code: @[to_additive]
instance : (forget₂ CommGrp.{u} Grp.{u}).ReflectsIsomorphisms 
goal: (CategoryTheory.forget₂ AddCommGrp AddGrp).ReflectsIsomorphisms

full_name: CommGrp.instReflectsIsomorphismsGrpForget₂
code: @[to_additive]
instance : (forget₂ CommGrp.{u} Grp.{u}).ReflectsIsomorphisms 
goal: (CategoryTheory.forget₂ CommGrp Grp).ReflectsIsomorphisms

full_name: AddCommGrp.Forget₂.createsLimit
code: /-- We show that the forgetful functor `CommGrp ⥤ Grp` creates limits.

All we need to do is notice that the limit point has a `CommGroup` instance available,
and then reuse the existing limit.
-/
@[to_additive "We show that the forgetful functor `AddCommGrp ⥤ AddGrp` creates limits.

  All we need to do is notice that the limit point has an `AddCommGroup` instance available,
  and then reuse the existing limit."]
noncomputable instance Forget₂.createsLimit :
    CreatesLimit F (forget₂ CommGrp Grp.{u}) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ AddCommGrp AddGrp)

full_name: CommGrp.Forget₂.createsLimit
code: /-- We show that the forgetful functor `CommGrp ⥤ Grp` creates limits.

All we need to do is notice that the limit point has a `CommGroup` instance available,
and then reuse the existing limit.
-/
@[to_additive "We show that the forgetful functor `AddCommGrp ⥤ AddGrp` creates limits.

  All we need to do is notice that the limit point has an `AddCommGroup` instance available,
  and then reuse the existing limit."]
noncomputable instance Forget₂.createsLimit :
    CreatesLimit F (forget₂ CommGrp Grp.{u}) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ CommGrp Grp)

full_name: AddCommGrp.limitCone
code: /-- A choice of limit cone for a functor into `CommGrp`.
(Generally, you'll just want to use `limit F`.)
-/
@[to_additive
  "A choice of limit cone for a functor into `AddCommGrp`.
  (Generally, you'll just want to use `limit F`.)"]
noncomputable def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CommGrp.limitCone
code: /-- A choice of limit cone for a functor into `CommGrp`.
(Generally, you'll just want to use `limit F`.)
-/
@[to_additive
  "A choice of limit cone for a functor into `AddCommGrp`.
  (Generally, you'll just want to use `limit F`.)"]
noncomputable def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: AddCommGrp.limitConeIsLimit
code: /-- The chosen cone is a limit cone.
(Generally, you'll just want to use `limit.cone F`.)
-/
@[to_additive
  "The chosen cone is a limit cone.
  (Generally, you'll just want to use `limit.cone F`.)"]
noncomputable def limitConeIsLimit : IsLimit (limitCone.{v, u} F) 
goal: CategoryTheory.Limits.IsLimit (AddCommGrp.limitCone F)

full_name: CommGrp.limitConeIsLimit
code: /-- The chosen cone is a limit cone.
(Generally, you'll just want to use `limit.cone F`.)
-/
@[to_additive
  "The chosen cone is a limit cone.
  (Generally, you'll just want to use `limit.cone F`.)"]
noncomputable def limitConeIsLimit : IsLimit (limitCone.{v, u} F) 
goal: CategoryTheory.Limits.IsLimit (CommGrp.limitCone F)

full_name: AddCommGrp.hasLimit
code: /-- If `(F ⋙ forget CommGrp).sections` is `u`-small, `F` has a limit. -/
@[to_additive "If `(F ⋙ forget AddCommGrp).sections` is `u`-small, `F` has a limit."]
instance hasLimit : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CommGrp.hasLimit
code: /-- If `(F ⋙ forget CommGrp).sections` is `u`-small, `F` has a limit. -/
@[to_additive "If `(F ⋙ forget AddCommGrp).sections` is `u`-small, `F` has a limit."]
instance hasLimit : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CommGrp.hasLimit_iff_small_sections
code: /-- A functor `F : J ⥤ CommGrp.{u}` has a limit iff `(F ⋙ forget CommGrp).sections` is
`u`-small.  -/
@[to_additive "A functor `F : J ⥤ AddCommGrp.{u}` has a limit iff
`(F ⋙ forget AddCommGrp).sections` is `u`-small."]
lemma hasLimit_iff_small_sections :
    HasLimit F ↔ Small.{u} (F ⋙ forget CommGrp).sections 
goal: CategoryTheory.Limits.HasLimit F ↔ Small.{u, max u v} ↑(F ⋙ CategoryTheory.forget CommGrp).sections

full_name: AddCommGrp.hasLimit_iff_small_sections
code: /-- A functor `F : J ⥤ CommGrp.{u}` has a limit iff `(F ⋙ forget CommGrp).sections` is
`u`-small.  -/
@[to_additive "A functor `F : J ⥤ AddCommGrp.{u}` has a limit iff
`(F ⋙ forget AddCommGrp).sections` is `u`-small."]
lemma hasLimit_iff_small_sections :
    HasLimit F ↔ Small.{u} (F ⋙ forget CommGrp).sections 
goal: CategoryTheory.Limits.HasLimit F ↔ Small.{u, max u v} ↑(F ⋙ CategoryTheory.forget AddCommGrp).sections

full_name: AddCommGrp.hasLimitsOfShape
code: /-- If `J` is `u`-small, `CommGrp.{u}` has limits of shape `J`. -/
@[to_additive "If `J` is `u`-small, `AddCommGrp.{u}` has limits of shape `J`."]
instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J CommGrp.{u} 
goal: CategoryTheory.Limits.HasLimitsOfShape J AddCommGrp

full_name: CommGrp.hasLimitsOfShape
code: /-- If `J` is `u`-small, `CommGrp.{u}` has limits of shape `J`. -/
@[to_additive "If `J` is `u`-small, `AddCommGrp.{u}` has limits of shape `J`."]
instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J CommGrp.{u} 
goal: CategoryTheory.Limits.HasLimitsOfShape J CommGrp

full_name: CommGrp.hasLimitsOfSize
code: /-- The category of commutative groups has all limits. -/
@[to_additive "The category of additive commutative groups has all limits.",
  to_additive_relevant_arg 2]
instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} CommGrp.{u}
  
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} CommGrp

full_name: AddCommGrp.hasLimitsOfSize
code: /-- The category of commutative groups has all limits. -/
@[to_additive "The category of additive commutative groups has all limits.",
  to_additive_relevant_arg 2]
instance hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} CommGrp.{u}
  
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} AddCommGrp

full_name: CommGrp.hasLimits
code: @[to_additive]
instance hasLimits : HasLimits CommGrp.{u} 
goal: CategoryTheory.Limits.HasLimits CommGrp

full_name: AddCommGrp.hasLimits
code: @[to_additive]
instance hasLimits : HasLimits CommGrp.{u} 
goal: CategoryTheory.Limits.HasLimits AddCommGrp

full_name: CommGrp.forget₂GroupPreservesLimit
code: @[to_additive]
noncomputable instance forget₂GroupPreservesLimit :
    PreservesLimit F (forget₂ CommGrp.{u} Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimit F (CategoryTheory.forget₂ CommGrp Grp)

full_name: AddCommGrp.forget₂AddGroupPreservesLimit
code: @[to_additive]
noncomputable instance forget₂GroupPreservesLimit :
    PreservesLimit F (forget₂ CommGrp.{u} Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimit F (CategoryTheory.forget₂ AddCommGrp AddGrp)

full_name: CommGrp.forget₂GroupPreservesLimitsOfShape
code: @[to_additive]
noncomputable instance forget₂GroupPreservesLimitsOfShape :
    PreservesLimitsOfShape J (forget₂ CommGrp.{u} Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget₂ CommGrp Grp)

full_name: AddCommGrp.forget₂AddGroupPreservesLimitsOfShape
code: @[to_additive]
noncomputable instance forget₂GroupPreservesLimitsOfShape :
    PreservesLimitsOfShape J (forget₂ CommGrp.{u} Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget₂ AddCommGrp AddGrp)

full_name: AddCommGrp.forget₂AddGroupPreservesLimitsOfSize
code: /-- The forgetful functor from commutative groups to groups preserves all limits.
(That is, the underlying group could have been computed instead as limits in the category
of groups.)
-/
@[to_additive
  "The forgetful functor from additive commutative groups to additive groups preserves all limits.
  (That is, the underlying group could have been computed instead as limits in the category
    of additive groups.)",
  to_additive_relevant_arg 2]
noncomputable instance forget₂GroupPreservesLimitsOfSize :
    PreservesLimitsOfSize.{w, v} (forget₂ CommGrp.{u} Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ AddCommGrp AddGrp)

full_name: CommGrp.forget₂GroupPreservesLimitsOfSize
code: /-- The forgetful functor from commutative groups to groups preserves all limits.
(That is, the underlying group could have been computed instead as limits in the category
of groups.)
-/
@[to_additive
  "The forgetful functor from additive commutative groups to additive groups preserves all limits.
  (That is, the underlying group could have been computed instead as limits in the category
    of additive groups.)",
  to_additive_relevant_arg 2]
noncomputable instance forget₂GroupPreservesLimitsOfSize :
    PreservesLimitsOfSize.{w, v} (forget₂ CommGrp.{u} Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ CommGrp Grp)

full_name: AddCommGrp.forget₂AddGroupPreservesLimits
code: @[to_additive]
noncomputable instance forget₂GroupPreservesLimits :
    PreservesLimits (forget₂ CommGrp Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ AddCommGrp AddGrp)

full_name: CommGrp.forget₂GroupPreservesLimits
code: @[to_additive]
noncomputable instance forget₂GroupPreservesLimits :
    PreservesLimits (forget₂ CommGrp Grp.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ CommGrp Grp)

full_name: CommGrp.forget₂CommMonPreservesLimitsAux
code: /-- An auxiliary declaration to speed up typechecking.
-/
@[to_additive AddCommGrp.forget₂AddCommMonPreservesLimitsAux
  "An auxiliary declaration to speed up typechecking."]
noncomputable def forget₂CommMonPreservesLimitsAux
    [Small.{u} (F ⋙ forget CommGrp).sections] :
    IsLimit ((forget₂ CommGrp.{u} CommMonCat.{u}).mapCone (limitCone.{v, u} F)) 
goal: CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ CommGrp CommMonCat).mapCone (CommGrp.limitCone F))

full_name: AddCommGrp.forget₂AddCommMonPreservesLimitsAux
code: /-- An auxiliary declaration to speed up typechecking.
-/
@[to_additive AddCommGrp.forget₂AddCommMonPreservesLimitsAux
  "An auxiliary declaration to speed up typechecking."]
noncomputable def forget₂CommMonPreservesLimitsAux
    [Small.{u} (F ⋙ forget CommGrp).sections] :
    IsLimit ((forget₂ CommGrp.{u} CommMonCat.{u}).mapCone (limitCone.{v, u} F)) 
goal: CategoryTheory.Limits.IsLimit ((CategoryTheory.forget₂ AddCommGrp AddCommMonCat).mapCone (AddCommGrp.limitCone F))

full_name: CommGrp.forget₂CommMonPreservesLimitsOfShape
code: /-- If `J` is `u`-small, the forgetful functor from `CommGrp.{u}` to `CommMonCat.{u}`
preserves limits of shape `J`. -/
@[to_additive AddCommGrp.forget₂AddCommMonPreservesLimitsOfShape
  "If `J` is `u`-small, the forgetful functor from `AddCommGrp.{u}`
  to `AddCommMonCat.{u}` preserves limits of shape `J`."]
noncomputable instance forget₂CommMonPreservesLimitsOfShape [Small.{u} J] :
    PreservesLimitsOfShape J (forget₂ CommGrp.{u} CommMonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget₂ CommGrp CommMonCat)

full_name: AddCommGrp.forget₂AddCommMonPreservesLimitsOfShape
code: /-- If `J` is `u`-small, the forgetful functor from `CommGrp.{u}` to `CommMonCat.{u}`
preserves limits of shape `J`. -/
@[to_additive AddCommGrp.forget₂AddCommMonPreservesLimitsOfShape
  "If `J` is `u`-small, the forgetful functor from `AddCommGrp.{u}`
  to `AddCommMonCat.{u}` preserves limits of shape `J`."]
noncomputable instance forget₂CommMonPreservesLimitsOfShape [Small.{u} J] :
    PreservesLimitsOfShape J (forget₂ CommGrp.{u} CommMonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget₂ AddCommGrp AddCommMonCat)

full_name: CommGrp.forget₂CommMonPreservesLimitsOfSize
code: /-- The forgetful functor from commutative groups to commutative monoids preserves all limits.
(That is, the underlying commutative monoids could have been computed instead as limits
in the category of commutative monoids.)
-/
@[to_additive AddCommGrp.forget₂AddCommMonPreservesLimitsOfSize
  "The forgetful functor from additive commutative groups to additive commutative monoids
  preserves all limits. (That is, the underlying additive commutative monoids could have been
  computed instead as limits in the category of additive commutative monoids.)"]
noncomputable instance forget₂CommMonPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ CommGrp CommMonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ CommGrp CommMonCat)

full_name: AddCommGrp.forget₂AddCommMonPreservesLimitsOfSize
code: /-- The forgetful functor from commutative groups to commutative monoids preserves all limits.
(That is, the underlying commutative monoids could have been computed instead as limits
in the category of commutative monoids.)
-/
@[to_additive AddCommGrp.forget₂AddCommMonPreservesLimitsOfSize
  "The forgetful functor from additive commutative groups to additive commutative monoids
  preserves all limits. (That is, the underlying additive commutative monoids could have been
  computed instead as limits in the category of additive commutative monoids.)"]
noncomputable instance forget₂CommMonPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ CommGrp CommMonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ AddCommGrp AddCommMonCat)

full_name: CommGrp.forgetPreservesLimitsOfShape
code: /-- If `J` is `u`-small, the forgetful functor from `CommGrp.{u}` preserves limits of
shape `J`. -/
@[to_additive "If `J` is `u`-small, the forgetful functor from `AddCommGrp.{u}`\n
preserves limits of shape `J`."]
noncomputable instance forgetPreservesLimitsOfShape [Small.{u} J] :
    PreservesLimitsOfShape J (forget CommGrp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget CommGrp)

full_name: AddCommGrp.forgetPreservesLimitsOfShape
code: /-- If `J` is `u`-small, the forgetful functor from `CommGrp.{u}` preserves limits of
shape `J`. -/
@[to_additive "If `J` is `u`-small, the forgetful functor from `AddCommGrp.{u}`\n
preserves limits of shape `J`."]
noncomputable instance forgetPreservesLimitsOfShape [Small.{u} J] :
    PreservesLimitsOfShape J (forget CommGrp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget AddCommGrp)

full_name: CommGrp.forgetPreservesLimitsOfSize
code: /-- The forgetful functor from commutative groups to types preserves all limits. (That is, the
underlying types could have been computed instead as limits in the category of types.)
-/
@[to_additive
  "The forgetful functor from additive commutative groups to types preserves all limits.
  (That is, the underlying types could have been computed instead as limits in the category of
  types.)"]
noncomputable instance forgetPreservesLimitsOfSize :
    PreservesLimitsOfSize.{w, v} (forget CommGrp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget CommGrp)

full_name: AddCommGrp.forgetPreservesLimitsOfSize
code: /-- The forgetful functor from commutative groups to types preserves all limits. (That is, the
underlying types could have been computed instead as limits in the category of types.)
-/
@[to_additive
  "The forgetful functor from additive commutative groups to types preserves all limits.
  (That is, the underlying types could have been computed instead as limits in the category of
  types.)"]
noncomputable instance forgetPreservesLimitsOfSize :
    PreservesLimitsOfSize.{w, v} (forget CommGrp.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget AddCommGrp)

full_name: AddCommGrp.forgetPreservesLimits
code: noncomputable instance _root_.AddCommGrp.forgetPreservesLimits :
    PreservesLimits (forget AddCommGrp.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget AddCommGrp)

full_name: CommGrp.forgetPreservesLimits
code: @[to_additive existing]
noncomputable instance forgetPreservesLimits : PreservesLimits (forget CommGrp.{u}) 
goal: CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget CommGrp)

full_name: AddCommGrp.kernelIsoKer
code: /-- The categorical kernel of a morphism in `AddCommGrp`
agrees with the usual group-theoretical kernel.
-/
def kernelIsoKer {G H : AddCommGrp.{u}} (f : G ⟶ H) :
    kernel f ≅ AddCommGrp.of f.ker 
goal: CategoryTheory.Limits.kernel f ≅ AddCommGrp.of ↥(AddMonoidHom.ker f)

full_name: AddCommGrp.kernelIsoKer_hom_comp_subtype
code: @[simp]
theorem kernelIsoKer_hom_comp_subtype {G H : AddCommGrp.{u}} (f : G ⟶ H) :
    (kernelIsoKer f).hom ≫ AddSubgroup.subtype f.ker = kernel.ι f 
goal: (AddCommGrp.kernelIsoKer f).hom ≫ (AddMonoidHom.ker f).subtype = CategoryTheory.Limits.kernel.ι f

full_name: AddCommGrp.kernelIsoKer_inv_comp_ι
code: @[simp]
theorem kernelIsoKer_inv_comp_ι {G H : AddCommGrp.{u}} (f : G ⟶ H) :
    (kernelIsoKer f).inv ≫ kernel.ι f = AddSubgroup.subtype f.ker 
goal: (AddCommGrp.kernelIsoKer f).inv ≫ CategoryTheory.Limits.kernel.ι f = (AddMonoidHom.ker f).subtype

full_name: AddCommGrp.kernelIsoKerOver_inv_left_apply
code: /-- The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`,
agrees with the `AddSubgroup.subtype` map.
-/
@[simps! hom_left_apply_coe inv_left_apply]
def kernelIsoKerOver {G H : AddCommGrp.{u}} (f : G ⟶ H) :
    Over.mk (kernel.ι f) ≅ @Over.mk _ _ G (AddCommGrp.of f.ker) (AddSubgroup.subtype f.ker) 
goal: ∀ (a : ↑(CategoryTheory.Limits.KernelFork.ofι (AddMonoidHom.ker f).subtype ⋯).pt),
  (AddCommGrp.kernelIsoKerOver f).inv.left a =
    (CategoryTheory.Limits.limit.lift (CategoryTheory.Limits.parallelPair f 0)
        (CategoryTheory.Limits.KernelFork.ofι (AddMonoidHom.ker f).subtype ⋯))
      a

full_name: AddCommGrp.kernelIsoKerOver_hom_left_apply_coe
code: /-- The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`,
agrees with the `AddSubgroup.subtype` map.
-/
@[simps! hom_left_apply_coe inv_left_apply]
def kernelIsoKerOver {G H : AddCommGrp.{u}} (f : G ⟶ H) :
    Over.mk (kernel.ι f) ≅ @Over.mk _ _ G (AddCommGrp.of f.ker) (AddSubgroup.subtype f.ker) 
goal: ↑((AddCommGrp.kernelIsoKerOver f).hom.left g) = (CategoryTheory.Limits.kernel.ι f) g

full_name: AddCommGrp.kernelIsoKerOver
code: /-- The categorical kernel inclusion for `f : G ⟶ H`, as an object over `G`,
agrees with the `AddSubgroup.subtype` map.
-/
@[simps! hom_left_apply_coe inv_left_apply]
def kernelIsoKerOver {G H : AddCommGrp.{u}} (f : G ⟶ H) :
    Over.mk (kernel.ι f) ≅ @Over.mk _ _ G (AddCommGrp.of f.ker) (AddSubgroup.subtype f.ker) 
goal: CategoryTheory.Over.mk (CategoryTheory.Limits.kernel.ι f) ≅ CategoryTheory.Over.mk (AddMonoidHom.ker f).subtype