File: Mathlib/CategoryTheory/Limits/Preserves/Basic.lean

full_name: CategoryTheory.Limits.PreservesLimit
code: /-- A functor `F` preserves limits of `K` (written as `PreservesLimit K F`)
if `F` maps any limit cone over `K` to a limit cone.
-/
class PreservesLimit (K : J ⥤ C) (F : C ⥤ D) where
  preserves : ∀ {c : Cone K}, IsLimit c → IsLimit (F.mapCone c)
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) w)

full_name: CategoryTheory.Limits.PreservesLimit.preserves
code: /-- A functor `F` preserves limits of `K` (written as `PreservesLimit K F`)
if `F` maps any limit cone over `K` to a limit cone.
-/
class PreservesLimit (K : J ⥤ C) (F : C ⥤ D) where
  preserves : ∀ {c : Cone K}, IsLimit c → IsLimit (F.mapCone c)
goal: CategoryTheory.Limits.IsLimit c → CategoryTheory.Limits.IsLimit (F.mapCone c)

full_name: CategoryTheory.Limits.PreservesColimit
code: /-- A functor `F` preserves colimits of `K` (written as `PreservesColimit K F`)
if `F` maps any colimit cocone over `K` to a colimit cocone.
-/
class PreservesColimit (K : J ⥤ C) (F : C ⥤ D) where
  preserves : ∀ {c : Cocone K}, IsColimit c → IsColimit (F.mapCocone c)
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) w)

full_name: CategoryTheory.Limits.PreservesColimit.preserves
code: /-- A functor `F` preserves colimits of `K` (written as `PreservesColimit K F`)
if `F` maps any colimit cocone over `K` to a colimit cocone.
-/
class PreservesColimit (K : J ⥤ C) (F : C ⥤ D) where
  preserves : ∀ {c : Cocone K}, IsColimit c → IsColimit (F.mapCocone c)
goal: CategoryTheory.Limits.IsColimit c → CategoryTheory.Limits.IsColimit (F.mapCocone c)

full_name: CategoryTheory.Limits.PreservesLimitsOfShape
code: /-- We say that `F` preserves limits of shape `J` if `F` preserves limits for every diagram
    `K : J ⥤ C`, i.e., `F` maps limit cones over `K` to limit cones. -/
class PreservesLimitsOfShape (J : Type w) [Category.{w'} J] (F : C ⥤ D) where
  preservesLimit : ∀ {K : J ⥤ C}, PreservesLimit K F := by infer_instance
goal: Type (max (max (max (max (max u₁ u₂) v₁) v₂) w) w')

full_name: CategoryTheory.Limits.PreservesLimitsOfShape.preservesLimit
code: /-- We say that `F` preserves limits of shape `J` if `F` preserves limits for every diagram
    `K : J ⥤ C`, i.e., `F` maps limit cones over `K` to limit cones. -/
class PreservesLimitsOfShape (J : Type w) [Category.{w'} J] (F : C ⥤ D) where
  preservesLimit : ∀ {K : J ⥤ C}, PreservesLimit K F := by infer_instance
goal: CategoryTheory.Limits.PreservesLimit K F

full_name: CategoryTheory.Limits.PreservesColimitsOfShape
code: /-- We say that `F` preserves colimits of shape `J` if `F` preserves colimits for every diagram
    `K : J ⥤ C`, i.e., `F` maps colimit cocones over `K` to colimit cocones. -/
class PreservesColimitsOfShape (J : Type w) [Category.{w'} J] (F : C ⥤ D) where
  preservesColimit : ∀ {K : J ⥤ C}, PreservesColimit K F := by infer_instance
goal: Type (max (max (max (max (max u₁ u₂) v₁) v₂) w) w')

full_name: CategoryTheory.Limits.PreservesColimitsOfShape.preservesColimit
code: /-- We say that `F` preserves colimits of shape `J` if `F` preserves colimits for every diagram
    `K : J ⥤ C`, i.e., `F` maps colimit cocones over `K` to colimit cocones. -/
class PreservesColimitsOfShape (J : Type w) [Category.{w'} J] (F : C ⥤ D) where
  preservesColimit : ∀ {K : J ⥤ C}, PreservesColimit K F := by infer_instance
goal: CategoryTheory.Limits.PreservesColimit K F

full_name: CategoryTheory.Limits.PreservesLimitsOfSize
code: /-- `PreservesLimitsOfSize.{v u} F` means that `F` sends all limit cones over any
diagram `J ⥤ C` to limit cones, where `J : Type u` with `[Category.{v} J]`. -/
@[nolint checkUnivs, pp_with_univ]
class PreservesLimitsOfSize (F : C ⥤ D) where
  preservesLimitsOfShape : ∀ {J : Type w} [Category.{w'} J], PreservesLimitsOfShape J F := by
    infer_instance
goal: Type (max (max (max (max (max u₁ u₂) v₁) v₂) (w + 1)) (w' + 1))

full_name: CategoryTheory.Limits.PreservesLimitsOfSize.preservesLimitsOfShape
code: /-- `PreservesLimitsOfSize.{v u} F` means that `F` sends all limit cones over any
diagram `J ⥤ C` to limit cones, where `J : Type u` with `[Category.{v} J]`. -/
@[nolint checkUnivs, pp_with_univ]
class PreservesLimitsOfSize (F : C ⥤ D) where
  preservesLimitsOfShape : ∀ {J : Type w} [Category.{w'} J], PreservesLimitsOfShape J F := by
    infer_instance
goal: CategoryTheory.Limits.PreservesLimitsOfShape J F

full_name: CategoryTheory.Limits.PreservesLimits
code: /-- We say that `F` preserves (small) limits if it sends small
limit cones over any diagram to limit cones. -/
abbrev PreservesLimits (F : C ⥤ D) 
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) (v₂ + 1))

full_name: CategoryTheory.Limits.PreservesColimitsOfSize
code: /-- `PreservesColimitsOfSize.{v u} F` means that `F` sends all colimit cocones over any
diagram `J ⥤ C` to colimit cocones, where `J : Type u` with `[Category.{v} J]`. -/
@[nolint checkUnivs, pp_with_univ]
class PreservesColimitsOfSize (F : C ⥤ D) where
  preservesColimitsOfShape : ∀ {J : Type w} [Category.{w'} J], PreservesColimitsOfShape J F := by
    infer_instance
goal: Type (max (max (max (max (max u₁ u₂) v₁) v₂) (w + 1)) (w' + 1))

full_name: CategoryTheory.Limits.PreservesColimitsOfSize.preservesColimitsOfShape
code: /-- `PreservesColimitsOfSize.{v u} F` means that `F` sends all colimit cocones over any
diagram `J ⥤ C` to colimit cocones, where `J : Type u` with `[Category.{v} J]`. -/
@[nolint checkUnivs, pp_with_univ]
class PreservesColimitsOfSize (F : C ⥤ D) where
  preservesColimitsOfShape : ∀ {J : Type w} [Category.{w'} J], PreservesColimitsOfShape J F := by
    infer_instance
goal: CategoryTheory.Limits.PreservesColimitsOfShape J F

full_name: CategoryTheory.Limits.PreservesColimits
code: /-- We say that `F` preserves (small) limits if it sends small
limit cones over any diagram to limit cones. -/
abbrev PreservesColimits (F : C ⥤ D) 
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) (v₂ + 1))

full_name: CategoryTheory.Limits.isLimitOfPreserves
code: /-- A convenience function for `PreservesLimit`, which takes the functor as an explicit argument to
guide typeclass resolution.
-/
def isLimitOfPreserves (F : C ⥤ D) {c : Cone K} (t : IsLimit c) [PreservesLimit K F] :
    IsLimit (F.mapCone c) 
goal: CategoryTheory.Limits.IsLimit (F.mapCone c)

full_name: CategoryTheory.Limits.isColimitOfPreserves
code: /--
A convenience function for `PreservesColimit`, which takes the functor as an explicit argument to
guide typeclass resolution.
-/
def isColimitOfPreserves (F : C ⥤ D) {c : Cocone K} (t : IsColimit c) [PreservesColimit K F] :
    IsColimit (F.mapCocone c) 
goal: CategoryTheory.Limits.IsColimit (F.mapCocone c)

full_name: CategoryTheory.Limits.preservesLimit_subsingleton
code: instance preservesLimit_subsingleton (K : J ⥤ C) (F : C ⥤ D) :
    Subsingleton (PreservesLimit K F) 
goal: Subsingleton (CategoryTheory.Limits.PreservesLimit K F)

full_name: CategoryTheory.Limits.preservesColimit_subsingleton
code: instance preservesColimit_subsingleton (K : J ⥤ C) (F : C ⥤ D) :
    Subsingleton (PreservesColimit K F) 
goal: Subsingleton (CategoryTheory.Limits.PreservesColimit K F)

full_name: CategoryTheory.Limits.preservesLimitsOfShape_subsingleton
code: instance preservesLimitsOfShape_subsingleton (J : Type w) [Category.{w'} J] (F : C ⥤ D) :
    Subsingleton (PreservesLimitsOfShape J F) 
goal: Subsingleton (CategoryTheory.Limits.PreservesLimitsOfShape J F)

full_name: CategoryTheory.Limits.preservesColimitsOfShape_subsingleton
code: instance preservesColimitsOfShape_subsingleton (J : Type w) [Category.{w'} J] (F : C ⥤ D) :
    Subsingleton (PreservesColimitsOfShape J F) 
goal: Subsingleton (CategoryTheory.Limits.PreservesColimitsOfShape J F)

full_name: CategoryTheory.Limits.preserves_limits_subsingleton
code: instance preserves_limits_subsingleton (F : C ⥤ D) :
    Subsingleton (PreservesLimitsOfSize.{w', w} F) 
goal: Subsingleton (CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F)

full_name: CategoryTheory.Limits.preserves_colimits_subsingleton
code: instance preserves_colimits_subsingleton (F : C ⥤ D) :
    Subsingleton (PreservesColimitsOfSize.{w', w} F) 
goal: Subsingleton (CategoryTheory.Limits.PreservesColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F)

full_name: CategoryTheory.Limits.idPreservesLimits
code: instance idPreservesLimits : PreservesLimitsOfSize.{w', w} (𝟭 C) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, v₁, v₁, u₁, u₁} (𝟭 C)

full_name: CategoryTheory.Limits.idPreservesColimits
code: instance idPreservesColimits : PreservesColimitsOfSize.{w', w} (𝟭 C) 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{w', w, v₁, v₁, u₁, u₁} (𝟭 C)

full_name: CategoryTheory.Limits.instHasLimitCompOfPreservesLimit
code: instance [HasLimit K] {F : C ⥤ D} [PreservesLimit K F] : HasLimit (K ⋙ F) 
goal: CategoryTheory.Limits.HasLimit (K ⋙ F)

full_name: CategoryTheory.Limits.instHasColimitCompOfPreservesColimit
code: instance [HasColimit K] {F : C ⥤ D} [PreservesColimit K F] : HasColimit (K ⋙ F) 
goal: CategoryTheory.Limits.HasColimit (K ⋙ F)

full_name: CategoryTheory.Limits.compPreservesLimit
code: instance compPreservesLimit [PreservesLimit K F] [PreservesLimit (K ⋙ F) G] :
    PreservesLimit K (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesLimit K (F ⋙ G)

full_name: CategoryTheory.Limits.compPreservesLimitsOfShape
code: instance compPreservesLimitsOfShape [PreservesLimitsOfShape J F] [PreservesLimitsOfShape J G] :
    PreservesLimitsOfShape J (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (F ⋙ G)

full_name: CategoryTheory.Limits.compPreservesLimits
code: instance compPreservesLimits [PreservesLimitsOfSize.{w', w} F] [PreservesLimitsOfSize.{w', w} G] :
    PreservesLimitsOfSize.{w', w} (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, v₁, v₃, u₁, u₃} (F ⋙ G)

full_name: CategoryTheory.Limits.compPreservesColimit
code: instance compPreservesColimit [PreservesColimit K F] [PreservesColimit (K ⋙ F) G] :
    PreservesColimit K (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesColimit K (F ⋙ G)

full_name: CategoryTheory.Limits.compPreservesColimitsOfShape
code: instance compPreservesColimitsOfShape [PreservesColimitsOfShape J F]
    [PreservesColimitsOfShape J G] : PreservesColimitsOfShape J (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesColimitsOfShape J (F ⋙ G)

full_name: CategoryTheory.Limits.compPreservesColimits
code: instance compPreservesColimits [PreservesColimitsOfSize.{w', w} F]
    [PreservesColimitsOfSize.{w', w} G] : PreservesColimitsOfSize.{w', w} (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{w', w, v₁, v₃, u₁, u₃} (F ⋙ G)

full_name: CategoryTheory.Limits.preservesLimitOfPreservesLimitCone
code: /-- If F preserves one limit cone for the diagram K,
  then it preserves any limit cone for K. -/
def preservesLimitOfPreservesLimitCone {F : C ⥤ D} {t : Cone K} (h : IsLimit t)
    (hF : IsLimit (F.mapCone t)) : PreservesLimit K F 
goal: CategoryTheory.Limits.PreservesLimit K F

full_name: CategoryTheory.Limits.preservesLimitOfIsoDiagram
code: /-- Transfer preservation of limits along a natural isomorphism in the diagram. -/
def preservesLimitOfIsoDiagram {K₁ K₂ : J ⥤ C} (F : C ⥤ D) (h : K₁ ≅ K₂) [PreservesLimit K₁ F] :
    PreservesLimit K₂ F 
goal: CategoryTheory.Limits.PreservesLimit K₂ F

full_name: CategoryTheory.Limits.preservesLimitOfNatIso
code: /-- Transfer preservation of a limit along a natural isomorphism in the functor. -/
def preservesLimitOfNatIso (K : J ⥤ C) {F G : C ⥤ D} (h : F ≅ G) [PreservesLimit K F] :
    PreservesLimit K G 
goal: CategoryTheory.Limits.PreservesLimit K G

full_name: CategoryTheory.Limits.preservesLimitsOfShapeOfNatIso
code: /-- Transfer preservation of limits of shape along a natural isomorphism in the functor. -/
def preservesLimitsOfShapeOfNatIso {F G : C ⥤ D} (h : F ≅ G) [PreservesLimitsOfShape J F] :
    PreservesLimitsOfShape J G 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J G

full_name: CategoryTheory.Limits.preservesLimitsOfNatIso
code: /-- Transfer preservation of limits along a natural isomorphism in the functor. -/
def preservesLimitsOfNatIso {F G : C ⥤ D} (h : F ≅ G) [PreservesLimitsOfSize.{w, w'} F] :
    PreservesLimitsOfSize.{w, w'} G 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} G

full_name: CategoryTheory.Limits.preservesLimitsOfShapeOfEquiv
code: /-- Transfer preservation of limits along an equivalence in the shape. -/
def preservesLimitsOfShapeOfEquiv {J' : Type w₂} [Category.{w₂'} J'] (e : J ≌ J') (F : C ⥤ D)
    [PreservesLimitsOfShape J F] : PreservesLimitsOfShape J' F 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J' F

full_name: CategoryTheory.Limits.preservesLimitsOfSizeOfUnivLE
code: /-- A functor preserving larger limits also preserves smaller limits. -/
def preservesLimitsOfSizeOfUnivLE (F : C ⥤ D) [UnivLE.{w, w'}] [UnivLE.{w₂, w₂'}]
    [PreservesLimitsOfSize.{w', w₂'} F] : PreservesLimitsOfSize.{w, w₂} F 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, w₂, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.preservesLimitsOfSizeShrink
code: /-- `PreservesLimitsOfSizeShrink.{w w'} F` tries to obtain `PreservesLimitsOfSize.{w w'} F`
from some other `PreservesLimitsOfSize F`.
-/
def preservesLimitsOfSizeShrink (F : C ⥤ D) [PreservesLimitsOfSize.{max w w₂, max w' w₂'} F] :
    PreservesLimitsOfSize.{w, w'} F 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.preservesSmallestLimitsOfPreservesLimits
code: /-- Preserving limits at any universe level implies preserving limits in universe `0`. -/
def preservesSmallestLimitsOfPreservesLimits (F : C ⥤ D) [PreservesLimitsOfSize.{v₃, u₃} F] :
    PreservesLimitsOfSize.{0, 0} F 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{0, 0, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.preservesColimitOfPreservesColimitCocone
code: /-- If F preserves one colimit cocone for the diagram K,
  then it preserves any colimit cocone for K. -/
def preservesColimitOfPreservesColimitCocone {F : C ⥤ D} {t : Cocone K} (h : IsColimit t)
    (hF : IsColimit (F.mapCocone t)) : PreservesColimit K F 
goal: CategoryTheory.Limits.PreservesColimit K F

full_name: CategoryTheory.Limits.preservesColimitOfIsoDiagram
code: /-- Transfer preservation of colimits along a natural isomorphism in the shape. -/
def preservesColimitOfIsoDiagram {K₁ K₂ : J ⥤ C} (F : C ⥤ D) (h : K₁ ≅ K₂) [PreservesColimit K₁ F] :
    PreservesColimit K₂ F 
goal: CategoryTheory.Limits.PreservesColimit K₂ F

full_name: CategoryTheory.Limits.preservesColimitOfNatIso
code: /-- Transfer preservation of a colimit along a natural isomorphism in the functor. -/
def preservesColimitOfNatIso (K : J ⥤ C) {F G : C ⥤ D} (h : F ≅ G) [PreservesColimit K F] :
    PreservesColimit K G 
goal: CategoryTheory.Limits.PreservesColimit K G

full_name: CategoryTheory.Limits.preservesColimitsOfShapeOfNatIso
code: /-- Transfer preservation of colimits of shape along a natural isomorphism in the functor. -/
def preservesColimitsOfShapeOfNatIso {F G : C ⥤ D} (h : F ≅ G) [PreservesColimitsOfShape J F] :
    PreservesColimitsOfShape J G 
goal: CategoryTheory.Limits.PreservesColimitsOfShape J G

full_name: CategoryTheory.Limits.preservesColimitsOfNatIso
code: /-- Transfer preservation of colimits along a natural isomorphism in the functor. -/
def preservesColimitsOfNatIso {F G : C ⥤ D} (h : F ≅ G) [PreservesColimitsOfSize.{w, w'} F] :
    PreservesColimitsOfSize.{w, w'} G 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} G

full_name: CategoryTheory.Limits.preservesColimitsOfShapeOfEquiv
code: /-- Transfer preservation of colimits along an equivalence in the shape. -/
def preservesColimitsOfShapeOfEquiv {J' : Type w₂} [Category.{w₂'} J'] (e : J ≌ J') (F : C ⥤ D)
    [PreservesColimitsOfShape J F] : PreservesColimitsOfShape J' F 
goal: CategoryTheory.Limits.PreservesColimitsOfShape J' F

full_name: CategoryTheory.Limits.preservesColimitsOfSizeOfUnivLE
code: /-- A functor preserving larger colimits also preserves smaller colimits. -/
def preservesColimitsOfSizeOfUnivLE (F : C ⥤ D) [UnivLE.{w, w'}] [UnivLE.{w₂, w₂'}]
    [PreservesColimitsOfSize.{w', w₂'} F] : PreservesColimitsOfSize.{w, w₂} F 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{w, w₂, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.preservesColimitsOfSizeShrink
code: /--
`PreservesColimitsOfSizeShrink.{w w'} F` tries to obtain `PreservesColimitsOfSize.{w w'} F`
from some other `PreservesColimitsOfSize F`.
-/
def preservesColimitsOfSizeShrink (F : C ⥤ D) [PreservesColimitsOfSize.{max w w₂, max w' w₂'} F] :
    PreservesColimitsOfSize.{w, w'} F 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.preservesSmallestColimitsOfPreservesColimits
code: /-- Preserving colimits at any universe implies preserving colimits at universe `0`. -/
def preservesSmallestColimitsOfPreservesColimits (F : C ⥤ D) [PreservesColimitsOfSize.{v₃, u₃} F] :
    PreservesColimitsOfSize.{0, 0} F 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.ReflectsLimit
code: /-- A functor `F : C ⥤ D` reflects limits for `K : J ⥤ C` if
whenever the image of a cone over `K` under `F` is a limit cone in `D`,
the cone was already a limit cone in `C`.
Note that we do not assume a priori that `D` actually has any limits.
-/
class ReflectsLimit (K : J ⥤ C) (F : C ⥤ D) where
  reflects : ∀ {c : Cone K}, IsLimit (F.mapCone c) → IsLimit c
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) w)

full_name: CategoryTheory.Limits.ReflectsLimit.reflects
code: /-- A functor `F : C ⥤ D` reflects limits for `K : J ⥤ C` if
whenever the image of a cone over `K` under `F` is a limit cone in `D`,
the cone was already a limit cone in `C`.
Note that we do not assume a priori that `D` actually has any limits.
-/
class ReflectsLimit (K : J ⥤ C) (F : C ⥤ D) where
  reflects : ∀ {c : Cone K}, IsLimit (F.mapCone c) → IsLimit c
goal: CategoryTheory.Limits.IsLimit (F.mapCone c) → CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.ReflectsColimit
code: /-- A functor `F : C ⥤ D` reflects colimits for `K : J ⥤ C` if
whenever the image of a cocone over `K` under `F` is a colimit cocone in `D`,
the cocone was already a colimit cocone in `C`.
Note that we do not assume a priori that `D` actually has any colimits.
-/
class ReflectsColimit (K : J ⥤ C) (F : C ⥤ D) where
  reflects : ∀ {c : Cocone K}, IsColimit (F.mapCocone c) → IsColimit c
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) w)

full_name: CategoryTheory.Limits.ReflectsColimit.reflects
code: /-- A functor `F : C ⥤ D` reflects colimits for `K : J ⥤ C` if
whenever the image of a cocone over `K` under `F` is a colimit cocone in `D`,
the cocone was already a colimit cocone in `C`.
Note that we do not assume a priori that `D` actually has any colimits.
-/
class ReflectsColimit (K : J ⥤ C) (F : C ⥤ D) where
  reflects : ∀ {c : Cocone K}, IsColimit (F.mapCocone c) → IsColimit c
goal: CategoryTheory.Limits.IsColimit (F.mapCocone c) → CategoryTheory.Limits.IsColimit c

full_name: CategoryTheory.Limits.ReflectsLimitsOfShape
code: /-- A functor `F : C ⥤ D` reflects limits of shape `J` if
whenever the image of a cone over some `K : J ⥤ C` under `F` is a limit cone in `D`,
the cone was already a limit cone in `C`.
Note that we do not assume a priori that `D` actually has any limits.
-/
class ReflectsLimitsOfShape (J : Type w) [Category.{w'} J] (F : C ⥤ D) where
  reflectsLimit : ∀ {K : J ⥤ C}, ReflectsLimit K F := by infer_instance
goal: Type (max (max (max (max (max u₁ u₂) v₁) v₂) w) w')

full_name: CategoryTheory.Limits.ReflectsLimitsOfShape.reflectsLimit
code: /-- A functor `F : C ⥤ D` reflects limits of shape `J` if
whenever the image of a cone over some `K : J ⥤ C` under `F` is a limit cone in `D`,
the cone was already a limit cone in `C`.
Note that we do not assume a priori that `D` actually has any limits.
-/
class ReflectsLimitsOfShape (J : Type w) [Category.{w'} J] (F : C ⥤ D) where
  reflectsLimit : ∀ {K : J ⥤ C}, ReflectsLimit K F := by infer_instance
goal: CategoryTheory.Limits.ReflectsLimit K F

full_name: CategoryTheory.Limits.ReflectsColimitsOfShape.reflectsColimit
code: /-- A functor `F : C ⥤ D` reflects colimits of shape `J` if
whenever the image of a cocone over some `K : J ⥤ C` under `F` is a colimit cocone in `D`,
the cocone was already a colimit cocone in `C`.
Note that we do not assume a priori that `D` actually has any colimits.
-/
class ReflectsColimitsOfShape (J : Type w) [Category.{w'} J] (F : C ⥤ D) where
  reflectsColimit : ∀ {K : J ⥤ C}, ReflectsColimit K F := by infer_instance
goal: CategoryTheory.Limits.ReflectsColimit K F

full_name: CategoryTheory.Limits.ReflectsColimitsOfShape
code: /-- A functor `F : C ⥤ D` reflects colimits of shape `J` if
whenever the image of a cocone over some `K : J ⥤ C` under `F` is a colimit cocone in `D`,
the cocone was already a colimit cocone in `C`.
Note that we do not assume a priori that `D` actually has any colimits.
-/
class ReflectsColimitsOfShape (J : Type w) [Category.{w'} J] (F : C ⥤ D) where
  reflectsColimit : ∀ {K : J ⥤ C}, ReflectsColimit K F := by infer_instance
goal: Type (max (max (max (max (max u₁ u₂) v₁) v₂) w) w')

full_name: CategoryTheory.Limits.ReflectsLimitsOfSize.reflectsLimitsOfShape
code: /-- A functor `F : C ⥤ D` reflects limits if
whenever the image of a cone over some `K : J ⥤ C` under `F` is a limit cone in `D`,
the cone was already a limit cone in `C`.
Note that we do not assume a priori that `D` actually has any limits.
-/
@[nolint checkUnivs, pp_with_univ]
class ReflectsLimitsOfSize (F : C ⥤ D) where
  reflectsLimitsOfShape : ∀ {J : Type w} [Category.{w'} J], ReflectsLimitsOfShape J F := by
    infer_instance
goal: CategoryTheory.Limits.ReflectsLimitsOfShape J F

full_name: CategoryTheory.Limits.ReflectsLimitsOfSize
code: /-- A functor `F : C ⥤ D` reflects limits if
whenever the image of a cone over some `K : J ⥤ C` under `F` is a limit cone in `D`,
the cone was already a limit cone in `C`.
Note that we do not assume a priori that `D` actually has any limits.
-/
@[nolint checkUnivs, pp_with_univ]
class ReflectsLimitsOfSize (F : C ⥤ D) where
  reflectsLimitsOfShape : ∀ {J : Type w} [Category.{w'} J], ReflectsLimitsOfShape J F := by
    infer_instance
goal: Type (max (max (max (max (max u₁ u₂) v₁) v₂) (w + 1)) (w' + 1))

full_name: CategoryTheory.Limits.ReflectsLimits
code: /-- A functor `F : C ⥤ D` reflects (small) limits if
whenever the image of a cone over some `K : J ⥤ C` under `F` is a limit cone in `D`,
the cone was already a limit cone in `C`.
Note that we do not assume a priori that `D` actually has any limits.
-/
abbrev ReflectsLimits (F : C ⥤ D) 
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) (v₂ + 1))

full_name: CategoryTheory.Limits.ReflectsColimitsOfSize.reflectsColimitsOfShape
code: /-- A functor `F : C ⥤ D` reflects colimits if
whenever the image of a cocone over some `K : J ⥤ C` under `F` is a colimit cocone in `D`,
the cocone was already a colimit cocone in `C`.
Note that we do not assume a priori that `D` actually has any colimits.
-/
@[nolint checkUnivs, pp_with_univ]
class ReflectsColimitsOfSize (F : C ⥤ D) where
  reflectsColimitsOfShape : ∀ {J : Type w} [Category.{w'} J], ReflectsColimitsOfShape J F := by
    infer_instance
goal: CategoryTheory.Limits.ReflectsColimitsOfShape J F

full_name: CategoryTheory.Limits.ReflectsColimitsOfSize
code: /-- A functor `F : C ⥤ D` reflects colimits if
whenever the image of a cocone over some `K : J ⥤ C` under `F` is a colimit cocone in `D`,
the cocone was already a colimit cocone in `C`.
Note that we do not assume a priori that `D` actually has any colimits.
-/
@[nolint checkUnivs, pp_with_univ]
class ReflectsColimitsOfSize (F : C ⥤ D) where
  reflectsColimitsOfShape : ∀ {J : Type w} [Category.{w'} J], ReflectsColimitsOfShape J F := by
    infer_instance
goal: Type (max (max (max (max (max u₁ u₂) v₁) v₂) (w + 1)) (w' + 1))

full_name: CategoryTheory.Limits.ReflectsColimits
code: /-- A functor `F : C ⥤ D` reflects (small) colimits if
whenever the image of a cocone over some `K : J ⥤ C` under `F` is a colimit cocone in `D`,
the cocone was already a colimit cocone in `C`.
Note that we do not assume a priori that `D` actually has any colimits.
-/
abbrev ReflectsColimits (F : C ⥤ D) 
goal: Type (max (max (max (max u₁ u₂) v₁) v₂) (v₂ + 1))

full_name: CategoryTheory.Limits.isLimitOfReflects
code: /-- A convenience function for `ReflectsLimit`, which takes the functor as an explicit argument to
guide typeclass resolution.
-/
def isLimitOfReflects (F : C ⥤ D) {c : Cone K} (t : IsLimit (F.mapCone c))
    [ReflectsLimit K F] : IsLimit c 
goal: CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.isColimitOfReflects
code: /--
A convenience function for `ReflectsColimit`, which takes the functor as an explicit argument to
guide typeclass resolution.
-/
def isColimitOfReflects (F : C ⥤ D) {c : Cocone K} (t : IsColimit (F.mapCocone c))
    [ReflectsColimit K F] : IsColimit c 
goal: CategoryTheory.Limits.IsColimit c

full_name: CategoryTheory.Limits.reflectsLimit_subsingleton
code: instance reflectsLimit_subsingleton (K : J ⥤ C) (F : C ⥤ D) : Subsingleton (ReflectsLimit K F) 
goal: Subsingleton (CategoryTheory.Limits.ReflectsLimit K F)

full_name: CategoryTheory.Limits.reflectsColimit_subsingleton
code: instance
  reflectsColimit_subsingleton (K : J ⥤ C) (F : C ⥤ D) : Subsingleton (ReflectsColimit K F) 
goal: Subsingleton (CategoryTheory.Limits.ReflectsColimit K F)

full_name: CategoryTheory.Limits.reflectsLimitsOfShape_subsingleton
code: instance reflectsLimitsOfShape_subsingleton (J : Type w) [Category.{w'} J] (F : C ⥤ D) :
    Subsingleton (ReflectsLimitsOfShape J F) 
goal: Subsingleton (CategoryTheory.Limits.ReflectsLimitsOfShape J F)

full_name: CategoryTheory.Limits.reflectsColimitsOfShape_subsingleton
code: instance reflectsColimitsOfShape_subsingleton (J : Type w) [Category.{w'} J] (F : C ⥤ D) :
    Subsingleton (ReflectsColimitsOfShape J F) 
goal: Subsingleton (CategoryTheory.Limits.ReflectsColimitsOfShape J F)

full_name: CategoryTheory.Limits.reflects_limits_subsingleton
code: instance
  reflects_limits_subsingleton (F : C ⥤ D) : Subsingleton (ReflectsLimitsOfSize.{w', w} F) 
goal: Subsingleton (CategoryTheory.Limits.ReflectsLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F)

full_name: CategoryTheory.Limits.reflects_colimits_subsingleton
code: instance reflects_colimits_subsingleton (F : C ⥤ D) :
    Subsingleton (ReflectsColimitsOfSize.{w', w} F) 
goal: Subsingleton (CategoryTheory.Limits.ReflectsColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F)

full_name: CategoryTheory.Limits.reflectsLimitOfReflectsLimitsOfShape
code: instance (priority := 100) reflectsLimitOfReflectsLimitsOfShape (K : J ⥤ C) (F : C ⥤ D)
    [ReflectsLimitsOfShape J F] : ReflectsLimit K F 
goal: CategoryTheory.Limits.ReflectsLimit K F

full_name: CategoryTheory.Limits.reflectsColimitOfReflectsColimitsOfShape
code: instance (priority := 100) reflectsColimitOfReflectsColimitsOfShape (K : J ⥤ C) (F : C ⥤ D)
    [ReflectsColimitsOfShape J F] : ReflectsColimit K F 
goal: CategoryTheory.Limits.ReflectsColimit K F

full_name: CategoryTheory.Limits.reflectsLimitsOfShapeOfReflectsLimits
code: instance (priority := 100) reflectsLimitsOfShapeOfReflectsLimits (J : Type w) [Category.{w'} J]
    (F : C ⥤ D) [ReflectsLimitsOfSize.{w', w} F] : ReflectsLimitsOfShape J F 
goal: CategoryTheory.Limits.ReflectsLimitsOfShape J F

full_name: CategoryTheory.Limits.reflectsColimitsOfShapeOfReflectsColimits
code: instance (priority := 100) reflectsColimitsOfShapeOfReflectsColimits (J : Type w) [Category.{w'} J]
    (F : C ⥤ D) [ReflectsColimitsOfSize.{w', w} F] : ReflectsColimitsOfShape J F 
goal: CategoryTheory.Limits.ReflectsColimitsOfShape J F

full_name: CategoryTheory.Limits.idReflectsLimits
code: instance idReflectsLimits : ReflectsLimitsOfSize.{w, w'} (𝟭 C) 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{w, w', v₁, v₁, u₁, u₁} (𝟭 C)

full_name: CategoryTheory.Limits.idReflectsColimits
code: instance idReflectsColimits : ReflectsColimitsOfSize.{w, w'} (𝟭 C) 
goal: CategoryTheory.Limits.ReflectsColimitsOfSize.{w, w', v₁, v₁, u₁, u₁} (𝟭 C)

full_name: CategoryTheory.Limits.compReflectsLimit
code: instance compReflectsLimit [ReflectsLimit K F] [ReflectsLimit (K ⋙ F) G] :
    ReflectsLimit K (F ⋙ G) 
goal: CategoryTheory.Limits.ReflectsLimit K (F ⋙ G)

full_name: CategoryTheory.Limits.compReflectsLimitsOfShape
code: instance compReflectsLimitsOfShape [ReflectsLimitsOfShape J F] [ReflectsLimitsOfShape J G] :
    ReflectsLimitsOfShape J (F ⋙ G) 
goal: CategoryTheory.Limits.ReflectsLimitsOfShape J (F ⋙ G)

full_name: CategoryTheory.Limits.compReflectsLimits
code: instance compReflectsLimits [ReflectsLimitsOfSize.{w', w} F] [ReflectsLimitsOfSize.{w', w} G] :
    ReflectsLimitsOfSize.{w', w} (F ⋙ G) 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{w', w, v₁, v₃, u₁, u₃} (F ⋙ G)

full_name: CategoryTheory.Limits.compReflectsColimit
code: instance compReflectsColimit [ReflectsColimit K F] [ReflectsColimit (K ⋙ F) G] :
    ReflectsColimit K (F ⋙ G) 
goal: CategoryTheory.Limits.ReflectsColimit K (F ⋙ G)

full_name: CategoryTheory.Limits.compReflectsColimitsOfShape
code: instance compReflectsColimitsOfShape [ReflectsColimitsOfShape J F] [ReflectsColimitsOfShape J G] :
    ReflectsColimitsOfShape J (F ⋙ G) 
goal: CategoryTheory.Limits.ReflectsColimitsOfShape J (F ⋙ G)

full_name: CategoryTheory.Limits.compReflectsColimits
code: instance compReflectsColimits [ReflectsColimitsOfSize.{w', w} F]
    [ReflectsColimitsOfSize.{w', w} G] : ReflectsColimitsOfSize.{w', w} (F ⋙ G) 
goal: CategoryTheory.Limits.ReflectsColimitsOfSize.{w', w, v₁, v₃, u₁, u₃} (F ⋙ G)

full_name: CategoryTheory.Limits.preservesLimitOfReflectsOfPreserves
code: /-- If `F ⋙ G` preserves limits for `K`, and `G` reflects limits for `K ⋙ F`,
then `F` preserves limits for `K`. -/
def preservesLimitOfReflectsOfPreserves [PreservesLimit K (F ⋙ G)] [ReflectsLimit (K ⋙ F) G] :
    PreservesLimit K F 
goal: CategoryTheory.Limits.PreservesLimit K F

full_name: CategoryTheory.Limits.preservesLimitsOfShapeOfReflectsOfPreserves
code: /--
If `F ⋙ G` preserves limits of shape `J` and `G` reflects limits of shape `J`, then `F` preserves
limits of shape `J`.
-/
def preservesLimitsOfShapeOfReflectsOfPreserves [PreservesLimitsOfShape J (F ⋙ G)]
    [ReflectsLimitsOfShape J G] : PreservesLimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J F

full_name: CategoryTheory.Limits.preservesLimitsOfReflectsOfPreserves
code: /-- If `F ⋙ G` preserves limits and `G` reflects limits, then `F` preserves limits. -/
def preservesLimitsOfReflectsOfPreserves [PreservesLimitsOfSize.{w', w} (F ⋙ G)]
    [ReflectsLimitsOfSize.{w', w} G] : PreservesLimitsOfSize.{w', w} F 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.reflectsLimitOfIsoDiagram
code: /-- Transfer reflection of limits along a natural isomorphism in the diagram. -/
def reflectsLimitOfIsoDiagram {K₁ K₂ : J ⥤ C} (F : C ⥤ D) (h : K₁ ≅ K₂) [ReflectsLimit K₁ F] :
    ReflectsLimit K₂ F 
goal: CategoryTheory.Limits.ReflectsLimit K₂ F

full_name: CategoryTheory.Limits.reflectsLimitOfNatIso
code: /-- Transfer reflection of a limit along a natural isomorphism in the functor. -/
def reflectsLimitOfNatIso (K : J ⥤ C) {F G : C ⥤ D} (h : F ≅ G) [ReflectsLimit K F] :
    ReflectsLimit K G 
goal: CategoryTheory.Limits.ReflectsLimit K G

full_name: CategoryTheory.Limits.reflectsLimitsOfShapeOfNatIso
code: /-- Transfer reflection of limits of shape along a natural isomorphism in the functor. -/
def reflectsLimitsOfShapeOfNatIso {F G : C ⥤ D} (h : F ≅ G) [ReflectsLimitsOfShape J F] :
    ReflectsLimitsOfShape J G 
goal: CategoryTheory.Limits.ReflectsLimitsOfShape J G

full_name: CategoryTheory.Limits.reflectsLimitsOfNatIso
code: /-- Transfer reflection of limits along a natural isomorphism in the functor. -/
def reflectsLimitsOfNatIso {F G : C ⥤ D} (h : F ≅ G) [ReflectsLimitsOfSize.{w', w} F] :
    ReflectsLimitsOfSize.{w', w} G 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} G

full_name: CategoryTheory.Limits.reflectsLimitsOfShapeOfEquiv
code: /-- Transfer reflection of limits along an equivalence in the shape. -/
def reflectsLimitsOfShapeOfEquiv {J' : Type w₂} [Category.{w₂'} J'] (e : J ≌ J') (F : C ⥤ D)
    [ReflectsLimitsOfShape J F] : ReflectsLimitsOfShape J' F 
goal: CategoryTheory.Limits.ReflectsLimitsOfShape J' F

full_name: CategoryTheory.Limits.reflectsLimitsOfSizeOfUnivLE
code: /-- A functor reflecting larger limits also reflects smaller limits. -/
def reflectsLimitsOfSizeOfUnivLE (F : C ⥤ D) [UnivLE.{w, w'}] [UnivLE.{w₂, w₂'}]
    [ReflectsLimitsOfSize.{w', w₂'} F] : ReflectsLimitsOfSize.{w, w₂} F 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{w, w₂, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.reflectsLimitsOfSizeShrink
code: /-- `reflectsLimitsOfSizeShrink.{w w'} F` tries to obtain `reflectsLimitsOfSize.{w w'} F`
from some other `reflectsLimitsOfSize F`.
-/
def reflectsLimitsOfSizeShrink (F : C ⥤ D) [ReflectsLimitsOfSize.{max w w₂, max w' w₂'} F] :
    ReflectsLimitsOfSize.{w, w'} F 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.reflectsSmallestLimitsOfReflectsLimits
code: /-- Reflecting limits at any universe implies reflecting limits at universe `0`. -/
def reflectsSmallestLimitsOfReflectsLimits (F : C ⥤ D) [ReflectsLimitsOfSize.{v₃, u₃} F] :
    ReflectsLimitsOfSize.{0, 0} F 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{0, 0, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.reflectsLimitOfReflectsIsomorphisms
code: /-- If the limit of `F` exists and `G` preserves it, then if `G` reflects isomorphisms then it
reflects the limit of `F`.
-/ -- Porting note: previous behavior of apply pushed instance holes into hypotheses, this errors
def reflectsLimitOfReflectsIsomorphisms (F : J ⥤ C) (G : C ⥤ D) [G.ReflectsIsomorphisms]
    [HasLimit F] [PreservesLimit F G] : ReflectsLimit F G 
goal: CategoryTheory.Limits.ReflectsLimit F G

full_name: CategoryTheory.Limits.reflectsLimitsOfShapeOfReflectsIsomorphisms
code: /-- If `C` has limits of shape `J` and `G` preserves them, then if `G` reflects isomorphisms then it
reflects limits of shape `J`.
-/
def reflectsLimitsOfShapeOfReflectsIsomorphisms {G : C ⥤ D} [G.ReflectsIsomorphisms]
    [HasLimitsOfShape J C] [PreservesLimitsOfShape J G] : ReflectsLimitsOfShape J G 
goal: CategoryTheory.Limits.ReflectsLimitsOfShape J G

full_name: CategoryTheory.Limits.reflectsLimitsOfReflectsIsomorphisms
code: /-- If `C` has limits and `G` preserves limits, then if `G` reflects isomorphisms then it reflects
limits.
-/
def reflectsLimitsOfReflectsIsomorphisms {G : C ⥤ D} [G.ReflectsIsomorphisms]
    [HasLimitsOfSize.{w', w} C] [PreservesLimitsOfSize.{w', w} G] :
    ReflectsLimitsOfSize.{w', w} G 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} G

full_name: CategoryTheory.Limits.preservesColimitOfReflectsOfPreserves
code: /-- If `F ⋙ G` preserves colimits for `K`, and `G` reflects colimits for `K ⋙ F`,
then `F` preserves colimits for `K`. -/
def preservesColimitOfReflectsOfPreserves [PreservesColimit K (F ⋙ G)] [ReflectsColimit (K ⋙ F) G] :
    PreservesColimit K F 
goal: CategoryTheory.Limits.PreservesColimit K F

full_name: CategoryTheory.Limits.preservesColimitsOfShapeOfReflectsOfPreserves
code: /-- If `F ⋙ G` preserves colimits of shape `J` and `G` reflects colimits of shape `J`, then `F`
preserves colimits of shape `J`.
-/
def preservesColimitsOfShapeOfReflectsOfPreserves [PreservesColimitsOfShape J (F ⋙ G)]
    [ReflectsColimitsOfShape J G] : PreservesColimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesColimitsOfShape J F

full_name: CategoryTheory.Limits.preservesColimitsOfReflectsOfPreserves
code: /-- If `F ⋙ G` preserves colimits and `G` reflects colimits, then `F` preserves colimits. -/
def preservesColimitsOfReflectsOfPreserves [PreservesColimitsOfSize.{w', w} (F ⋙ G)]
    [ReflectsColimitsOfSize.{w', w} G] : PreservesColimitsOfSize.{w', w} F 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.reflectsColimitOfIsoDiagram
code: /-- Transfer reflection of colimits along a natural isomorphism in the diagram. -/
def reflectsColimitOfIsoDiagram {K₁ K₂ : J ⥤ C} (F : C ⥤ D) (h : K₁ ≅ K₂) [ReflectsColimit K₁ F] :
    ReflectsColimit K₂ F 
goal: CategoryTheory.Limits.ReflectsColimit K₂ F

full_name: CategoryTheory.Limits.reflectsColimitOfNatIso
code: /-- Transfer reflection of a colimit along a natural isomorphism in the functor. -/
def reflectsColimitOfNatIso (K : J ⥤ C) {F G : C ⥤ D} (h : F ≅ G) [ReflectsColimit K F] :
    ReflectsColimit K G 
goal: CategoryTheory.Limits.ReflectsColimit K G

full_name: CategoryTheory.Limits.reflectsColimitsOfShapeOfNatIso
code: /-- Transfer reflection of colimits of shape along a natural isomorphism in the functor. -/
def reflectsColimitsOfShapeOfNatIso {F G : C ⥤ D} (h : F ≅ G) [ReflectsColimitsOfShape J F] :
    ReflectsColimitsOfShape J G 
goal: CategoryTheory.Limits.ReflectsColimitsOfShape J G

full_name: CategoryTheory.Limits.reflectsColimitsOfNatIso
code: /-- Transfer reflection of colimits along a natural isomorphism in the functor. -/
def reflectsColimitsOfNatIso {F G : C ⥤ D} (h : F ≅ G) [ReflectsColimitsOfSize.{w, w'} F] :
    ReflectsColimitsOfSize.{w, w'} G 
goal: CategoryTheory.Limits.ReflectsColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} G

full_name: CategoryTheory.Limits.reflectsColimitsOfShapeOfEquiv
code: /-- Transfer reflection of colimits along an equivalence in the shape. -/
def reflectsColimitsOfShapeOfEquiv {J' : Type w₂} [Category.{w₂'} J'] (e : J ≌ J') (F : C ⥤ D)
    [ReflectsColimitsOfShape J F] : ReflectsColimitsOfShape J' F 
goal: CategoryTheory.Limits.ReflectsColimitsOfShape J' F

full_name: CategoryTheory.Limits.reflectsColimitsOfSizeOfUnivLE
code: /-- A functor reflecting larger colimits also reflects smaller colimits. -/
def reflectsColimitsOfSizeOfUnivLE (F : C ⥤ D) [UnivLE.{w, w'}] [UnivLE.{w₂, w₂'}]
    [ReflectsColimitsOfSize.{w', w₂'} F] : ReflectsColimitsOfSize.{w, w₂} F 
goal: CategoryTheory.Limits.ReflectsColimitsOfSize.{w, w₂, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.reflectsColimitsOfSizeShrink
code: /-- `reflectsColimitsOfSizeShrink.{w w'} F` tries to obtain `reflectsColimitsOfSize.{w w'} F`
from some other `reflectsColimitsOfSize F`.
-/
def reflectsColimitsOfSizeShrink (F : C ⥤ D) [ReflectsColimitsOfSize.{max w w₂, max w' w₂'} F] :
    ReflectsColimitsOfSize.{w, w'} F 
goal: CategoryTheory.Limits.ReflectsColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.reflectsSmallestColimitsOfReflectsColimits
code: /-- Reflecting colimits at any universe implies reflecting colimits at universe `0`. -/
def reflectsSmallestColimitsOfReflectsColimits (F : C ⥤ D) [ReflectsColimitsOfSize.{v₃, u₃} F] :
    ReflectsColimitsOfSize.{0, 0} F 
goal: CategoryTheory.Limits.ReflectsColimitsOfSize.{0, 0, v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.reflectsColimitOfReflectsIsomorphisms
code: /-- If the colimit of `F` exists and `G` preserves it, then if `G` reflects isomorphisms then it
reflects the colimit of `F`.
-/ -- Porting note: previous behavior of apply pushed instance holes into hypotheses, this errors
def reflectsColimitOfReflectsIsomorphisms (F : J ⥤ C) (G : C ⥤ D) [G.ReflectsIsomorphisms]
    [HasColimit F] [PreservesColimit F G] : ReflectsColimit F G 
goal: CategoryTheory.Limits.ReflectsColimit F G

full_name: CategoryTheory.Limits.reflectsColimitsOfShapeOfReflectsIsomorphisms
code: /--
If `C` has colimits of shape `J` and `G` preserves them, then if `G` reflects isomorphisms then it
reflects colimits of shape `J`.
-/
def reflectsColimitsOfShapeOfReflectsIsomorphisms {G : C ⥤ D} [G.ReflectsIsomorphisms]
    [HasColimitsOfShape J C] [PreservesColimitsOfShape J G] : ReflectsColimitsOfShape J G 
goal: CategoryTheory.Limits.ReflectsColimitsOfShape J G

full_name: CategoryTheory.Limits.reflectsColimitsOfReflectsIsomorphisms
code: /--
If `C` has colimits and `G` preserves colimits, then if `G` reflects isomorphisms then it reflects
colimits.
-/
def reflectsColimitsOfReflectsIsomorphisms {G : C ⥤ D} [G.ReflectsIsomorphisms]
    [HasColimitsOfSize.{w', w} C] [PreservesColimitsOfSize.{w', w} G] :
    ReflectsColimitsOfSize.{w', w} G 
goal: CategoryTheory.Limits.ReflectsColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} G

full_name: CategoryTheory.Limits.fullyFaithfulReflectsLimits
code: /-- A fully faithful functor reflects limits. -/
instance fullyFaithfulReflectsLimits [F.Full] [F.Faithful] : ReflectsLimitsOfSize.{w, w'} F 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F

full_name: CategoryTheory.Limits.fullyFaithfulReflectsColimits
code: /-- A fully faithful functor reflects colimits. -/
instance fullyFaithfulReflectsColimits [F.Full] [F.Faithful] :
    ReflectsColimitsOfSize.{w, w'} F 
goal: CategoryTheory.Limits.ReflectsColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F