File: Mathlib/CategoryTheory/Limits/FunctorCategory.lean

full_name: CategoryTheory.Limits.limit.lift_π_app
code: @[reassoc (attr := simp)]
theorem limit.lift_π_app (H : J ⥤ K ⥤ C) [HasLimit H] (c : Cone H) (j : J) (k : K) :
    (limit.lift H c).app k ≫ (limit.π H j).app k = (c.π.app j).app k 
goal: (CategoryTheory.Limits.limit.lift H c).app k ≫ (CategoryTheory.Limits.limit.π H j).app k = (c.π.app j).app k

full_name: CategoryTheory.Limits.colimit.ι_desc_app
code: @[reassoc (attr := simp)]
theorem colimit.ι_desc_app (H : J ⥤ K ⥤ C) [HasColimit H] (c : Cocone H) (j : J) (k : K) :
    (colimit.ι H j).app k ≫ (colimit.desc H c).app k = (c.ι.app j).app k 
goal: (CategoryTheory.Limits.colimit.ι H j).app k ≫ (CategoryTheory.Limits.colimit.desc H c).app k = (c.ι.app j).app k

full_name: CategoryTheory.Limits.evaluationJointlyReflectsLimits
code: /-- The evaluation functors jointly reflect limits: that is, to show a cone is a limit of `F`
it suffices to show that each evaluation cone is a limit. In other words, to prove a cone is
limiting you can show it's pointwise limiting.
-/
def evaluationJointlyReflectsLimits {F : J ⥤ K ⥤ C} (c : Cone F)
    (t : ∀ k : K, IsLimit (((evaluation K C).obj k).mapCone c)) : IsLimit c 
goal: CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.combineCones
code: /-- Given a functor `F` and a collection of limit cones for each diagram `X ↦ F X k`, we can stitch
them together to give a cone for the diagram `F`.
`combinedIsLimit` shows that the new cone is limiting, and `evalCombined` shows it is
(essentially) made up of the original cones.
-/
@[simps]
def combineCones (F : J ⥤ K ⥤ C) (c : ∀ k : K, LimitCone (F.flip.obj k)) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.combineCones_π_app_app
code: /-- Given a functor `F` and a collection of limit cones for each diagram `X ↦ F X k`, we can stitch
them together to give a cone for the diagram `F`.
`combinedIsLimit` shows that the new cone is limiting, and `evalCombined` shows it is
(essentially) made up of the original cones.
-/
@[simps]
def combineCones (F : J ⥤ K ⥤ C) (c : ∀ k : K, LimitCone (F.flip.obj k)) : Cone F 
goal: ((CategoryTheory.Limits.combineCones F c).π.app j).app k = (c k).cone.π.app j

full_name: CategoryTheory.Limits.combineCones_pt_map
code: /-- Given a functor `F` and a collection of limit cones for each diagram `X ↦ F X k`, we can stitch
them together to give a cone for the diagram `F`.
`combinedIsLimit` shows that the new cone is limiting, and `evalCombined` shows it is
(essentially) made up of the original cones.
-/
@[simps]
def combineCones (F : J ⥤ K ⥤ C) (c : ∀ k : K, LimitCone (F.flip.obj k)) : Cone F 
goal: (CategoryTheory.Limits.combineCones F c).pt.map f =
  (c k₂).isLimit.lift { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ F.flip.map f }

full_name: CategoryTheory.Limits.combineCones_pt_obj
code: /-- Given a functor `F` and a collection of limit cones for each diagram `X ↦ F X k`, we can stitch
them together to give a cone for the diagram `F`.
`combinedIsLimit` shows that the new cone is limiting, and `evalCombined` shows it is
(essentially) made up of the original cones.
-/
@[simps]
def combineCones (F : J ⥤ K ⥤ C) (c : ∀ k : K, LimitCone (F.flip.obj k)) : Cone F 
goal: (CategoryTheory.Limits.combineCones F c).pt.obj k = (c k).cone.pt

full_name: CategoryTheory.Limits.evaluateCombinedCones
code: /-- The stitched together cones each project down to the original given cones (up to iso). -/
def evaluateCombinedCones (F : J ⥤ K ⥤ C) (c : ∀ k : K, LimitCone (F.flip.obj k)) (k : K) :
    ((evaluation K C).obj k).mapCone (combineCones F c) ≅ (c k).cone 
goal: ((CategoryTheory.evaluation K C).obj k).mapCone (CategoryTheory.Limits.combineCones F c) ≅ (c k).cone

full_name: CategoryTheory.Limits.combinedIsLimit
code: /-- Stitching together limiting cones gives a limiting cone. -/
def combinedIsLimit (F : J ⥤ K ⥤ C) (c : ∀ k : K, LimitCone (F.flip.obj k)) :
    IsLimit (combineCones F c) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.combineCones F c)

full_name: CategoryTheory.Limits.evaluationJointlyReflectsColimits
code: /-- The evaluation functors jointly reflect colimits: that is, to show a cocone is a colimit of `F`
it suffices to show that each evaluation cocone is a colimit. In other words, to prove a cocone is
colimiting you can show it's pointwise colimiting.
-/
def evaluationJointlyReflectsColimits {F : J ⥤ K ⥤ C} (c : Cocone F)
    (t : ∀ k : K, IsColimit (((evaluation K C).obj k).mapCocone c)) : IsColimit c 
goal: CategoryTheory.Limits.IsColimit c

full_name: CategoryTheory.Limits.combineCocones_pt_obj
code: /--
Given a functor `F` and a collection of colimit cocones for each diagram `X ↦ F X k`, we can stitch
them together to give a cocone for the diagram `F`.
`combinedIsColimit` shows that the new cocone is colimiting, and `evalCombined` shows it is
(essentially) made up of the original cocones.
-/
@[simps]
def combineCocones (F : J ⥤ K ⥤ C) (c : ∀ k : K, ColimitCocone (F.flip.obj k)) : Cocone F 
goal: (CategoryTheory.Limits.combineCocones F c).pt.obj k = (c k).cocone.pt

full_name: CategoryTheory.Limits.combineCocones_ι_app_app
code: /--
Given a functor `F` and a collection of colimit cocones for each diagram `X ↦ F X k`, we can stitch
them together to give a cocone for the diagram `F`.
`combinedIsColimit` shows that the new cocone is colimiting, and `evalCombined` shows it is
(essentially) made up of the original cocones.
-/
@[simps]
def combineCocones (F : J ⥤ K ⥤ C) (c : ∀ k : K, ColimitCocone (F.flip.obj k)) : Cocone F 
goal: ((CategoryTheory.Limits.combineCocones F c).ι.app j).app k = (c k).cocone.ι.app j

full_name: CategoryTheory.Limits.combineCocones_pt_map
code: /--
Given a functor `F` and a collection of colimit cocones for each diagram `X ↦ F X k`, we can stitch
them together to give a cocone for the diagram `F`.
`combinedIsColimit` shows that the new cocone is colimiting, and `evalCombined` shows it is
(essentially) made up of the original cocones.
-/
@[simps]
def combineCocones (F : J ⥤ K ⥤ C) (c : ∀ k : K, ColimitCocone (F.flip.obj k)) : Cocone F 
goal: (CategoryTheory.Limits.combineCocones F c).pt.map f =
  (c k₁).isColimit.desc { pt := (c k₂).cocone.pt, ι := F.flip.map f ≫ (c k₂).cocone.ι }

full_name: CategoryTheory.Limits.combineCocones
code: /--
Given a functor `F` and a collection of colimit cocones for each diagram `X ↦ F X k`, we can stitch
them together to give a cocone for the diagram `F`.
`combinedIsColimit` shows that the new cocone is colimiting, and `evalCombined` shows it is
(essentially) made up of the original cocones.
-/
@[simps]
def combineCocones (F : J ⥤ K ⥤ C) (c : ∀ k : K, ColimitCocone (F.flip.obj k)) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.evaluateCombinedCocones
code: /-- The stitched together cocones each project down to the original given cocones (up to iso). -/
def evaluateCombinedCocones (F : J ⥤ K ⥤ C) (c : ∀ k : K, ColimitCocone (F.flip.obj k)) (k : K) :
    ((evaluation K C).obj k).mapCocone (combineCocones F c) ≅ (c k).cocone 
goal: ((CategoryTheory.evaluation K C).obj k).mapCocone (CategoryTheory.Limits.combineCocones F c) ≅ (c k).cocone

full_name: CategoryTheory.Limits.combinedIsColimit
code: /-- Stitching together colimiting cocones gives a colimiting cocone. -/
def combinedIsColimit (F : J ⥤ K ⥤ C) (c : ∀ k : K, ColimitCocone (F.flip.obj k)) :
    IsColimit (combineCocones F c) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.combineCocones F c)

full_name: CategoryTheory.Limits.functorCategoryHasLimitsOfShape
code: instance functorCategoryHasLimitsOfShape [HasLimitsOfShape J C] : HasLimitsOfShape J (K ⥤ C) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (K ⥤ C)

full_name: CategoryTheory.Limits.functorCategoryHasColimitsOfShape
code: instance functorCategoryHasColimitsOfShape [HasColimitsOfShape J C] :
    HasColimitsOfShape J (K ⥤ C) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (K ⥤ C)

full_name: CategoryTheory.Limits.functorCategoryHasLimitsOfSize
code: instance functorCategoryHasLimitsOfSize [HasLimitsOfSize.{v₁, u₁} C] :
    HasLimitsOfSize.{v₁, u₁} (K ⥤ C) 
goal: CategoryTheory.Limits.HasLimitsOfSize.{v₁, u₁, max u₂ v, max (max (max u u₂) v) v₂} (K ⥤ C)

full_name: CategoryTheory.Limits.functorCategoryHasColimitsOfSize
code: instance functorCategoryHasColimitsOfSize [HasColimitsOfSize.{v₁, u₁} C] :
    HasColimitsOfSize.{v₁, u₁} (K ⥤ C) 
goal: CategoryTheory.Limits.HasColimitsOfSize.{v₁, u₁, max u₂ v, max (max (max u u₂) v) v₂} (K ⥤ C)

full_name: CategoryTheory.Limits.evaluationPreservesLimitsOfShape
code: instance evaluationPreservesLimitsOfShape [HasLimitsOfShape J C] (k : K) :
    PreservesLimitsOfShape J ((evaluation K C).obj k) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J ((CategoryTheory.evaluation K C).obj k)

full_name: CategoryTheory.Limits.limitObjIsoLimitCompEvaluation
code: /-- If `F : J ⥤ K ⥤ C` is a functor into a functor category which has a limit,
then the evaluation of that limit at `k` is the limit of the evaluations of `F.obj j` at `k`.
-/
def limitObjIsoLimitCompEvaluation [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) (k : K) :
    (limit F).obj k ≅ limit (F ⋙ (evaluation K C).obj k) 
goal: (CategoryTheory.Limits.limit F).obj k ≅ CategoryTheory.Limits.limit (F ⋙ (CategoryTheory.evaluation K C).obj k)

full_name: CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_hom_π
code: @[reassoc (attr := simp)]
theorem limitObjIsoLimitCompEvaluation_hom_π [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J)
    (k : K) :
    (limitObjIsoLimitCompEvaluation F k).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j =
      (limit.π F j).app k 
goal: (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F k).hom ≫
    CategoryTheory.Limits.limit.π (F ⋙ (CategoryTheory.evaluation K C).obj k) j =
  (CategoryTheory.Limits.limit.π F j).app k

full_name: CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_inv_π_app
code: @[reassoc (attr := simp)]
theorem limitObjIsoLimitCompEvaluation_inv_π_app [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J)
    (k : K) :
    (limitObjIsoLimitCompEvaluation F k).inv ≫ (limit.π F j).app k =
      limit.π (F ⋙ (evaluation K C).obj k) j 
goal: (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F k).inv ≫ (CategoryTheory.Limits.limit.π F j).app k =
  CategoryTheory.Limits.limit.π (F ⋙ (CategoryTheory.evaluation K C).obj k) j

full_name: CategoryTheory.Limits.limit_map_limitObjIsoLimitCompEvaluation_hom
code: @[reassoc (attr := simp)]
theorem limit_map_limitObjIsoLimitCompEvaluation_hom [HasLimitsOfShape J C] {i j : K}
    (F : J ⥤ K ⥤ C) (f : i ⟶ j) : (limit F).map f ≫ (limitObjIsoLimitCompEvaluation _ _).hom =
    (limitObjIsoLimitCompEvaluation _ _).hom ≫ limMap (whiskerLeft _ ((evaluation _ _).map f)) 
goal: (CategoryTheory.Limits.limit F).map f ≫ (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F j).hom =
  (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F i).hom ≫
    CategoryTheory.Limits.limMap (CategoryTheory.whiskerLeft F ((CategoryTheory.evaluation K C).map f))

full_name: CategoryTheory.Limits.limitObjIsoLimitCompEvaluation_inv_limit_map
code: @[reassoc (attr := simp)]
theorem limitObjIsoLimitCompEvaluation_inv_limit_map [HasLimitsOfShape J C] {i j : K}
    (F : J ⥤ K ⥤ C) (f : i ⟶ j) : (limitObjIsoLimitCompEvaluation _ _).inv ≫ (limit F).map f =
    limMap (whiskerLeft _ ((evaluation _ _).map f)) ≫ (limitObjIsoLimitCompEvaluation _ _).inv 
goal: (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F i).inv ≫ (CategoryTheory.Limits.limit F).map f =
  CategoryTheory.Limits.limMap (CategoryTheory.whiskerLeft F ((CategoryTheory.evaluation K C).map f)) ≫
    (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F j).inv

full_name: CategoryTheory.Limits.limit_obj_ext
code: @[ext]
theorem limit_obj_ext {H : J ⥤ K ⥤ C} [HasLimitsOfShape J C] {k : K} {W : C}
    {f g : W ⟶ (limit H).obj k}
    (w : ∀ j, f ≫ (Limits.limit.π H j).app k = g ≫ (Limits.limit.π H j).app k) : f = g 
goal: f = g

full_name: CategoryTheory.Limits.evaluationPreservesColimitsOfShape
code: instance evaluationPreservesColimitsOfShape [HasColimitsOfShape J C] (k : K) :
    PreservesColimitsOfShape J ((evaluation K C).obj k) 
goal: CategoryTheory.Limits.PreservesColimitsOfShape J ((CategoryTheory.evaluation K C).obj k)

full_name: CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation
code: /-- If `F : J ⥤ K ⥤ C` is a functor into a functor category which has a colimit,
then the evaluation of that colimit at `k` is the colimit of the evaluations of `F.obj j` at `k`.
-/
def colimitObjIsoColimitCompEvaluation [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) (k : K) :
    (colimit F).obj k ≅ colimit (F ⋙ (evaluation K C).obj k) 
goal: (CategoryTheory.Limits.colimit F).obj k ≅ CategoryTheory.Limits.colimit (F ⋙ (CategoryTheory.evaluation K C).obj k)

full_name: CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_ι_inv
code: @[reassoc (attr := simp)]
theorem colimitObjIsoColimitCompEvaluation_ι_inv [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) (j : J)
    (k : K) :
    colimit.ι (F ⋙ (evaluation K C).obj k) j ≫ (colimitObjIsoColimitCompEvaluation F k).inv =
      (colimit.ι F j).app k 
goal: CategoryTheory.Limits.colimit.ι (F ⋙ (CategoryTheory.evaluation K C).obj k) j ≫
    (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F k).inv =
  (CategoryTheory.Limits.colimit.ι F j).app k

full_name: CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_ι_app_hom
code: @[reassoc (attr := simp)]
theorem colimitObjIsoColimitCompEvaluation_ι_app_hom [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C)
    (j : J) (k : K) :
    (colimit.ι F j).app k ≫ (colimitObjIsoColimitCompEvaluation F k).hom =
      colimit.ι (F ⋙ (evaluation K C).obj k) j 
goal: (CategoryTheory.Limits.colimit.ι F j).app k ≫ (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F k).hom =
  CategoryTheory.Limits.colimit.ι (F ⋙ (CategoryTheory.evaluation K C).obj k) j

full_name: CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation_inv_colimit_map
code: @[reassoc (attr := simp)]
theorem colimitObjIsoColimitCompEvaluation_inv_colimit_map [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C)
    {i j : K} (f : i ⟶ j) :
    (colimitObjIsoColimitCompEvaluation _ _).inv ≫ (colimit F).map f =
      colimMap (whiskerLeft _ ((evaluation _ _).map f)) ≫
        (colimitObjIsoColimitCompEvaluation _ _).inv 
goal: (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F i).inv ≫ (CategoryTheory.Limits.colimit F).map f =
  CategoryTheory.Limits.colimMap (CategoryTheory.whiskerLeft F ((CategoryTheory.evaluation K C).map f)) ≫
    (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F j).inv

full_name: CategoryTheory.Limits.colimit_map_colimitObjIsoColimitCompEvaluation_hom
code: @[reassoc (attr := simp)]
theorem colimit_map_colimitObjIsoColimitCompEvaluation_hom [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C)
    {i j : K} (f : i ⟶ j) :
    (colimit F).map f ≫ (colimitObjIsoColimitCompEvaluation _ _).hom =
      (colimitObjIsoColimitCompEvaluation _ _).hom ≫
        colimMap (whiskerLeft _ ((evaluation _ _).map f)) 
goal: (CategoryTheory.Limits.colimit F).map f ≫ (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F j).hom =
  (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F i).hom ≫
    CategoryTheory.Limits.colimMap (CategoryTheory.whiskerLeft F ((CategoryTheory.evaluation K C).map f))

full_name: CategoryTheory.Limits.colimit_obj_ext
code: @[ext]
theorem colimit_obj_ext {H : J ⥤ K ⥤ C} [HasColimitsOfShape J C] {k : K} {W : C}
    {f g : (colimit H).obj k ⟶ W} (w : ∀ j, (colimit.ι H j).app k ≫ f = (colimit.ι H j).app k ≫ g) :
    f = g 
goal: f = g

full_name: CategoryTheory.Limits.evaluationPreservesLimits
code: instance evaluationPreservesLimits [HasLimits C] (k : K) :
    PreservesLimits ((evaluation K C).obj k) 
goal: CategoryTheory.Limits.PreservesLimits ((CategoryTheory.evaluation K C).obj k)

full_name: CategoryTheory.Limits.preservesLimitOfEvaluation
code: /-- `F : D ⥤ K ⥤ C` preserves the limit of some `G : J ⥤ D` if it does for each `k : K`. -/
def preservesLimitOfEvaluation (F : D ⥤ K ⥤ C) (G : J ⥤ D)
    (H : ∀ k : K, PreservesLimit G (F ⋙ (evaluation K C).obj k : D ⥤ C)) : PreservesLimit G F 
goal: CategoryTheory.Limits.PreservesLimit G F

full_name: CategoryTheory.Limits.preservesLimitsOfShapeOfEvaluation
code: /-- `F : D ⥤ K ⥤ C` preserves limits of shape `J` if it does for each `k : K`. -/
def preservesLimitsOfShapeOfEvaluation (F : D ⥤ K ⥤ C) (J : Type*) [Category J]
    (_ : ∀ k : K, PreservesLimitsOfShape J (F ⋙ (evaluation K C).obj k)) :
    PreservesLimitsOfShape J F 
goal: ((k : K) → CategoryTheory.Limits.PreservesLimitsOfShape J (F ⋙ (CategoryTheory.evaluation K C).obj k)) →
  CategoryTheory.Limits.PreservesLimitsOfShape J F

full_name: CategoryTheory.Limits.preservesLimitsOfEvaluation
code: /-- `F : D ⥤ K ⥤ C` preserves all limits if it does for each `k : K`. -/
def preservesLimitsOfEvaluation (F : D ⥤ K ⥤ C)
    (_ : ∀ k : K, PreservesLimitsOfSize.{w', w} (F ⋙ (evaluation K C).obj k)) :
    PreservesLimitsOfSize.{w', w} F 
goal: ((k : K) →
    CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, v', v, u', u} (F ⋙ (CategoryTheory.evaluation K C).obj k)) →
  CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, v', max u₂ v, u', max (max (max u u₂) v) v₂} F

full_name: CategoryTheory.Limits.preservesLimitsConst
code: /-- The constant functor `C ⥤ (D ⥤ C)` preserves limits. -/
instance preservesLimitsConst : PreservesLimitsOfSize.{w', w} (const D : C ⥤ _) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, v, max u' v, u, max (max (max u u') v) v'}
  (CategoryTheory.Functor.const D)

full_name: CategoryTheory.Limits.evaluationPreservesColimits
code: instance evaluationPreservesColimits [HasColimits C] (k : K) :
    PreservesColimits ((evaluation K C).obj k) 
goal: CategoryTheory.Limits.PreservesColimits ((CategoryTheory.evaluation K C).obj k)

full_name: CategoryTheory.Limits.preservesColimitOfEvaluation
code: /-- `F : D ⥤ K ⥤ C` preserves the colimit of some `G : J ⥤ D` if it does for each `k : K`. -/
def preservesColimitOfEvaluation (F : D ⥤ K ⥤ C) (G : J ⥤ D)
    (H : ∀ k, PreservesColimit G (F ⋙ (evaluation K C).obj k)) : PreservesColimit G F 
goal: CategoryTheory.Limits.PreservesColimit G F

full_name: CategoryTheory.Limits.preservesColimitsOfShapeOfEvaluation
code: /-- `F : D ⥤ K ⥤ C` preserves all colimits of shape `J` if it does for each `k : K`. -/
def preservesColimitsOfShapeOfEvaluation (F : D ⥤ K ⥤ C) (J : Type*) [Category J]
    (_ : ∀ k : K, PreservesColimitsOfShape J (F ⋙ (evaluation K C).obj k)) :
    PreservesColimitsOfShape J F 
goal: ((k : K) → CategoryTheory.Limits.PreservesColimitsOfShape J (F ⋙ (CategoryTheory.evaluation K C).obj k)) →
  CategoryTheory.Limits.PreservesColimitsOfShape J F

full_name: CategoryTheory.Limits.preservesColimitsOfEvaluation
code: /-- `F : D ⥤ K ⥤ C` preserves all colimits if it does for each `k : K`. -/
def preservesColimitsOfEvaluation (F : D ⥤ K ⥤ C)
    (_ : ∀ k : K, PreservesColimitsOfSize.{w', w} (F ⋙ (evaluation K C).obj k)) :
    PreservesColimitsOfSize.{w', w} F 
goal: ((k : K) →
    CategoryTheory.Limits.PreservesColimitsOfSize.{w', w, v', v, u', u} (F ⋙ (CategoryTheory.evaluation K C).obj k)) →
  CategoryTheory.Limits.PreservesColimitsOfSize.{w', w, v', max u₂ v, u', max (max (max u u₂) v) v₂} F

full_name: CategoryTheory.Limits.preservesColimitsConst
code: /-- The constant functor `C ⥤ (D ⥤ C)` preserves colimits. -/
instance preservesColimitsConst : PreservesColimitsOfSize.{w', w} (const D : C ⥤ _) 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{w', w, v, max u' v, u, max (max (max u u') v) v'}
  (CategoryTheory.Functor.const D)

full_name: CategoryTheory.Limits.limitIsoFlipCompLim_hom_app
code: /-- The limit of a diagram `F : J ⥤ K ⥤ C` is isomorphic to the functor given by
the individual limits on objects. -/
@[simps!]
def limitIsoFlipCompLim [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) : limit F ≅ F.flip ⋙ lim 
goal: (CategoryTheory.Limits.limitIsoFlipCompLim F).hom.app X = (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F X).hom

full_name: CategoryTheory.Limits.limitIsoFlipCompLim_inv_app
code: /-- The limit of a diagram `F : J ⥤ K ⥤ C` is isomorphic to the functor given by
the individual limits on objects. -/
@[simps!]
def limitIsoFlipCompLim [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) : limit F ≅ F.flip ⋙ lim 
goal: (CategoryTheory.Limits.limitIsoFlipCompLim F).inv.app X = (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F X).inv

full_name: CategoryTheory.Limits.limitIsoFlipCompLim
code: /-- The limit of a diagram `F : J ⥤ K ⥤ C` is isomorphic to the functor given by
the individual limits on objects. -/
@[simps!]
def limitIsoFlipCompLim [HasLimitsOfShape J C] (F : J ⥤ K ⥤ C) : limit F ≅ F.flip ⋙ lim 
goal: CategoryTheory.Limits.limit F ≅ F.flip ⋙ CategoryTheory.Limits.lim

full_name: CategoryTheory.Limits.limitFlipIsoCompLim_hom_app
code: /-- A variant of `limitIsoFlipCompLim` where the arguments of `F` are flipped. -/
@[simps!]
def limitFlipIsoCompLim [HasLimitsOfShape J C] (F : K ⥤ J ⥤ C) : limit F.flip ≅ F ⋙ lim 
goal: (CategoryTheory.Limits.limitFlipIsoCompLim F).hom.app X =
  (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F.flip X).hom ≫
    (CategoryTheory.Limits.HasLimit.isoOfNatIso (CategoryTheory.flipCompEvaluation F X)).hom

full_name: CategoryTheory.Limits.limitFlipIsoCompLim_inv_app
code: /-- A variant of `limitIsoFlipCompLim` where the arguments of `F` are flipped. -/
@[simps!]
def limitFlipIsoCompLim [HasLimitsOfShape J C] (F : K ⥤ J ⥤ C) : limit F.flip ≅ F ⋙ lim 
goal: (CategoryTheory.Limits.limitFlipIsoCompLim F).inv.app X =
  (CategoryTheory.Limits.HasLimit.isoOfNatIso (CategoryTheory.flipCompEvaluation F X)).inv ≫
    (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation F.flip X).inv

full_name: CategoryTheory.Limits.limitFlipIsoCompLim
code: /-- A variant of `limitIsoFlipCompLim` where the arguments of `F` are flipped. -/
@[simps!]
def limitFlipIsoCompLim [HasLimitsOfShape J C] (F : K ⥤ J ⥤ C) : limit F.flip ≅ F ⋙ lim 
goal: CategoryTheory.Limits.limit F.flip ≅ F ⋙ CategoryTheory.Limits.lim

full_name: CategoryTheory.Limits.limitIsoSwapCompLim_hom_app
code: /-- For a functor `G : J ⥤ K ⥤ C`, its limit `K ⥤ C` is given by `(G' : K ⥤ J ⥤ C) ⋙ lim`.
Note that this does not require `K` to be small.
-/
@[simps!]
def limitIsoSwapCompLim [HasLimitsOfShape J C] (G : J ⥤ K ⥤ C) :
    limit G ≅ curry.obj (Prod.swap K J ⋙ uncurry.obj G) ⋙ lim 
goal: (CategoryTheory.Limits.limitIsoSwapCompLim G).hom.app X =
  (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation G X).hom ≫
    CategoryTheory.Limits.limMap ((CategoryTheory.flipIsoCurrySwapUncurry G).hom.app X)

full_name: CategoryTheory.Limits.limitIsoSwapCompLim
code: /-- For a functor `G : J ⥤ K ⥤ C`, its limit `K ⥤ C` is given by `(G' : K ⥤ J ⥤ C) ⋙ lim`.
Note that this does not require `K` to be small.
-/
@[simps!]
def limitIsoSwapCompLim [HasLimitsOfShape J C] (G : J ⥤ K ⥤ C) :
    limit G ≅ curry.obj (Prod.swap K J ⋙ uncurry.obj G) ⋙ lim 
goal: CategoryTheory.Limits.limit G ≅
  CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ CategoryTheory.uncurry.obj G) ⋙ CategoryTheory.Limits.lim

full_name: CategoryTheory.Limits.limitIsoSwapCompLim_inv_app
code: /-- For a functor `G : J ⥤ K ⥤ C`, its limit `K ⥤ C` is given by `(G' : K ⥤ J ⥤ C) ⋙ lim`.
Note that this does not require `K` to be small.
-/
@[simps!]
def limitIsoSwapCompLim [HasLimitsOfShape J C] (G : J ⥤ K ⥤ C) :
    limit G ≅ curry.obj (Prod.swap K J ⋙ uncurry.obj G) ⋙ lim 
goal: (CategoryTheory.Limits.limitIsoSwapCompLim G).inv.app X =
  CategoryTheory.Limits.limMap ((CategoryTheory.flipIsoCurrySwapUncurry G).inv.app X) ≫
    (CategoryTheory.Limits.limitObjIsoLimitCompEvaluation G X).inv

full_name: CategoryTheory.Limits.colimitIsoFlipCompColim_hom_app
code: /-- The colimit of a diagram `F : J ⥤ K ⥤ C` is isomorphic to the functor given by
the individual colimits on objects. -/
@[simps!]
def colimitIsoFlipCompColim [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) : colimit F ≅ F.flip ⋙ colim 
goal: (CategoryTheory.Limits.colimitIsoFlipCompColim F).hom.app X =
  (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F X).hom

full_name: CategoryTheory.Limits.colimitIsoFlipCompColim
code: /-- The colimit of a diagram `F : J ⥤ K ⥤ C` is isomorphic to the functor given by
the individual colimits on objects. -/
@[simps!]
def colimitIsoFlipCompColim [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) : colimit F ≅ F.flip ⋙ colim 
goal: CategoryTheory.Limits.colimit F ≅ F.flip ⋙ CategoryTheory.Limits.colim

full_name: CategoryTheory.Limits.colimitIsoFlipCompColim_inv_app
code: /-- The colimit of a diagram `F : J ⥤ K ⥤ C` is isomorphic to the functor given by
the individual colimits on objects. -/
@[simps!]
def colimitIsoFlipCompColim [HasColimitsOfShape J C] (F : J ⥤ K ⥤ C) : colimit F ≅ F.flip ⋙ colim 
goal: (CategoryTheory.Limits.colimitIsoFlipCompColim F).inv.app X =
  (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F X).inv

full_name: CategoryTheory.Limits.colimitFlipIsoCompColim_inv_app
code: /-- A variant of `colimit_iso_flip_comp_colim` where the arguments of `F` are flipped. -/
@[simps!]
def colimitFlipIsoCompColim [HasColimitsOfShape J C] (F : K ⥤ J ⥤ C) : colimit F.flip ≅ F ⋙ colim 
goal: (CategoryTheory.Limits.colimitFlipIsoCompColim F).inv.app X =
  (CategoryTheory.Limits.HasColimit.isoOfNatIso (CategoryTheory.flipCompEvaluation F X)).inv ≫
    (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F.flip X).inv

full_name: CategoryTheory.Limits.colimitFlipIsoCompColim
code: /-- A variant of `colimit_iso_flip_comp_colim` where the arguments of `F` are flipped. -/
@[simps!]
def colimitFlipIsoCompColim [HasColimitsOfShape J C] (F : K ⥤ J ⥤ C) : colimit F.flip ≅ F ⋙ colim 
goal: CategoryTheory.Limits.colimit F.flip ≅ F ⋙ CategoryTheory.Limits.colim

full_name: CategoryTheory.Limits.colimitFlipIsoCompColim_hom_app
code: /-- A variant of `colimit_iso_flip_comp_colim` where the arguments of `F` are flipped. -/
@[simps!]
def colimitFlipIsoCompColim [HasColimitsOfShape J C] (F : K ⥤ J ⥤ C) : colimit F.flip ≅ F ⋙ colim 
goal: (CategoryTheory.Limits.colimitFlipIsoCompColim F).hom.app X =
  (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F.flip X).hom ≫
    (CategoryTheory.Limits.HasColimit.isoOfNatIso (CategoryTheory.flipCompEvaluation F X)).hom

full_name: CategoryTheory.Limits.colimitIsoSwapCompColim_hom_app
code: /-- For a functor `G : J ⥤ K ⥤ C`, its colimit `K ⥤ C` is given by `(G' : K ⥤ J ⥤ C) ⋙ colim`.
Note that this does not require `K` to be small.
-/
@[simps!]
def colimitIsoSwapCompColim [HasColimitsOfShape J C] (G : J ⥤ K ⥤ C) :
    colimit G ≅ curry.obj (Prod.swap K J ⋙ uncurry.obj G) ⋙ colim 
goal: (CategoryTheory.Limits.colimitIsoSwapCompColim G).hom.app X =
  (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation G X).hom ≫
    CategoryTheory.Limits.colimMap ((CategoryTheory.flipIsoCurrySwapUncurry G).hom.app X)

full_name: CategoryTheory.Limits.colimitIsoSwapCompColim_inv_app
code: /-- For a functor `G : J ⥤ K ⥤ C`, its colimit `K ⥤ C` is given by `(G' : K ⥤ J ⥤ C) ⋙ colim`.
Note that this does not require `K` to be small.
-/
@[simps!]
def colimitIsoSwapCompColim [HasColimitsOfShape J C] (G : J ⥤ K ⥤ C) :
    colimit G ≅ curry.obj (Prod.swap K J ⋙ uncurry.obj G) ⋙ colim 
goal: (CategoryTheory.Limits.colimitIsoSwapCompColim G).inv.app X =
  CategoryTheory.Limits.colimMap ((CategoryTheory.flipIsoCurrySwapUncurry G).inv.app X) ≫
    (CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation G X).inv

full_name: CategoryTheory.Limits.colimitIsoSwapCompColim
code: /-- For a functor `G : J ⥤ K ⥤ C`, its colimit `K ⥤ C` is given by `(G' : K ⥤ J ⥤ C) ⋙ colim`.
Note that this does not require `K` to be small.
-/
@[simps!]
def colimitIsoSwapCompColim [HasColimitsOfShape J C] (G : J ⥤ K ⥤ C) :
    colimit G ≅ curry.obj (Prod.swap K J ⋙ uncurry.obj G) ⋙ colim 
goal: CategoryTheory.Limits.colimit G ≅
  CategoryTheory.curry.obj (CategoryTheory.Prod.swap K J ⋙ CategoryTheory.uncurry.obj G) ⋙ CategoryTheory.Limits.colim