File: Mathlib/CategoryTheory/Limits/Shapes/FiniteLimits.lean

full_name: CategoryTheory.Limits.HasFiniteLimits.out
code: /-- A category has all finite limits if every functor `J ⥤ C` with a `FinCategory J`
instance and `J : Type` has a limit.

This is often called 'finitely complete'.
-/
class HasFiniteLimits : Prop where
  /-- `C` has all limits over any type `J` whose objects and morphisms lie in the same universe
  and which has `FinType` objects and morphisms-/
  out (J : Type) [𝒥 : SmallCategory J] [@FinCategory J 𝒥] : @HasLimitsOfShape J 𝒥 C _
goal: CategoryTheory.Limits.HasLimitsOfShape J C

full_name: CategoryTheory.Limits.HasFiniteLimits
code: /-- A category has all finite limits if every functor `J ⥤ C` with a `FinCategory J`
instance and `J : Type` has a limit.

This is often called 'finitely complete'.
-/
class HasFiniteLimits : Prop where
  /-- `C` has all limits over any type `J` whose objects and morphisms lie in the same universe
  and which has `FinType` objects and morphisms-/
  out (J : Type) [𝒥 : SmallCategory J] [@FinCategory J 𝒥] : @HasLimitsOfShape J 𝒥 C _
goal: Prop

full_name: CategoryTheory.Limits.hasLimitsOfShape_of_hasFiniteLimits
code: instance (priority := 100) hasLimitsOfShape_of_hasFiniteLimits (J : Type w) [SmallCategory J]
    [FinCategory J] [HasFiniteLimits C] : HasLimitsOfShape J C 
goal: CategoryTheory.Limits.HasLimitsOfShape J C

full_name: CategoryTheory.Limits.hasFiniteLimits_of_hasLimitsOfSize
code: lemma hasFiniteLimits_of_hasLimitsOfSize [HasLimitsOfSize.{v', u'} C] :
    HasFiniteLimits C 
goal: CategoryTheory.Limits.HasFiniteLimits C

full_name: CategoryTheory.Limits.hasFiniteLimits_of_hasLimits
code: /-- If `C` has all limits, it has finite limits. -/
instance (priority := 100) hasFiniteLimits_of_hasLimits [HasLimits C] : HasFiniteLimits C 
goal: CategoryTheory.Limits.HasFiniteLimits C

full_name: CategoryTheory.Limits.hasFiniteLimits_of_hasLimitsOfSize₀
code: instance (priority := 90) hasFiniteLimits_of_hasLimitsOfSize₀ [HasLimitsOfSize.{0, 0} C] :
    HasFiniteLimits C 
goal: CategoryTheory.Limits.HasFiniteLimits C

full_name: CategoryTheory.Limits.hasFiniteLimits_of_hasFiniteLimits_of_size
code: /-- We can always derive `HasFiniteLimits C` by providing limits at an
arbitrary universe. -/
theorem hasFiniteLimits_of_hasFiniteLimits_of_size
    (h : ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), HasLimitsOfShape J C) :
    HasFiniteLimits C 
goal: CategoryTheory.Limits.HasFiniteLimits C

full_name: CategoryTheory.Limits.HasFiniteColimits
code: /-- A category has all finite colimits if every functor `J ⥤ C` with a `FinCategory J`
instance and `J : Type` has a colimit.

This is often called 'finitely cocomplete'.
-/
class HasFiniteColimits : Prop where
  /-- `C` has all colimits over any type `J` whose objects and morphisms lie in the same universe
  and which has `Fintype` objects and morphisms-/
  out (J : Type) [𝒥 : SmallCategory J] [@FinCategory J 𝒥] : @HasColimitsOfShape J 𝒥 C _
goal: Prop

full_name: CategoryTheory.Limits.HasFiniteColimits.out
code: /-- A category has all finite colimits if every functor `J ⥤ C` with a `FinCategory J`
instance and `J : Type` has a colimit.

This is often called 'finitely cocomplete'.
-/
class HasFiniteColimits : Prop where
  /-- `C` has all colimits over any type `J` whose objects and morphisms lie in the same universe
  and which has `Fintype` objects and morphisms-/
  out (J : Type) [𝒥 : SmallCategory J] [@FinCategory J 𝒥] : @HasColimitsOfShape J 𝒥 C _
goal: CategoryTheory.Limits.HasColimitsOfShape J C

full_name: CategoryTheory.Limits.hasColimitsOfShape_of_hasFiniteColimits
code: instance (priority := 100) hasColimitsOfShape_of_hasFiniteColimits (J : Type w) [SmallCategory J]
    [FinCategory J] [HasFiniteColimits C] : HasColimitsOfShape J C 
goal: CategoryTheory.Limits.HasColimitsOfShape J C

full_name: CategoryTheory.Limits.hasFiniteColimits_of_hasColimitsOfSize
code: lemma hasFiniteColimits_of_hasColimitsOfSize [HasColimitsOfSize.{v', u'} C] :
    HasFiniteColimits C 
goal: CategoryTheory.Limits.HasFiniteColimits C

full_name: CategoryTheory.Limits.hasFiniteColimits_of_hasColimits
code: instance (priority := 100) hasFiniteColimits_of_hasColimits [HasColimits C] : HasFiniteColimits C 
goal: CategoryTheory.Limits.HasFiniteColimits C

full_name: CategoryTheory.Limits.hasFiniteColimits_of_hasColimitsOfSize₀
code: instance (priority := 90) hasFiniteColimits_of_hasColimitsOfSize₀ [HasColimitsOfSize.{0, 0} C] :
    HasFiniteColimits C 
goal: CategoryTheory.Limits.HasFiniteColimits C

full_name: CategoryTheory.Limits.hasFiniteColimits_of_hasFiniteColimits_of_size
code: /-- We can always derive `HasFiniteColimits C` by providing colimits at an
arbitrary universe. -/
theorem hasFiniteColimits_of_hasFiniteColimits_of_size
    (h : ∀ (J : Type w) {𝒥 : SmallCategory J} (_ : @FinCategory J 𝒥), HasColimitsOfShape J C) :
    HasFiniteColimits C 
goal: CategoryTheory.Limits.HasFiniteColimits C

full_name: CategoryTheory.Limits.fintypeWalkingParallelPair
code: instance fintypeWalkingParallelPair : Fintype WalkingParallelPair 
goal: Fintype CategoryTheory.Limits.WalkingParallelPair

full_name: CategoryTheory.Limits.instFintypeWalkingParallelPairHom
code: instance instFintypeWalkingParallelPairHom (j j' : WalkingParallelPair) :
    Fintype (WalkingParallelPairHom j j') 
goal: Fintype (CategoryTheory.Limits.WalkingParallelPairHom j j')

full_name: CategoryTheory.Limits.instFinCategoryWalkingParallelPair
code: instance : FinCategory WalkingParallelPair 
goal: CategoryTheory.FinCategory CategoryTheory.Limits.WalkingParallelPair

full_name: CategoryTheory.Limits.WidePullbackShape.fintypeObj
code: instance fintypeObj [Fintype J] : Fintype (WidePullbackShape J) 
goal: Fintype (CategoryTheory.Limits.WidePullbackShape J)

full_name: CategoryTheory.Limits.WidePullbackShape.fintypeHom
code: instance fintypeHom (j j' : WidePullbackShape J) : Fintype (j ⟶ j') 
goal: Fintype (j ⟶ j')

full_name: CategoryTheory.Limits.WidePushoutShape.fintypeObj
code: instance fintypeObj [Fintype J] : Fintype (WidePushoutShape J) 
goal: Fintype (CategoryTheory.Limits.WidePushoutShape J)

full_name: CategoryTheory.Limits.WidePushoutShape.fintypeHom
code: instance fintypeHom (j j' : WidePushoutShape J) : Fintype (j ⟶ j') 
goal: Fintype (j ⟶ j')

full_name: CategoryTheory.Limits.finCategoryWidePullback
code: instance finCategoryWidePullback [Fintype J] : FinCategory (WidePullbackShape J) 
goal: CategoryTheory.FinCategory (CategoryTheory.Limits.WidePullbackShape J)

full_name: CategoryTheory.Limits.finCategoryWidePushout
code: instance finCategoryWidePushout [Fintype J] : FinCategory (WidePushoutShape J) 
goal: CategoryTheory.FinCategory (CategoryTheory.Limits.WidePushoutShape J)

full_name: CategoryTheory.Limits.HasFiniteWidePullbacks.out
code: /-- `HasFiniteWidePullbacks` represents a choice of wide pullback
for every finite collection of morphisms
-/
class HasFiniteWidePullbacks : Prop where
  /-- `C` has all wide pullbacks any Fintype `J`-/
  out (J : Type) [Finite J] : HasLimitsOfShape (WidePullbackShape J) C
goal: CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WidePullbackShape J) C

full_name: CategoryTheory.Limits.HasFiniteWidePullbacks
code: /-- `HasFiniteWidePullbacks` represents a choice of wide pullback
for every finite collection of morphisms
-/
class HasFiniteWidePullbacks : Prop where
  /-- `C` has all wide pullbacks any Fintype `J`-/
  out (J : Type) [Finite J] : HasLimitsOfShape (WidePullbackShape J) C
goal: Prop

full_name: CategoryTheory.Limits.hasLimitsOfShape_widePullbackShape
code: instance hasLimitsOfShape_widePullbackShape (J : Type) [Finite J] [HasFiniteWidePullbacks C] :
    HasLimitsOfShape (WidePullbackShape J) C 
goal: CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WidePullbackShape J) C

full_name: CategoryTheory.Limits.HasFiniteWidePushouts.out
code: /-- `HasFiniteWidePushouts` represents a choice of wide pushout
for every finite collection of morphisms
-/
class HasFiniteWidePushouts : Prop where
  /-- `C` has all wide pushouts any Fintype `J`-/
  out (J : Type) [Finite J] : HasColimitsOfShape (WidePushoutShape J) C
goal: CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Limits.WidePushoutShape J) C

full_name: CategoryTheory.Limits.HasFiniteWidePushouts
code: /-- `HasFiniteWidePushouts` represents a choice of wide pushout
for every finite collection of morphisms
-/
class HasFiniteWidePushouts : Prop where
  /-- `C` has all wide pushouts any Fintype `J`-/
  out (J : Type) [Finite J] : HasColimitsOfShape (WidePushoutShape J) C
goal: Prop

full_name: CategoryTheory.Limits.hasColimitsOfShape_widePushoutShape
code: instance hasColimitsOfShape_widePushoutShape (J : Type) [Finite J] [HasFiniteWidePushouts C] :
    HasColimitsOfShape (WidePushoutShape J) C 
goal: CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Limits.WidePushoutShape J) C

full_name: CategoryTheory.Limits.hasFiniteWidePullbacks_of_hasFiniteLimits
code: /-- Finite wide pullbacks are finite limits, so if `C` has all finite limits,
it also has finite wide pullbacks
-/
theorem hasFiniteWidePullbacks_of_hasFiniteLimits [HasFiniteLimits C] : HasFiniteWidePullbacks C 
goal: CategoryTheory.Limits.HasFiniteWidePullbacks C

full_name: CategoryTheory.Limits.hasFiniteWidePushouts_of_has_finite_limits
code: /-- Finite wide pushouts are finite colimits, so if `C` has all finite colimits,
it also has finite wide pushouts
-/
theorem hasFiniteWidePushouts_of_has_finite_limits [HasFiniteColimits C] :
    HasFiniteWidePushouts C 
goal: CategoryTheory.Limits.HasFiniteWidePushouts C

full_name: CategoryTheory.Limits.fintypeWalkingPair
code: instance fintypeWalkingPair : Fintype WalkingPair 
goal: Fintype CategoryTheory.Limits.WalkingPair