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

full_name: CategoryTheory.Limits.PreservesFiniteLimits
code: /-- A functor is said to preserve finite limits, if it preserves all limits of shape `J`,
where `J : Type` is a finite category.
-/
class PreservesFiniteLimits (F : C ⥤ D) where
  preservesFiniteLimits :
    ∀ (J : Type) [SmallCategory J] [FinCategory J], PreservesLimitsOfShape J F := by infer_instance
goal: Type (max (max (max (max 1 u₁) u₂) v₁) v₂)

full_name: CategoryTheory.Limits.PreservesFiniteLimits.preservesFiniteLimits
code: /-- A functor is said to preserve finite limits, if it preserves all limits of shape `J`,
where `J : Type` is a finite category.
-/
class PreservesFiniteLimits (F : C ⥤ D) where
  preservesFiniteLimits :
    ∀ (J : Type) [SmallCategory J] [FinCategory J], PreservesLimitsOfShape J F := by infer_instance
goal: CategoryTheory.Limits.PreservesLimitsOfShape J F

full_name: CategoryTheory.Limits.preservesLimitsOfShapeOfPreservesFiniteLimits
code: /-- Preserving finite limits also implies preserving limits over finite shapes in higher universes,
though through a noncomputable instance. -/
noncomputable instance (priority := 100) preservesLimitsOfShapeOfPreservesFiniteLimits (F : C ⥤ D)
    [PreservesFiniteLimits F] (J : Type w) [SmallCategory J] [FinCategory J] :
    PreservesLimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J F

full_name: CategoryTheory.Limits.PreservesLimitsOfSize.preservesFiniteLimits
code: /-- If we preserve limits of some arbitrary size, then we preserve all finite limits. -/
noncomputable def PreservesLimitsOfSize.preservesFiniteLimits (F : C ⥤ D)
    [PreservesLimitsOfSize.{w, w₂} F] : PreservesFiniteLimits F 
goal: CategoryTheory.Limits.PreservesFiniteLimits F

full_name: CategoryTheory.Limits.PreservesLimitsOfSize0.preservesFiniteLimits
code: noncomputable instance (priority := 120) PreservesLimitsOfSize0.preservesFiniteLimits
    (F : C ⥤ D) [PreservesLimitsOfSize.{0, 0} F] : PreservesFiniteLimits F 
goal: CategoryTheory.Limits.PreservesFiniteLimits F

full_name: CategoryTheory.Limits.PreservesLimits.preservesFiniteLimits
code: noncomputable instance (priority := 120) PreservesLimits.preservesFiniteLimits (F : C ⥤ D)
    [PreservesLimits F] : PreservesFiniteLimits F 
goal: CategoryTheory.Limits.PreservesFiniteLimits F

full_name: CategoryTheory.Limits.preservesFiniteLimitsOfPreservesFiniteLimitsOfSize
code: /-- We can always derive `PreservesFiniteLimits C` by showing that we are preserving limits at an
arbitrary universe. -/
def preservesFiniteLimitsOfPreservesFiniteLimitsOfSize (F : C ⥤ D)
    (h :
      ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), PreservesLimitsOfShape J F) :
    PreservesFiniteLimits F 
goal: CategoryTheory.Limits.PreservesFiniteLimits F

full_name: CategoryTheory.Limits.compPreservesFiniteLimits
code: /-- The composition of two left exact functors is left exact. -/
def compPreservesFiniteLimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteLimits F]
    [PreservesFiniteLimits G] : PreservesFiniteLimits (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesFiniteLimits (F ⋙ G)

full_name: CategoryTheory.Limits.PreservesFiniteProducts.preserves
code: /-- A functor `F` preserves finite products if it preserves all from `Discrete J`
for `Fintype J` -/
class PreservesFiniteProducts (F : C ⥤ D) where
  preserves : ∀ (J : Type) [Fintype J], PreservesLimitsOfShape (Discrete J) F
goal: CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete J) F

full_name: CategoryTheory.Limits.PreservesFiniteProducts
code: /-- A functor `F` preserves finite products if it preserves all from `Discrete J`
for `Fintype J` -/
class PreservesFiniteProducts (F : C ⥤ D) where
  preserves : ∀ (J : Type) [Fintype J], PreservesLimitsOfShape (Discrete J) F
goal: Type (max (max (max (max 1 u₁) u₂) v₁) v₂)

full_name: CategoryTheory.Limits.compPreservesFiniteProducts
code: instance compPreservesFiniteProducts (F : C ⥤ D) (G : D ⥤ E)
    [PreservesFiniteProducts F] [PreservesFiniteProducts G] :
    PreservesFiniteProducts (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesFiniteProducts (F ⋙ G)

full_name: CategoryTheory.Limits.instPreservesFiniteProductsOfPreservesFiniteLimits
code: noncomputable instance (F : C ⥤ D) [PreservesFiniteLimits F] : PreservesFiniteProducts F 
goal: CategoryTheory.Limits.PreservesFiniteProducts F

full_name: CategoryTheory.Limits.ReflectsFiniteLimits
code: /--
A functor is said to reflect finite limits, if it reflects all limits of shape `J`,
where `J : Type` is a finite category.
-/
class ReflectsFiniteLimits (F : C ⥤ D) where
  reflects : ∀ (J : Type) [SmallCategory J] [FinCategory J], ReflectsLimitsOfShape J F := by
    infer_instance
goal: Type (max (max (max (max 1 u₁) u₂) v₁) v₂)

full_name: CategoryTheory.Limits.ReflectsFiniteLimits.reflects
code: /--
A functor is said to reflect finite limits, if it reflects all limits of shape `J`,
where `J : Type` is a finite category.
-/
class ReflectsFiniteLimits (F : C ⥤ D) where
  reflects : ∀ (J : Type) [SmallCategory J] [FinCategory J], ReflectsLimitsOfShape J F := by
    infer_instance
goal: CategoryTheory.Limits.ReflectsLimitsOfShape J F

full_name: CategoryTheory.Limits.ReflectsFiniteProducts
code: /--
A functor `F` preserves finite products if it reflects limits of shape `Discrete J` for finite `J`
-/
class ReflectsFiniteProducts (F : C ⥤ D) where
  reflects : ∀ (J : Type) [Fintype J], ReflectsLimitsOfShape (Discrete J) F
goal: Type (max (max (max (max 1 u₁) u₂) v₁) v₂)

full_name: CategoryTheory.Limits.ReflectsFiniteProducts.reflects
code: /--
A functor `F` preserves finite products if it reflects limits of shape `Discrete J` for finite `J`
-/
class ReflectsFiniteProducts (F : C ⥤ D) where
  reflects : ∀ (J : Type) [Fintype J], ReflectsLimitsOfShape (Discrete J) F
goal: CategoryTheory.Limits.ReflectsLimitsOfShape (CategoryTheory.Discrete J) F

full_name: CategoryTheory.Limits.ReflectsLimitsOfSize.reflectsFiniteLimits
code: /-- If we reflect limits of some arbitrary size, then we reflect all finite limits. -/
noncomputable def ReflectsLimitsOfSize.reflectsFiniteLimits
    (F : C ⥤ D) [ReflectsLimitsOfSize.{w, w₂} F] : ReflectsFiniteLimits F 
goal: CategoryTheory.Limits.ReflectsFiniteLimits F

full_name: CategoryTheory.Limits.instReflectsFiniteLimitsOfReflectsLimitsOfSize
code: noncomputable instance (priority := 120) (F : C ⥤ D) [ReflectsLimitsOfSize.{0, 0} F] :
    ReflectsFiniteLimits F 
goal: CategoryTheory.Limits.ReflectsFiniteLimits F

full_name: CategoryTheory.Limits.instReflectsFiniteLimitsOfReflectsLimits
code: noncomputable instance (priority := 120) (F : C ⥤ D)
    [ReflectsLimits F] : ReflectsFiniteLimits F 
goal: CategoryTheory.Limits.ReflectsFiniteLimits F

full_name: CategoryTheory.Limits.preservesFiniteLimitsOfReflectsOfPreserves
code: /--
If `F ⋙ G` preserves finite limits and `G` reflects finite limits, then `F` preserves
finite limits.
-/
def preservesFiniteLimitsOfReflectsOfPreserves (F : C ⥤ D) (G : D ⥤ E)
    [PreservesFiniteLimits (F ⋙ G)] [ReflectsFiniteLimits G] : PreservesFiniteLimits F 
goal: CategoryTheory.Limits.PreservesFiniteLimits F

full_name: CategoryTheory.Limits.preservesFiniteProductsOfReflectsOfPreserves
code: /--
If `F ⋙ G` preserves finite products and `G` reflects finite products, then `F` preserves
finite products.
-/
def preservesFiniteProductsOfReflectsOfPreserves (F : C ⥤ D) (G : D ⥤ E)
    [PreservesFiniteProducts (F ⋙ G)] [ReflectsFiniteProducts G] : PreservesFiniteProducts F 
goal: CategoryTheory.Limits.PreservesFiniteProducts F

full_name: CategoryTheory.Limits.reflectsFiniteLimitsOfReflectsIsomorphisms
code: noncomputable instance reflectsFiniteLimitsOfReflectsIsomorphisms (F : C ⥤ D)
    [F.ReflectsIsomorphisms] [HasFiniteLimits C] [PreservesFiniteLimits F] :
      ReflectsFiniteLimits F 
goal: CategoryTheory.Limits.ReflectsFiniteLimits F

full_name: CategoryTheory.Limits.reflectsFiniteProductsOfReflectsIsomorphisms
code: noncomputable instance reflectsFiniteProductsOfReflectsIsomorphisms (F : C ⥤ D)
    [F.ReflectsIsomorphisms] [HasFiniteProducts C] [PreservesFiniteProducts F] :
      ReflectsFiniteProducts F 
goal: CategoryTheory.Limits.ReflectsFiniteProducts F

full_name: CategoryTheory.Limits.compReflectsFiniteProducts
code: instance compReflectsFiniteProducts (F : C ⥤ D) (G : D ⥤ E)
    [ReflectsFiniteProducts F] [ReflectsFiniteProducts G] :
    ReflectsFiniteProducts (F ⋙ G) 
goal: CategoryTheory.Limits.ReflectsFiniteProducts (F ⋙ G)

full_name: CategoryTheory.Limits.instReflectsFiniteProductsOfReflectsFiniteLimits
code: noncomputable instance (F : C ⥤ D) [ReflectsFiniteLimits F] : ReflectsFiniteProducts F 
goal: CategoryTheory.Limits.ReflectsFiniteProducts F

full_name: CategoryTheory.Limits.PreservesFiniteColimits
code: /-- A functor is said to preserve finite colimits, if it preserves all colimits of
shape `J`, where `J : Type` is a finite category.
-/
class PreservesFiniteColimits (F : C ⥤ D) where
  preservesFiniteColimits :
    ∀ (J : Type) [SmallCategory J] [FinCategory J], PreservesColimitsOfShape J F := by
      infer_instance
goal: Type (max (max (max (max 1 u₁) u₂) v₁) v₂)

full_name: CategoryTheory.Limits.PreservesFiniteColimits.preservesFiniteColimits
code: /-- A functor is said to preserve finite colimits, if it preserves all colimits of
shape `J`, where `J : Type` is a finite category.
-/
class PreservesFiniteColimits (F : C ⥤ D) where
  preservesFiniteColimits :
    ∀ (J : Type) [SmallCategory J] [FinCategory J], PreservesColimitsOfShape J F := by
      infer_instance
goal: CategoryTheory.Limits.PreservesColimitsOfShape J F

full_name: CategoryTheory.Limits.preservesColimitsOfShapeOfPreservesFiniteColimits
code: /--
Preserving finite colimits also implies preserving colimits over finite shapes in higher
universes, though through a noncomputable instance.
-/
noncomputable instance (priority := 100) preservesColimitsOfShapeOfPreservesFiniteColimits
    (F : C ⥤ D) [PreservesFiniteColimits F] (J : Type w) [SmallCategory J] [FinCategory J] :
    PreservesColimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesColimitsOfShape J F

full_name: CategoryTheory.Limits.PreservesColimitsOfSize.preservesFiniteColimits
code: /-- If we preserve colimits of some arbitrary size, then we preserve all finite colimits. -/
noncomputable def PreservesColimitsOfSize.preservesFiniteColimits (F : C ⥤ D)
    [PreservesColimitsOfSize.{w, w₂} F] : PreservesFiniteColimits F 
goal: CategoryTheory.Limits.PreservesFiniteColimits F

full_name: CategoryTheory.Limits.PreservesColimitsOfSize0.preservesFiniteColimits
code: noncomputable instance (priority := 120) PreservesColimitsOfSize0.preservesFiniteColimits
    (F : C ⥤ D) [PreservesColimitsOfSize.{0, 0} F] : PreservesFiniteColimits F 
goal: CategoryTheory.Limits.PreservesFiniteColimits F

full_name: CategoryTheory.Limits.PreservesColimits.preservesFiniteColimits
code: noncomputable instance (priority := 120) PreservesColimits.preservesFiniteColimits (F : C ⥤ D)
    [PreservesColimits F] : PreservesFiniteColimits F 
goal: CategoryTheory.Limits.PreservesFiniteColimits F

full_name: CategoryTheory.Limits.preservesFiniteColimitsOfPreservesFiniteColimitsOfSize
code: /-- We can always derive `PreservesFiniteColimits C`
by showing that we are preserving colimits at an arbitrary universe. -/
def preservesFiniteColimitsOfPreservesFiniteColimitsOfSize (F : C ⥤ D)
    (h :
      ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), PreservesColimitsOfShape J F) :
    PreservesFiniteColimits F 
goal: CategoryTheory.Limits.PreservesFiniteColimits F

full_name: CategoryTheory.Limits.compPreservesFiniteColimits
code: /-- The composition of two right exact functors is right exact. -/
def compPreservesFiniteColimits (F : C ⥤ D) (G : D ⥤ E) [PreservesFiniteColimits F]
    [PreservesFiniteColimits G] : PreservesFiniteColimits (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesFiniteColimits (F ⋙ G)

full_name: CategoryTheory.Limits.PreservesFiniteCoproducts
code: /-- A functor `F` preserves finite products if it preserves all from `Discrete J`
for `Fintype J` -/
class PreservesFiniteCoproducts (F : C ⥤ D) where
  /-- preservation of colimits indexed by `Discrete J` when `[Fintype J]` -/
  preserves : ∀ (J : Type) [Fintype J], PreservesColimitsOfShape (Discrete J) F
goal: Type (max (max (max (max 1 u₁) u₂) v₁) v₂)

full_name: CategoryTheory.Limits.PreservesFiniteCoproducts.preserves
code: /-- A functor `F` preserves finite products if it preserves all from `Discrete J`
for `Fintype J` -/
class PreservesFiniteCoproducts (F : C ⥤ D) where
  /-- preservation of colimits indexed by `Discrete J` when `[Fintype J]` -/
  preserves : ∀ (J : Type) [Fintype J], PreservesColimitsOfShape (Discrete J) F
goal: CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete J) F

full_name: CategoryTheory.Limits.instPreservesColimitsOfShapeDiscreteOfFiniteOfPreservesFiniteCoproducts
code: noncomputable instance (F : C ⥤ D) (J : Type*) [Finite J] [PreservesFiniteCoproducts F] :
    PreservesColimitsOfShape (Discrete J) F 
goal: CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete J) F

full_name: CategoryTheory.Limits.compPreservesFiniteCoproducts
code: noncomputable instance compPreservesFiniteCoproducts (F : C ⥤ D) (G : D ⥤ E)
    [PreservesFiniteCoproducts F] [PreservesFiniteCoproducts G] :
    PreservesFiniteCoproducts (F ⋙ G) 
goal: CategoryTheory.Limits.PreservesFiniteCoproducts (F ⋙ G)

full_name: CategoryTheory.Limits.instPreservesFiniteCoproductsOfPreservesFiniteColimits
code: noncomputable instance (F : C ⥤ D) [PreservesFiniteColimits F] : PreservesFiniteCoproducts F 
goal: CategoryTheory.Limits.PreservesFiniteCoproducts F

full_name: CategoryTheory.Limits.ReflectsFiniteColimits.reflects
code: /--
A functor is said to reflect finite colimits, if it reflects all colimits of shape `J`,
where `J : Type` is a finite category.
-/
class ReflectsFiniteColimits (F : C ⥤ D) where
  reflects : ∀ (J : Type) [SmallCategory J] [FinCategory J], ReflectsColimitsOfShape J F := by
    infer_instance
goal: CategoryTheory.Limits.ReflectsColimitsOfShape J F

full_name: CategoryTheory.Limits.ReflectsFiniteColimits
code: /--
A functor is said to reflect finite colimits, if it reflects all colimits of shape `J`,
where `J : Type` is a finite category.
-/
class ReflectsFiniteColimits (F : C ⥤ D) where
  reflects : ∀ (J : Type) [SmallCategory J] [FinCategory J], ReflectsColimitsOfShape J F := by
    infer_instance
goal: Type (max (max (max (max 1 u₁) u₂) v₁) v₂)

full_name: CategoryTheory.Limits.ReflectsColimitsOfSize.reflectsFiniteColimits
code: /-- If we reflect colimits of some arbitrary size, then we reflect all finite colimits. -/
noncomputable def ReflectsColimitsOfSize.reflectsFiniteColimits
    (F : C ⥤ D) [ReflectsColimitsOfSize.{w, w₂} F] : ReflectsFiniteColimits F 
goal: CategoryTheory.Limits.ReflectsFiniteColimits F

full_name: CategoryTheory.Limits.instReflectsFiniteColimitsOfReflectsColimitsOfSize
code: noncomputable instance (priority := 120) (F : C ⥤ D) [ReflectsColimitsOfSize.{0, 0} F] :
    ReflectsFiniteColimits F 
goal: CategoryTheory.Limits.ReflectsFiniteColimits F

full_name: CategoryTheory.Limits.instReflectsFiniteColimitsOfReflectsColimits
code: noncomputable instance (priority := 120) (F : C ⥤ D)
    [ReflectsColimits F] : ReflectsFiniteColimits F 
goal: CategoryTheory.Limits.ReflectsFiniteColimits F

full_name: CategoryTheory.Limits.ReflectsFiniteCoproducts.reflects
code: /--
A functor `F` preserves finite coproducts if it reflects colimits of shape `Discrete J` for
finite `J`
-/
class ReflectsFiniteCoproducts (F : C ⥤ D) where
  reflects : ∀ (J : Type) [Fintype J], ReflectsColimitsOfShape (Discrete J) F
goal: CategoryTheory.Limits.ReflectsColimitsOfShape (CategoryTheory.Discrete J) F

full_name: CategoryTheory.Limits.ReflectsFiniteCoproducts
code: /--
A functor `F` preserves finite coproducts if it reflects colimits of shape `Discrete J` for
finite `J`
-/
class ReflectsFiniteCoproducts (F : C ⥤ D) where
  reflects : ∀ (J : Type) [Fintype J], ReflectsColimitsOfShape (Discrete J) F
goal: Type (max (max (max (max 1 u₁) u₂) v₁) v₂)

full_name: CategoryTheory.Limits.preservesFiniteColimitsOfReflectsOfPreserves
code: /--
If `F ⋙ G` preserves finite colimits and `G` reflects finite colimits, then `F` preserves finite
colimits.
-/
def preservesFiniteColimitsOfReflectsOfPreserves (F : C ⥤ D) (G : D ⥤ E)
    [PreservesFiniteColimits (F ⋙ G)] [ReflectsFiniteColimits G] : PreservesFiniteColimits F 
goal: CategoryTheory.Limits.PreservesFiniteColimits F

full_name: CategoryTheory.Limits.preservesFiniteCoproductsOfReflectsOfPreserves
code: /--
If `F ⋙ G` preserves finite coproducts and `G` reflects finite coproducts, then `F` preserves
finite coproducts.
-/
noncomputable def preservesFiniteCoproductsOfReflectsOfPreserves (F : C ⥤ D) (G : D ⥤ E)
    [PreservesFiniteCoproducts (F ⋙ G)] [ReflectsFiniteCoproducts G] :
    PreservesFiniteCoproducts F 
goal: CategoryTheory.Limits.PreservesFiniteCoproducts F

full_name: CategoryTheory.Limits.reflectsFiniteColimitsOfReflectsIsomorphisms
code: noncomputable instance reflectsFiniteColimitsOfReflectsIsomorphisms (F : C ⥤ D)
    [F.ReflectsIsomorphisms] [HasFiniteColimits C] [PreservesFiniteColimits F] :
      ReflectsFiniteColimits F 
goal: CategoryTheory.Limits.ReflectsFiniteColimits F

full_name: CategoryTheory.Limits.reflectsFiniteCoproductsOfReflectsIsomorphisms
code: noncomputable instance reflectsFiniteCoproductsOfReflectsIsomorphisms (F : C ⥤ D)
    [F.ReflectsIsomorphisms] [HasFiniteCoproducts C] [PreservesFiniteCoproducts F] :
      ReflectsFiniteCoproducts F 
goal: CategoryTheory.Limits.ReflectsFiniteCoproducts F

full_name: CategoryTheory.Limits.compReflectsFiniteCoproducts
code: instance compReflectsFiniteCoproducts (F : C ⥤ D) (G : D ⥤ E)
    [ReflectsFiniteCoproducts F] [ReflectsFiniteCoproducts G] :
    ReflectsFiniteCoproducts (F ⋙ G) 
goal: CategoryTheory.Limits.ReflectsFiniteCoproducts (F ⋙ G)

full_name: CategoryTheory.Limits.instReflectsFiniteCoproductsOfReflectsFiniteColimits
code: noncomputable instance (F : C ⥤ D) [ReflectsFiniteColimits F] : ReflectsFiniteCoproducts F 
goal: CategoryTheory.Limits.ReflectsFiniteCoproducts F