File: Mathlib/CategoryTheory/Limits/FullSubcategory.lean

full_name: CategoryTheory.Limits.ClosedUnderLimitsOfShape
code: /-- We say that a property is closed under limits of shape `J` if whenever all objects in a
    `J`-shaped diagram have the property, any limit of this diagram also has the property. -/
def ClosedUnderLimitsOfShape {C : Type u} [Category.{v} C] (J : Type w) [Category.{w'} J]
    (P : C → Prop) : Prop 
goal: Prop

full_name: CategoryTheory.Limits.ClosedUnderColimitsOfShape
code: /-- We say that a property is closed under colimits of shape `J` if whenever all objects in a
    `J`-shaped diagram have the property, any colimit of this diagram also has the property. -/
def ClosedUnderColimitsOfShape {C : Type u} [Category.{v} C] (J : Type w) [Category.{w'} J]
    (P : C → Prop) : Prop 
goal: Prop

full_name: CategoryTheory.Limits.ClosedUnderLimitsOfShape.limit
code: theorem ClosedUnderLimitsOfShape.limit (h : ClosedUnderLimitsOfShape J P) {F : J ⥤ C} [HasLimit F] :
    (∀ j, P (F.obj j)) → P (limit F) 
goal: (∀ (j : J), P (F.obj j)) → P (CategoryTheory.Limits.limit F)

full_name: CategoryTheory.Limits.ClosedUnderColimitsOfShape.colimit
code: theorem ClosedUnderColimitsOfShape.colimit (h : ClosedUnderColimitsOfShape J P) {F : J ⥤ C}
    [HasColimit F] : (∀ j, P (F.obj j)) → P (colimit F) 
goal: (∀ (j : J), P (F.obj j)) → P (CategoryTheory.Limits.colimit F)

full_name: CategoryTheory.Limits.createsLimitFullSubcategoryInclusion'
code: /-- If a `J`-shaped diagram in `FullSubcategory P` has a limit cone in `C` whose cone point lives
    in the full subcategory, then this defines a limit in the full subcategory. -/
def createsLimitFullSubcategoryInclusion' (F : J ⥤ FullSubcategory P)
    {c : Cone (F ⋙ fullSubcategoryInclusion P)} (hc : IsLimit c) (h : P c.pt) :
    CreatesLimit F (fullSubcategoryInclusion P) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.fullSubcategoryInclusion P)

full_name: CategoryTheory.Limits.createsLimitFullSubcategoryInclusion
code: /-- If a `J`-shaped diagram in `FullSubcategory P` has a limit in `C` whose cone point lives in the
    full subcategory, then this defines a limit in the full subcategory. -/
def createsLimitFullSubcategoryInclusion (F : J ⥤ FullSubcategory P)
    [HasLimit (F ⋙ fullSubcategoryInclusion P)] (h : P (limit (F ⋙ fullSubcategoryInclusion P))) :
    CreatesLimit F (fullSubcategoryInclusion P) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.fullSubcategoryInclusion P)

full_name: CategoryTheory.Limits.createsColimitFullSubcategoryInclusion'
code: /-- If a `J`-shaped diagram in `FullSubcategory P` has a colimit cocone in `C` whose cocone point
    lives in the full subcategory, then this defines a colimit in the full subcategory. -/
def createsColimitFullSubcategoryInclusion' (F : J ⥤ FullSubcategory P)
    {c : Cocone (F ⋙ fullSubcategoryInclusion P)} (hc : IsColimit c) (h : P c.pt) :
    CreatesColimit F (fullSubcategoryInclusion P) 
goal: CategoryTheory.CreatesColimit F (CategoryTheory.fullSubcategoryInclusion P)

full_name: CategoryTheory.Limits.createsColimitFullSubcategoryInclusion
code: /-- If a `J`-shaped diagram in `FullSubcategory P` has a colimit in `C` whose cocone point lives in
    the full subcategory, then this defines a colimit in the full subcategory. -/
def createsColimitFullSubcategoryInclusion (F : J ⥤ FullSubcategory P)
    [HasColimit (F ⋙ fullSubcategoryInclusion P)]
    (h : P (colimit (F ⋙ fullSubcategoryInclusion P))) :
    CreatesColimit F (fullSubcategoryInclusion P) 
goal: CategoryTheory.CreatesColimit F (CategoryTheory.fullSubcategoryInclusion P)

full_name: CategoryTheory.Limits.createsLimitFullSubcategoryInclusionOfClosed
code: /-- If `P` is closed under limits of shape `J`, then the inclusion creates such limits. -/
def createsLimitFullSubcategoryInclusionOfClosed (h : ClosedUnderLimitsOfShape J P)
    (F : J ⥤ FullSubcategory P) [HasLimit (F ⋙ fullSubcategoryInclusion P)] :
    CreatesLimit F (fullSubcategoryInclusion P) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.fullSubcategoryInclusion P)

full_name: CategoryTheory.Limits.createsLimitsOfShapeFullSubcategoryInclusion
code: /-- If `P` is closed under limits of shape `J`, then the inclusion creates such limits. -/
def createsLimitsOfShapeFullSubcategoryInclusion (h : ClosedUnderLimitsOfShape J P)
    [HasLimitsOfShape J C] : CreatesLimitsOfShape J (fullSubcategoryInclusion P) 
goal: CategoryTheory.CreatesLimitsOfShape J (CategoryTheory.fullSubcategoryInclusion P)

full_name: CategoryTheory.Limits.hasLimit_of_closedUnderLimits
code: theorem hasLimit_of_closedUnderLimits (h : ClosedUnderLimitsOfShape J P)
    (F : J ⥤ FullSubcategory P) [HasLimit (F ⋙ fullSubcategoryInclusion P)] : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.hasLimitsOfShape_of_closedUnderLimits
code: theorem hasLimitsOfShape_of_closedUnderLimits (h : ClosedUnderLimitsOfShape J P)
    [HasLimitsOfShape J C] : HasLimitsOfShape J (FullSubcategory P) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.FullSubcategory P)

full_name: CategoryTheory.Limits.createsColimitFullSubcategoryInclusionOfClosed
code: /-- If `P` is closed under colimits of shape `J`, then the inclusion creates such colimits. -/
def createsColimitFullSubcategoryInclusionOfClosed (h : ClosedUnderColimitsOfShape J P)
    (F : J ⥤ FullSubcategory P) [HasColimit (F ⋙ fullSubcategoryInclusion P)] :
    CreatesColimit F (fullSubcategoryInclusion P) 
goal: CategoryTheory.CreatesColimit F (CategoryTheory.fullSubcategoryInclusion P)

full_name: CategoryTheory.Limits.createsColimitsOfShapeFullSubcategoryInclusion
code: /-- If `P` is closed under colimits of shape `J`, then the inclusion creates such colimits. -/
def createsColimitsOfShapeFullSubcategoryInclusion (h : ClosedUnderColimitsOfShape J P)
    [HasColimitsOfShape J C] : CreatesColimitsOfShape J (fullSubcategoryInclusion P) 
goal: CategoryTheory.CreatesColimitsOfShape J (CategoryTheory.fullSubcategoryInclusion P)

full_name: CategoryTheory.Limits.hasColimit_of_closedUnderColimits
code: theorem hasColimit_of_closedUnderColimits (h : ClosedUnderColimitsOfShape J P)
    (F : J ⥤ FullSubcategory P) [HasColimit (F ⋙ fullSubcategoryInclusion P)] : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.hasColimitsOfShape_of_closedUnderColimits
code: theorem hasColimitsOfShape_of_closedUnderColimits (h : ClosedUnderColimitsOfShape J P)
    [HasColimitsOfShape J C] : HasColimitsOfShape J (FullSubcategory P) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.FullSubcategory P)