File: Mathlib/CategoryTheory/Sites/Limits.lean

full_name: CategoryTheory.Sheaf.multiforkEvaluationCone
code: /-- An auxiliary definition to be used below.

Whenever `E` is a cone of shape `K` of sheaves, and `S` is the multifork associated to a
covering `W` of an object `X`, with respect to the cone point `E.X`, this provides a cone of
shape `K` of objects in `D`, with cone point `S.X`.

See `isLimitMultiforkOfIsLimit` for more on how this definition is used.
-/
def multiforkEvaluationCone (F : K ⥤ Sheaf J D) (E : Cone (F ⋙ sheafToPresheaf J D)) (X : C)
    (W : J.Cover X) (S : Multifork (W.index E.pt)) :
    Cone (F ⋙ sheafToPresheaf J D ⋙ (evaluation Cᵒᵖ D).obj (op X)) 
goal: CategoryTheory.Limits.Cone
  (F.comp ((CategoryTheory.sheafToPresheaf J D).comp ((CategoryTheory.evaluation Cᵒᵖ D).obj (Opposite.op X))))

full_name: CategoryTheory.Sheaf.isLimitMultiforkOfIsLimit
code: /-- If `E` is a cone of shape `K` of sheaves, which is a limit on the level of presheaves,
this definition shows that the limit presheaf satisfies the multifork variant of the sheaf
condition, at a given covering `W`.

This is used below in `isSheaf_of_isLimit` to show that the limit presheaf is indeed a sheaf.
-/
def isLimitMultiforkOfIsLimit (F : K ⥤ Sheaf J D) (E : Cone (F ⋙ sheafToPresheaf J D))
    (hE : IsLimit E) (X : C) (W : J.Cover X) : IsLimit (W.multifork E.pt) 
goal: CategoryTheory.Limits.IsLimit (W.multifork E.pt)

full_name: CategoryTheory.Sheaf.isSheaf_of_isLimit
code: /-- If `E` is a cone which is a limit on the level of presheaves,
then the limit presheaf is again a sheaf.

This is used to show that the forgetful functor from sheaves to presheaves creates limits.
-/
theorem isSheaf_of_isLimit (F : K ⥤ Sheaf J D) (E : Cone (F ⋙ sheafToPresheaf J D))
    (hE : IsLimit E) : Presheaf.IsSheaf J E.pt 
goal: CategoryTheory.Presheaf.IsSheaf J E.pt

full_name: CategoryTheory.Sheaf.instCreatesLimitFunctorOppositeSheafToPresheaf
code: instance (F : K ⥤ Sheaf J D) : CreatesLimit F (sheafToPresheaf J D) 
goal: CategoryTheory.CreatesLimit F (CategoryTheory.sheafToPresheaf J D)

full_name: CategoryTheory.Sheaf.createsLimitsOfShape
code: instance createsLimitsOfShape : CreatesLimitsOfShape K (sheafToPresheaf J D) 
goal: CategoryTheory.CreatesLimitsOfShape K (CategoryTheory.sheafToPresheaf J D)

full_name: CategoryTheory.Sheaf.instHasLimitsOfShape
code: instance : HasLimitsOfShape K (Sheaf J D) 
goal: CategoryTheory.Limits.HasLimitsOfShape K (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.Sheaf.instHasFiniteProducts
code: instance [HasFiniteProducts D] : HasFiniteProducts (Sheaf J D) 
goal: CategoryTheory.Limits.HasFiniteProducts (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.Sheaf.instHasFiniteLimits
code: instance [HasFiniteLimits D] : HasFiniteLimits (Sheaf J D) 
goal: CategoryTheory.Limits.HasFiniteLimits (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.Sheaf.createsLimits
code: instance createsLimits [HasLimitsOfSize.{u₁, u₂} D] :
    CreatesLimitsOfSize.{u₁, u₂} (sheafToPresheaf J D) 
goal: CategoryTheory.CreatesLimitsOfSize.{u₁, u₂, max u w', max u w', max (max (max u v) w) w', max (max (max u v) w) w'}
  (CategoryTheory.sheafToPresheaf J D)

full_name: CategoryTheory.Sheaf.hasLimitsOfSize
code: instance hasLimitsOfSize [HasLimitsOfSize.{u₁, u₂} D] : HasLimitsOfSize.{u₁, u₂} (Sheaf J D) 
goal: CategoryTheory.Limits.HasLimitsOfSize.{u₁, u₂, max u w', max (max (max w u) w') v} (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.Sheaf.sheafifyCocone
code: /-- Construct a cocone by sheafifying a cocone point of a cocone `E` of presheaves
over a functor which factors through sheaves.
In `isColimitSheafifyCocone`, we show that this is a colimit cocone when `E` is a colimit. -/
noncomputable def sheafifyCocone {F : K ⥤ Sheaf J D}
    (E : Cocone (F ⋙ sheafToPresheaf J D)) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Sheaf.isColimitSheafifyCocone
code: /-- If `E` is a colimit cocone of presheaves, over a diagram factoring through sheaves,
then `sheafifyCocone E` is a colimit cocone. -/
noncomputable def isColimitSheafifyCocone {F : K ⥤ Sheaf J D}
    (E : Cocone (F ⋙ sheafToPresheaf J D)) (hE : IsColimit E) : IsColimit (sheafifyCocone E) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Sheaf.sheafifyCocone E)

full_name: CategoryTheory.Sheaf.instHasColimitsOfShape
code: instance [HasColimitsOfShape K D] : HasColimitsOfShape K (Sheaf J D) 
goal: CategoryTheory.Limits.HasColimitsOfShape K (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.Sheaf.instHasFiniteCoproducts
code: instance [HasFiniteCoproducts D] : HasFiniteCoproducts (Sheaf J D) 
goal: CategoryTheory.Limits.HasFiniteCoproducts (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.Sheaf.instHasFiniteColimits
code: instance [HasFiniteColimits D] : HasFiniteColimits (Sheaf J D) 
goal: CategoryTheory.Limits.HasFiniteColimits (CategoryTheory.Sheaf J D)

full_name: CategoryTheory.Sheaf.instHasColimitsOfSize
code: instance [HasColimitsOfSize.{u₁, u₂} D] : HasColimitsOfSize.{u₁, u₂} (Sheaf J D) 
goal: CategoryTheory.Limits.HasColimitsOfSize.{u₁, u₂, max u w', max (max (max w u) w') v} (CategoryTheory.Sheaf J D)