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

full_name: MonCatMax
code: /-- An alias for `MonCat.{max u v}`, to deal around unification issues. -/
@[to_additive (attr := nolint checkUnivs) AddMonCatMax
  "An alias for `AddMonCat.{max u v}`, to deal around unification issues."]
abbrev MonCatMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: AddMonCatMax
code: /-- An alias for `MonCat.{max u v}`, to deal around unification issues. -/
@[to_additive (attr := nolint checkUnivs) AddMonCatMax
  "An alias for `AddMonCat.{max u v}`, to deal around unification issues."]
abbrev MonCatMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: AddMonCat.addMonoidObj
code: @[to_additive]
instance monoidObj (j) : Monoid ((F ⋙ forget MonCat).obj j) 
goal: AddMonoid ((F ⋙ CategoryTheory.forget AddMonCat).obj j)

full_name: MonCat.monoidObj
code: @[to_additive]
instance monoidObj (j) : Monoid ((F ⋙ forget MonCat).obj j) 
goal: Monoid ((F ⋙ CategoryTheory.forget MonCat).obj j)

full_name: AddMonCat.sectionsAddSubmonoid
code: /-- The flat sections of a functor into `MonCat` form a submonoid of all sections.
-/
@[to_additive
      "The flat sections of a functor into `AddMonCat` form an additive submonoid of all sections."]
def sectionsSubmonoid : Submonoid (∀ j, F.obj j) 
goal: AddSubmonoid ((j : J) → ↑(F.obj j))

full_name: MonCat.sectionsSubmonoid
code: /-- The flat sections of a functor into `MonCat` form a submonoid of all sections.
-/
@[to_additive
      "The flat sections of a functor into `AddMonCat` form an additive submonoid of all sections."]
def sectionsSubmonoid : Submonoid (∀ j, F.obj j) 
goal: Submonoid ((j : J) → ↑(F.obj j))

full_name: AddMonCat.sectionsAddMonoid
code: @[to_additive]
instance sectionsMonoid : Monoid (F ⋙ forget MonCat.{u}).sections 
goal: AddMonoid ↑(F ⋙ CategoryTheory.forget AddMonCat).sections

full_name: MonCat.sectionsMonoid
code: @[to_additive]
instance sectionsMonoid : Monoid (F ⋙ forget MonCat.{u}).sections 
goal: Monoid ↑(F ⋙ CategoryTheory.forget MonCat).sections

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

full_name: AddMonCat.limitAddMonoid
code: @[to_additive]
noncomputable instance limitMonoid :
    Monoid (Types.Small.limitCone.{v, u} (F ⋙ forget MonCat.{u})).pt 
goal: AddMonoid (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget AddMonCat)).pt

full_name: AddMonCat.limitπAddMonoidHom
code: /-- `limit.π (F ⋙ forget MonCat) j` as a `MonoidHom`. -/
@[to_additive "`limit.π (F ⋙ forget AddMonCat) j` as an `AddMonoidHom`."]
noncomputable def limitπMonoidHom (j : J) :
    (Types.Small.limitCone.{v, u} (F ⋙ forget MonCat.{u})).pt →*
      ((F ⋙ forget MonCat.{u}).obj j) 
goal: (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget AddMonCat)).pt →+
  (F ⋙ CategoryTheory.forget AddMonCat).obj j

full_name: MonCat.limitπMonoidHom
code: /-- `limit.π (F ⋙ forget MonCat) j` as a `MonoidHom`. -/
@[to_additive "`limit.π (F ⋙ forget AddMonCat) j` as an `AddMonoidHom`."]
noncomputable def limitπMonoidHom (j : J) :
    (Types.Small.limitCone.{v, u} (F ⋙ forget MonCat.{u})).pt →*
      ((F ⋙ forget MonCat.{u}).obj j) 
goal: (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget MonCat)).pt →*
  (F ⋙ CategoryTheory.forget MonCat).obj j

full_name: AddMonCat.HasLimits.limitCone
code: /-- Construction of a limit cone in `MonCat`.
(Internal use only; use the limits API.)
-/
@[to_additive "(Internal use only; use the limits API.)"]
noncomputable def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: MonCat.HasLimits.limitCone
code: /-- Construction of a limit cone in `MonCat`.
(Internal use only; use the limits API.)
-/
@[to_additive "(Internal use only; use the limits API.)"]
noncomputable def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: MonCat.HasLimits.limitConeIsLimit
code: /-- Witness that the limit cone in `MonCat` is a limit cone.
(Internal use only; use the limits API.)
-/
@[to_additive "(Internal use only; use the limits API.)"]
noncomputable def limitConeIsLimit : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (MonCat.HasLimits.limitCone F)

full_name: AddMonCat.HasLimits.limitConeIsLimit
code: /-- Witness that the limit cone in `MonCat` is a limit cone.
(Internal use only; use the limits API.)
-/
@[to_additive "(Internal use only; use the limits API.)"]
noncomputable def limitConeIsLimit : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (AddMonCat.HasLimits.limitCone F)

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

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

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

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

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

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

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

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

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

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

full_name: AddMonCat.forgetPreservesLimitsOfSize
code: /-- The forgetful functor from monoids 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 monoids to types preserves all limits.\n\n
  This means the underlying type of a limit can be computed as a limit in the category of types.",
  to_additive_relevant_arg 2]
noncomputable instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget MonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget AddMonCat)

full_name: MonCat.forgetPreservesLimitsOfSize
code: /-- The forgetful functor from monoids 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 monoids to types preserves all limits.\n\n
  This means the underlying type of a limit can be computed as a limit in the category of types.",
  to_additive_relevant_arg 2]
noncomputable instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget MonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget MonCat)

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

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

full_name: CommMonCatMax
code: /-- An alias for `CommMonCat.{max u v}`, to deal around unification issues. -/
@[to_additive (attr := nolint checkUnivs) AddCommMonCatMax
  "An alias for `AddCommMonCat.{max u v}`, to deal around unification issues."]
abbrev CommMonCatMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: AddCommMonCatMax
code: /-- An alias for `CommMonCat.{max u v}`, to deal around unification issues. -/
@[to_additive (attr := nolint checkUnivs) AddCommMonCatMax
  "An alias for `AddCommMonCat.{max u v}`, to deal around unification issues."]
abbrev CommMonCatMax.{u1, u2} 
goal: Type ((max u1 u2) + 1)

full_name: CommMonCat.commMonoidObj
code: @[to_additive]
instance commMonoidObj (j) : CommMonoid ((F ⋙ forget CommMonCat.{u}).obj j) 
goal: CommMonoid ((F ⋙ CategoryTheory.forget CommMonCat).obj j)

full_name: AddCommMonCat.addCommMonoidObj
code: @[to_additive]
instance commMonoidObj (j) : CommMonoid ((F ⋙ forget CommMonCat.{u}).obj j) 
goal: AddCommMonoid ((F ⋙ CategoryTheory.forget AddCommMonCat).obj j)

full_name: AddCommMonCat.limitAddCommMonoid
code: @[to_additive]
noncomputable instance limitCommMonoid :
    CommMonoid (Types.Small.limitCone (F ⋙ forget CommMonCat.{u})).pt 
goal: AddCommMonoid (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget AddCommMonCat)).pt

full_name: CommMonCat.limitCommMonoid
code: @[to_additive]
noncomputable instance limitCommMonoid :
    CommMonoid (Types.Small.limitCone (F ⋙ forget CommMonCat.{u})).pt 
goal: CommMonoid (CategoryTheory.Limits.Types.Small.limitCone (F ⋙ CategoryTheory.forget CommMonCat)).pt

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

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

full_name: CommMonCat.forget₂CreatesLimit
code: /-- We show that the forgetful functor `CommMonCat ⥤ MonCat` creates limits.

All we need to do is notice that the limit point has a `CommMonoid` instance available,
and then reuse the existing limit. -/
@[to_additive "We show that the forgetful functor `AddCommMonCat ⥤ AddMonCat` creates limits.\n\n
All we need to do is notice that the limit point has an `AddCommMonoid` instance available,\n
and then reuse the existing limit."]
noncomputable instance forget₂CreatesLimit : CreatesLimit F (forget₂ CommMonCat MonCat.{u}) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ CommMonCat MonCat)

full_name: AddCommMonCat.forget₂CreatesLimit
code: /-- We show that the forgetful functor `CommMonCat ⥤ MonCat` creates limits.

All we need to do is notice that the limit point has a `CommMonoid` instance available,
and then reuse the existing limit. -/
@[to_additive "We show that the forgetful functor `AddCommMonCat ⥤ AddMonCat` creates limits.\n\n
All we need to do is notice that the limit point has an `AddCommMonoid` instance available,\n
and then reuse the existing limit."]
noncomputable instance forget₂CreatesLimit : CreatesLimit F (forget₂ CommMonCat MonCat.{u}) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.forget₂ AddCommMonCat AddMonCat)

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

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

full_name: AddCommMonCat.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\n`limit.cone F`.)"]
noncomputable def limitConeIsLimit : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (AddCommMonCat.limitCone F)

full_name: CommMonCat.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\n`limit.cone F`.)"]
noncomputable def limitConeIsLimit : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (CommMonCat.limitCone F)

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

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

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

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

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

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

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

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

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

This means the underlying type of a limit can be computed as a limit in the category of monoids. -/
@[to_additive AddCommMonCat.forget₂AddMonPreservesLimitsOfSize "The forgetful functor from
  additive commutative monoids to additive monoids preserves all limits.\n\n
  This means the underlying type of a limit can be computed as a limit in the category of additive\n
  monoids.",
  to_additive_relevant_arg 2]
noncomputable instance forget₂MonPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ CommMonCat.{u} MonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ CommMonCat MonCat)

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

This means the underlying type of a limit can be computed as a limit in the category of monoids. -/
@[to_additive AddCommMonCat.forget₂AddMonPreservesLimitsOfSize "The forgetful functor from
  additive commutative monoids to additive monoids preserves all limits.\n\n
  This means the underlying type of a limit can be computed as a limit in the category of additive\n
  monoids.",
  to_additive_relevant_arg 2]
noncomputable instance forget₂MonPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{w, v} (forget₂ CommMonCat.{u} MonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget₂ AddCommMonCat AddMonCat)

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

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

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

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

full_name: AddCommMonCat.forgetPreservesLimitsOfSize
code: /-- The forgetful functor from commutative monoids 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 commutative monoids to types preserves all\n
limits.\n\n
This means the underlying type of a limit can be computed as a limit in the category of types."]
noncomputable instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{v, v} (forget CommMonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, u, u, u + 1, u + 1} (CategoryTheory.forget AddCommMonCat)

full_name: CommMonCat.forgetPreservesLimitsOfSize
code: /-- The forgetful functor from commutative monoids 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 commutative monoids to types preserves all\n
limits.\n\n
This means the underlying type of a limit can be computed as a limit in the category of types."]
noncomputable instance forgetPreservesLimitsOfSize [UnivLE.{v, u}] :
    PreservesLimitsOfSize.{v, v} (forget CommMonCat.{u}) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{v, v, u, u, u + 1, u + 1} (CategoryTheory.forget CommMonCat)

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

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