File: Mathlib/CategoryTheory/Monoidal/Internal/Limits.lean

full_name: Mon_.limit
code: /-- We construct the (candidate) limit of a functor `F : J ⥤ Mon_ C`
by interpreting it as a functor `Mon_ (J ⥤ C)`,
and noting that taking limits is a lax monoidal functor,
and hence sends monoid objects to monoid objects.
-/
@[simps!]
def limit (F : J ⥤ Mon_ C) : Mon_ C 
goal: Mon_ C

full_name: Mon_.limit_X
code: /-- We construct the (candidate) limit of a functor `F : J ⥤ Mon_ C`
by interpreting it as a functor `Mon_ (J ⥤ C)`,
and noting that taking limits is a lax monoidal functor,
and hence sends monoid objects to monoid objects.
-/
@[simps!]
def limit (F : J ⥤ Mon_ C) : Mon_ C 
goal: (Mon_.limit F).X = CategoryTheory.Limits.limit (F ⋙ Mon_.forget C)

full_name: Mon_.limit_one
code: /-- We construct the (candidate) limit of a functor `F : J ⥤ Mon_ C`
by interpreting it as a functor `Mon_ (J ⥤ C)`,
and noting that taking limits is a lax monoidal functor,
and hence sends monoid objects to monoid objects.
-/
@[simps!]
def limit (F : J ⥤ Mon_ C) : Mon_ C 
goal: (Mon_.limit F).one =
  CategoryTheory.Limits.limit.lift (F ⋙ Mon_.forget C)
    ((CategoryTheory.Limits.Cones.postcompose
          (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj F).one).obj
      { pt := 𝟙_ C, π := { app := fun j => 𝟙 (𝟙_ C), naturality := ⋯ } })

full_name: Mon_.limit_mul
code: /-- We construct the (candidate) limit of a functor `F : J ⥤ Mon_ C`
by interpreting it as a functor `Mon_ (J ⥤ C)`,
and noting that taking limits is a lax monoidal functor,
and hence sends monoid objects to monoid objects.
-/
@[simps!]
def limit (F : J ⥤ Mon_ C) : Mon_ C 
goal: (Mon_.limit F).mul =
  CategoryTheory.Limits.limit.lift (F ⋙ Mon_.forget C)
    ((CategoryTheory.Limits.Cones.postcompose
          (CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverseObj F).mul).obj
      {
        pt :=
          CategoryTheory.MonoidalCategory.tensorObj (CategoryTheory.Limits.limit (F ⋙ Mon_.forget C))
            (CategoryTheory.Limits.limit (F ⋙ Mon_.forget C)),
        π :=
          {
            app := fun j =>
              CategoryTheory.MonoidalCategory.tensorHom (CategoryTheory.Limits.limit.π (F ⋙ Mon_.forget C) j)
                (CategoryTheory.Limits.limit.π (F ⋙ Mon_.forget C) j),
            naturality := ⋯ } })

full_name: Mon_.limitCone_pt
code: /-- Implementation of `Mon_.hasLimits`: a limiting cone over a functor `F : J ⥤ Mon_ C`.
-/
@[simps]
def limitCone (F : J ⥤ Mon_ C) : Cone F 
goal: (Mon_.limitCone F).pt = Mon_.limit F

full_name: Mon_.limitCone
code: /-- Implementation of `Mon_.hasLimits`: a limiting cone over a functor `F : J ⥤ Mon_ C`.
-/
@[simps]
def limitCone (F : J ⥤ Mon_ C) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: Mon_.limitCone_π_app_hom
code: /-- Implementation of `Mon_.hasLimits`: a limiting cone over a functor `F : J ⥤ Mon_ C`.
-/
@[simps]
def limitCone (F : J ⥤ Mon_ C) : Cone F 
goal: ((Mon_.limitCone F).π.app j).hom = CategoryTheory.Limits.limit.π (F ⋙ Mon_.forget C) j

full_name: Mon_.forgetMapConeLimitConeIso
code: /-- The image of the proposed limit cone for `F : J ⥤ Mon_ C` under the forgetful functor
`forget C : Mon_ C ⥤ C` is isomorphic to the limit cone of `F ⋙ forget C`.
-/
def forgetMapConeLimitConeIso (F : J ⥤ Mon_ C) :
    (forget C).mapCone (limitCone F) ≅ limit.cone (F ⋙ forget C) 
goal: (Mon_.forget C).mapCone (Mon_.limitCone F) ≅ CategoryTheory.Limits.limit.cone (F ⋙ Mon_.forget C)

full_name: Mon_.limitConeIsLimit
code: /-- Implementation of `Mon_.hasLimits`:
the proposed cone over a functor `F : J ⥤ Mon_ C` is a limit cone.
-/
@[simps]
def limitConeIsLimit (F : J ⥤ Mon_ C) : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (Mon_.limitCone F)

full_name: Mon_.limitConeIsLimit_lift_hom
code: /-- Implementation of `Mon_.hasLimits`:
the proposed cone over a functor `F : J ⥤ Mon_ C` is a limit cone.
-/
@[simps]
def limitConeIsLimit (F : J ⥤ Mon_ C) : IsLimit (limitCone F) 
goal: ((Mon_.limitConeIsLimit F).lift s).hom =
  CategoryTheory.Limits.limit.lift (F ⋙ Mon_.forget C) ((Mon_.forget C).mapCone s)

full_name: Mon_.hasLimitsOfShape
code: instance hasLimitsOfShape [HasLimitsOfShape J C] : HasLimitsOfShape J (Mon_ C) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (Mon_ C)

full_name: Mon_.forgetPreservesLimitsOfShape
code: instance forgetPreservesLimitsOfShape : PreservesLimitsOfShape J (Mon_.forget C) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (Mon_.forget C)