File: Mathlib/CategoryTheory/Limits/FinallySmall.lean

full_name: CategoryTheory.FinallySmall
code: /-- A category is `FinallySmall.{w}` if there is a final functor from a `w`-small category. -/
class FinallySmall : Prop where
  /-- There is a final functor from a small category. -/
  final_smallCategory : ∃ (S : Type w) (_ : SmallCategory S) (F : S ⥤ J), Final F
goal: Prop

full_name: CategoryTheory.FinallySmall.final_smallCategory
code: /-- A category is `FinallySmall.{w}` if there is a final functor from a `w`-small category. -/
class FinallySmall : Prop where
  /-- There is a final functor from a small category. -/
  final_smallCategory : ∃ (S : Type w) (_ : SmallCategory S) (F : S ⥤ J), Final F
goal: ∃ S x F, F.Final

full_name: CategoryTheory.FinallySmall.mk'
code: /-- Constructor for `FinallySmall C` from an explicit small category witness. -/
theorem FinallySmall.mk' {J : Type u} [Category.{v} J] {S : Type w} [SmallCategory S]
    (F : S ⥤ J) [Final F] : FinallySmall.{w} J 
goal: CategoryTheory.FinallySmall J

full_name: CategoryTheory.FinalModel
code: /-- An arbitrarily chosen small model for a finally small category. -/
def FinalModel [FinallySmall.{w} J] : Type w 
goal: Type w

full_name: CategoryTheory.smallCategoryFinalModel
code: noncomputable instance smallCategoryFinalModel [FinallySmall.{w} J] :
    SmallCategory (FinalModel J) 
goal: CategoryTheory.SmallCategory (CategoryTheory.FinalModel J)

full_name: CategoryTheory.fromFinalModel
code: /-- An arbitrarily chosen final functor `FinalModel J ⥤ J`. -/
noncomputable def fromFinalModel [FinallySmall.{w} J] : FinalModel J ⥤ J 
goal: CategoryTheory.FinalModel J ⥤ J

full_name: CategoryTheory.final_fromFinalModel
code: instance final_fromFinalModel [FinallySmall.{w} J] : Final (fromFinalModel J) 
goal: (CategoryTheory.fromFinalModel J).Final

full_name: CategoryTheory.finallySmall_of_essentiallySmall
code: theorem finallySmall_of_essentiallySmall [EssentiallySmall.{w} J] : FinallySmall.{w} J 
goal: CategoryTheory.FinallySmall J

full_name: CategoryTheory.finallySmall_of_final_of_finallySmall
code: theorem finallySmall_of_final_of_finallySmall [FinallySmall.{w} K] : FinallySmall.{w} J 
goal: CategoryTheory.FinallySmall J

full_name: CategoryTheory.finallySmall_of_final_of_essentiallySmall
code: theorem finallySmall_of_final_of_essentiallySmall [EssentiallySmall.{w} K] : FinallySmall.{w} J 
goal: CategoryTheory.FinallySmall J

full_name: CategoryTheory.InitiallySmall
code: /-- A category is `InitiallySmall.{w}` if there is an initial functor from a `w`-small category. -/
class InitiallySmall : Prop where
  /-- There is an initial functor from a small category. -/
  initial_smallCategory : ∃ (S : Type w) (_ : SmallCategory S) (F : S ⥤ J), Initial F
goal: Prop

full_name: CategoryTheory.InitiallySmall.initial_smallCategory
code: /-- A category is `InitiallySmall.{w}` if there is an initial functor from a `w`-small category. -/
class InitiallySmall : Prop where
  /-- There is an initial functor from a small category. -/
  initial_smallCategory : ∃ (S : Type w) (_ : SmallCategory S) (F : S ⥤ J), Initial F
goal: ∃ S x F, F.Initial

full_name: CategoryTheory.InitiallySmall.mk'
code: /-- Constructor for `InitialSmall C` from an explicit small category witness. -/
theorem InitiallySmall.mk' {J : Type u} [Category.{v} J] {S : Type w} [SmallCategory S]
    (F : S ⥤ J) [Initial F] : InitiallySmall.{w} J 
goal: CategoryTheory.InitiallySmall J

full_name: CategoryTheory.InitialModel
code: /-- An arbitrarily chosen small model for an initially small category. -/
def InitialModel [InitiallySmall.{w} J] : Type w 
goal: Type w

full_name: CategoryTheory.smallCategoryInitialModel
code: noncomputable instance smallCategoryInitialModel [InitiallySmall.{w} J] :
    SmallCategory (InitialModel J) 
goal: CategoryTheory.SmallCategory (CategoryTheory.InitialModel J)

full_name: CategoryTheory.fromInitialModel
code: /-- An arbitrarily chosen initial functor `InitialModel J ⥤ J`. -/
noncomputable def fromInitialModel [InitiallySmall.{w} J] : InitialModel J ⥤ J 
goal: CategoryTheory.InitialModel J ⥤ J

full_name: CategoryTheory.initial_fromInitialModel
code: instance initial_fromInitialModel [InitiallySmall.{w} J] : Initial (fromInitialModel J) 
goal: (CategoryTheory.fromInitialModel J).Initial

full_name: CategoryTheory.initiallySmall_of_essentiallySmall
code: theorem initiallySmall_of_essentiallySmall [EssentiallySmall.{w} J] : InitiallySmall.{w} J 
goal: CategoryTheory.InitiallySmall J

full_name: CategoryTheory.initiallySmall_of_initial_of_initiallySmall
code: theorem initiallySmall_of_initial_of_initiallySmall [InitiallySmall.{w} K] : InitiallySmall.{w} J 
goal: CategoryTheory.InitiallySmall J

full_name: CategoryTheory.initiallySmall_of_initial_of_essentiallySmall
code: theorem initiallySmall_of_initial_of_essentiallySmall [EssentiallySmall.{w} K] :
    InitiallySmall.{w} J 
goal: CategoryTheory.InitiallySmall J

full_name: CategoryTheory.FinallySmall.exists_small_weakly_terminal_set
code: /-- The converse is true if `J` is filtered, see `finallySmall_of_small_weakly_terminal_set`. -/
theorem FinallySmall.exists_small_weakly_terminal_set [FinallySmall.{w} J] :
    ∃ (s : Set J) (_ : Small.{w} s), ∀ i, ∃ j ∈ s, Nonempty (i ⟶ j) 
goal: ∃ s, ∃ (_ : Small.{w, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)

full_name: CategoryTheory.finallySmall_of_small_weakly_terminal_set
code: theorem finallySmall_of_small_weakly_terminal_set [IsFilteredOrEmpty J] (s : Set J) [Small.{v} s]
    (hs : ∀ i, ∃ j ∈ s, Nonempty (i ⟶ j)) : FinallySmall.{v} J 
goal: CategoryTheory.FinallySmall J

full_name: CategoryTheory.finallySmall_iff_exists_small_weakly_terminal_set
code: theorem finallySmall_iff_exists_small_weakly_terminal_set [IsFilteredOrEmpty J] :
    FinallySmall.{v} J ↔ ∃ (s : Set J) (_ : Small.{v} s), ∀ i, ∃ j ∈ s, Nonempty (i ⟶ j) 
goal: CategoryTheory.FinallySmall J ↔ ∃ s, ∃ (_ : Small.{v, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (i ⟶ j)

full_name: CategoryTheory.InitiallySmall.exists_small_weakly_initial_set
code: /-- The converse is true if `J` is cofiltered, see `intiallySmall_of_small_weakly_initial_set`. -/
theorem InitiallySmall.exists_small_weakly_initial_set [InitiallySmall.{w} J] :
    ∃ (s : Set J) (_ : Small.{w} s), ∀ i, ∃ j ∈ s, Nonempty (j ⟶ i) 
goal: ∃ s, ∃ (_ : Small.{w, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)

full_name: CategoryTheory.initiallySmall_of_small_weakly_initial_set
code: theorem initiallySmall_of_small_weakly_initial_set [IsCofilteredOrEmpty J] (s : Set J) [Small.{v} s]
    (hs : ∀ i, ∃ j ∈ s, Nonempty (j ⟶ i)) : InitiallySmall.{v} J 
goal: CategoryTheory.InitiallySmall J

full_name: CategoryTheory.initiallySmall_iff_exists_small_weakly_initial_set
code: theorem initiallySmall_iff_exists_small_weakly_initial_set [IsCofilteredOrEmpty J] :
    InitiallySmall.{v} J ↔ ∃ (s : Set J) (_ : Small.{v} s), ∀ i, ∃ j ∈ s, Nonempty (j ⟶ i) 
goal: CategoryTheory.InitiallySmall J ↔ ∃ s, ∃ (_ : Small.{v, u} ↑s), ∀ (i : J), ∃ j ∈ s, Nonempty (j ⟶ i)

full_name: CategoryTheory.Limits.hasColimitsOfShape_of_finallySmall
code: theorem hasColimitsOfShape_of_finallySmall (J : Type u) [Category.{v} J] [FinallySmall.{w} J]
    (C : Type u₁) [Category.{v₁} C] [HasColimitsOfSize.{w, w} C] : HasColimitsOfShape J C 
goal: CategoryTheory.Limits.HasColimitsOfShape J C

full_name: CategoryTheory.Limits.hasLimitsOfShape_of_initiallySmall
code: theorem hasLimitsOfShape_of_initiallySmall (J : Type u) [Category.{v} J] [InitiallySmall.{w} J]
    (C : Type u₁) [Category.{v₁} C] [HasLimitsOfSize.{w, w} C] : HasLimitsOfShape J C 
goal: CategoryTheory.Limits.HasLimitsOfShape J C