File: Mathlib/CategoryTheory/Category/Cat/Limit.lean

full_name: CategoryTheory.Cat.HasLimits.categoryObjects
code: instance categoryObjects {F : J ⥤ Cat.{u, u}} {j} :
    SmallCategory ((F ⋙ Cat.objects.{u, u}).obj j) 
goal: CategoryTheory.SmallCategory ((F.comp CategoryTheory.Cat.objects).obj j)

full_name: CategoryTheory.Cat.HasLimits.homDiagram_map
code: /-- Auxiliary definition:
the diagram whose limit gives the morphism space between two objects of the limit category. -/
@[simps]
def homDiagram {F : J ⥤ Cat.{v, v}} (X Y : limit (F ⋙ Cat.objects.{v, v})) : J ⥤ Type v 
goal: ∀ {X_1 Y_1 : J} (f : X_1 ⟶ Y_1)
  (g :
    CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) X_1 X ⟶
      CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) X_1 Y),
  (CategoryTheory.Cat.HasLimits.homDiagram X Y).map f g =
    CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
      (CategoryTheory.CategoryStruct.comp ((F.map f).map g) (CategoryTheory.eqToHom ⋯))

full_name: CategoryTheory.Cat.HasLimits.homDiagram
code: /-- Auxiliary definition:
the diagram whose limit gives the morphism space between two objects of the limit category. -/
@[simps]
def homDiagram {F : J ⥤ Cat.{v, v}} (X Y : limit (F ⋙ Cat.objects.{v, v})) : J ⥤ Type v 
goal: CategoryTheory.Functor J (Type v)

full_name: CategoryTheory.Cat.HasLimits.homDiagram_obj
code: /-- Auxiliary definition:
the diagram whose limit gives the morphism space between two objects of the limit category. -/
@[simps]
def homDiagram {F : J ⥤ Cat.{v, v}} (X Y : limit (F ⋙ Cat.objects.{v, v})) : J ⥤ Type v 
goal: (CategoryTheory.Cat.HasLimits.homDiagram X Y).obj j =
  (CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) j X ⟶
    CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) j Y)

full_name: CategoryTheory.Cat.HasLimits.instCategoryLimitCompObjects_id
code: @[simps]
instance (F : J ⥤ Cat.{v, v}) : Category (limit (F ⋙ Cat.objects)) 
goal: CategoryTheory.CategoryStruct.id X =
  CategoryTheory.Limits.Types.Limit.mk (CategoryTheory.Cat.HasLimits.homDiagram X X)
    (fun j => CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) j X))
    ⋯

full_name: CategoryTheory.Cat.HasLimits.instCategoryLimitCompObjects_comp
code: @[simps]
instance (F : J ⥤ Cat.{v, v}) : Category (limit (F ⋙ Cat.objects)) 
goal: CategoryTheory.CategoryStruct.comp f g =
  CategoryTheory.Limits.Types.Limit.mk (CategoryTheory.Cat.HasLimits.homDiagram X Z)
    (fun j =>
      CategoryTheory.CategoryStruct.comp
        (CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram X Y) j f)
        (CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram Y Z) j g))
    ⋯

full_name: CategoryTheory.Cat.HasLimits.instCategoryLimitCompObjects
code: @[simps]
instance (F : J ⥤ Cat.{v, v}) : Category (limit (F ⋙ Cat.objects)) 
goal: CategoryTheory.Category.{v, v} (CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects))

full_name: CategoryTheory.Cat.HasLimits.limitConeX
code: /-- Auxiliary definition: the limit category. -/
@[simps]
def limitConeX (F : J ⥤ Cat.{v, v}) : Cat.{v, v} 
goal: CategoryTheory.Cat

full_name: CategoryTheory.Cat.HasLimits.limitConeX_str
code: /-- Auxiliary definition: the limit category. -/
@[simps]
def limitConeX (F : J ⥤ Cat.{v, v}) : Cat.{v, v} 
goal: (CategoryTheory.Cat.HasLimits.limitConeX F).str = inferInstance

full_name: CategoryTheory.Cat.HasLimits.limitConeX_α
code: /-- Auxiliary definition: the limit category. -/
@[simps]
def limitConeX (F : J ⥤ Cat.{v, v}) : Cat.{v, v} 
goal: ↑(CategoryTheory.Cat.HasLimits.limitConeX F) = CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)

full_name: CategoryTheory.Cat.HasLimits.limitCone_π_app_map
code: /-- Auxiliary definition: the cone over the limit category. -/
@[simps]
def limitCone (F : J ⥤ Cat.{v, v}) : Cone F 
goal: ∀ {X Y : ↑(((CategoryTheory.Functor.const J).obj (CategoryTheory.Cat.HasLimits.limitConeX F)).obj j)} (f : X ⟶ Y),
  ((CategoryTheory.Cat.HasLimits.limitCone F).π.app j).map f =
    CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram X Y) j f

full_name: CategoryTheory.Cat.HasLimits.limitCone
code: /-- Auxiliary definition: the cone over the limit category. -/
@[simps]
def limitCone (F : J ⥤ Cat.{v, v}) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Cat.HasLimits.limitCone_π_app_obj
code: /-- Auxiliary definition: the cone over the limit category. -/
@[simps]
def limitCone (F : J ⥤ Cat.{v, v}) : Cone F 
goal: ∀ (a : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)),
  ((CategoryTheory.Cat.HasLimits.limitCone F).π.app j).obj a =
    CategoryTheory.Limits.limit.π (F.comp CategoryTheory.Cat.objects) j a

full_name: CategoryTheory.Cat.HasLimits.limitCone_pt
code: /-- Auxiliary definition: the cone over the limit category. -/
@[simps]
def limitCone (F : J ⥤ Cat.{v, v}) : Cone F 
goal: (CategoryTheory.Cat.HasLimits.limitCone F).pt = CategoryTheory.Cat.HasLimits.limitConeX F

full_name: CategoryTheory.Cat.HasLimits.limitConeLift_obj
code: /-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F 
goal: ∀ (a : { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } }.pt),
  (CategoryTheory.Cat.HasLimits.limitConeLift F s).obj a =
    CategoryTheory.Limits.limit.lift (F.comp CategoryTheory.Cat.objects)
      { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } a

full_name: CategoryTheory.Cat.HasLimits.limitConeLift
code: /-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F 
goal: s.pt ⟶ CategoryTheory.Cat.HasLimits.limitConeX F

full_name: CategoryTheory.Cat.HasLimits.limitConeLift_map
code: /-- Auxiliary definition: the universal morphism to the proposed limit cone. -/
@[simps]
def limitConeLift (F : J ⥤ Cat.{v, v}) (s : Cone F) : s.pt ⟶ limitConeX F 
goal: ∀ {X Y : ↑s.pt} (f : X ⟶ Y),
  (CategoryTheory.Cat.HasLimits.limitConeLift F s).map f =
    CategoryTheory.Limits.Types.Limit.mk
      (CategoryTheory.Cat.HasLimits.homDiagram
        (CategoryTheory.Limits.limit.lift (F.comp CategoryTheory.Cat.objects)
          { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } X)
        (CategoryTheory.Limits.limit.lift (F.comp CategoryTheory.Cat.objects)
          { pt := ↑s.pt, π := { app := fun j => (s.π.app j).obj, naturality := ⋯ } } Y))
      (fun j =>
        CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
          (CategoryTheory.CategoryStruct.comp ((s.π.app j).map f) (CategoryTheory.eqToHom ⋯)))
      ⋯

full_name: CategoryTheory.Cat.HasLimits.limit_π_homDiagram_eqToHom
code: @[simp]
theorem limit_π_homDiagram_eqToHom {F : J ⥤ Cat.{v, v}} (X Y : limit (F ⋙ Cat.objects.{v, v}))
    (j : J) (h : X = Y) :
    limit.π (homDiagram X Y) j (eqToHom h) =
      eqToHom (congr_arg (limit.π (F ⋙ Cat.objects.{v, v}) j) h) 
goal: CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram X Y) j (CategoryTheory.eqToHom h) =
  CategoryTheory.eqToHom ⋯

full_name: CategoryTheory.Cat.HasLimits.limitConeIsLimit
code: /-- Auxiliary definition: the proposed cone is a limit cone. -/
def limitConeIsLimit (F : J ⥤ Cat.{v, v}) : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Cat.HasLimits.limitCone F)

full_name: CategoryTheory.Cat.instHasLimits
code: /-- The category of small categories has all small limits. -/
instance : HasLimits Cat.{v, v} 
goal: CategoryTheory.Limits.HasLimits CategoryTheory.Cat

full_name: CategoryTheory.Cat.instPreservesLimitsObjects
code: instance : PreservesLimits Cat.objects.{v, v} 
goal: CategoryTheory.Limits.PreservesLimits CategoryTheory.Cat.objects