Connected limits in the over category

We show that the projection CostructuredArrow K B ⥤ C creates and preserves connected limits, without assuming that C has any limits. In particular, CostructuredArrow K B has any connected limit which C has.

From this we deduce the corresponding results for the over category.

def CategoryTheory.CostructuredArrow.CreatesConnected.natTransInCostructuredArrow {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} {B : D} (F : Functor J (CostructuredArrow K B)) : F.comp ((proj K B).comp K) ⟶ (Functor.const J).obj B

(Implementation) Given a diagram in CostructuredArrow K B, produce a natural transformation from the diagram legs to the specific object.

Equations

• CategoryTheory.CostructuredArrow.CreatesConnected.natTransInCostructuredArrow F = { app := fun (j : J) => (F.obj j).hom, naturality := ⋯ }

@[simp]

theorem CategoryTheory.CostructuredArrow.CreatesConnected.natTransInCostructuredArrow_app {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} {B : D} (F : Functor J (CostructuredArrow K B)) (j : J) : (natTransInCostructuredArrow F).app j = (F.obj j).hom

noncomputable def CategoryTheory.CostructuredArrow.CreatesConnected.raiseCone {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} [IsConnected J] {B : D} {F : Functor J (CostructuredArrow K B)} (c : Limits.Cone (F.comp (proj K B))) : Limits.Cone F

(Implementation) Given a cone in the base category, raise it to a cone in CostructuredArrow K B. Note this is where the connected assumption is used.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.CostructuredArrow.CreatesConnected.raiseCone_π_app {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} [IsConnected J] {B : D} {F : Functor J (CostructuredArrow K B)} (c : Limits.Cone (F.comp (proj K B))) (j : J) : (raiseCone c).π.app j = homMk (c.π.app j) ⋯

@[simp]

theorem CategoryTheory.CostructuredArrow.CreatesConnected.raiseCone_pt {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} [IsConnected J] {B : D} {F : Functor J (CostructuredArrow K B)} (c : Limits.Cone (F.comp (proj K B))) : (raiseCone c).pt = mk (CategoryStruct.comp (K.map (c.π.app (Classical.arbitrary J))) (F.obj (Classical.arbitrary J)).hom)

theorem CategoryTheory.CostructuredArrow.CreatesConnected.mapCone_raiseCone {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} [IsConnected J] {B : D} {F : Functor J (CostructuredArrow K B)} (c : Limits.Cone (F.comp (proj K B))) : (proj K B).mapCone (raiseCone c) = c

noncomputable def CategoryTheory.CostructuredArrow.CreatesConnected.isLimitRaiseCone {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} [IsConnected J] {B : D} {F : Functor J (CostructuredArrow K B)} {c : Limits.Cone (F.comp (proj K B))} (t : Limits.IsLimit c) : Limits.IsLimit (raiseCone c)

(Implementation) Show that the raised cone is a limit.

Equations

• One or more equations did not get rendered due to their size.

@[implicit_reducible]

noncomputable instance CategoryTheory.CostructuredArrow.instCreatesLimitsOfShapeProjOfIsConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} [IsConnected J] {B : D} : CreatesLimitsOfShape J (proj K B)

The projection from CostructuredArrow K B to C creates any connected limit.

Equations

• One or more equations did not get rendered due to their size.

instance CategoryTheory.CostructuredArrow.instPreservesLimitsOfShapeProjOfIsConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} [IsConnected J] {B : D} : Limits.PreservesLimitsOfShape J (proj K B)

The forgetful functor from CostructuredArrow K B preserves any connected limit.

instance CategoryTheory.CostructuredArrow.hasLimitsOfShape_of_isConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} {B : D} [IsConnected J] [Limits.HasLimitsOfShape J C] : Limits.HasLimitsOfShape J (CostructuredArrow K B)

The over category has any connected limit which the original category has.

@[implicit_reducible]

noncomputable instance CategoryTheory.StructuredArrow.instCreatesColimitsOfShapeProjOfIsConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} [IsConnected J] {B : D} : CreatesColimitsOfShape J (proj B K)

The projection from StructuredArrow K B to C creates any connected colimit.

Equations

• CategoryTheory.StructuredArrow.instCreatesColimitsOfShapeProjOfIsConnected = CategoryTheory.Limits.createsColimitsOfShapeOfOp J (CategoryTheory.StructuredArrow.proj B K)

instance CategoryTheory.StructuredArrow.instPreservesColimitsOfShapeProjOfIsConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} [IsConnected J] {B : D} : Limits.PreservesColimitsOfShape J (proj B K)

The forgetful functor from StructuredArrow K B preserves any connected colimit.

instance CategoryTheory.StructuredArrow.instHasColimitsOfShapeOfIsConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} {B : D} [IsConnected J] [Limits.HasColimitsOfShape J C] : Limits.HasColimitsOfShape J (StructuredArrow B K)

@[implicit_reducible]

noncomputable instance CategoryTheory.Over.createsLimitsOfShapeForgetOfIsConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] [IsConnected J] {B : C} : CreatesLimitsOfShape J (forget B)

The forgetful functor from the over category creates any connected limit.

Equations

• CategoryTheory.Over.createsLimitsOfShapeForgetOfIsConnected = { CreatesLimit := @CategoryTheory.Over.createsLimitsOfShapeForgetOfIsConnected._aux_1 J inst✝² C inst✝¹ inst✝ B }

instance CategoryTheory.Over.preservesLimitsOfShape_forget_of_isConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] [IsConnected J] {B : C} : Limits.PreservesLimitsOfShape J (forget B)

The forgetful functor from the over category preserves any connected limit.

instance CategoryTheory.Over.hasLimitsOfShape_of_isConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {B : C} [IsConnected J] [Limits.HasLimitsOfShape J C] : Limits.HasLimitsOfShape J (Over B)

The over category has any connected limit which the original category has.

def CategoryTheory.Over.conePost {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] (F : Functor J C) (i : J) : Functor (Limits.Cone F) (Limits.Cone (post F))

The functor taking a cone over F to a cone over Over.post F : Over i ⥤ Over (F.obj i). This takes limit cones to limit cones when J is cofiltered. See isLimitConePost

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Over.conePost_map_hom {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] (F : Functor J C) (i : J) {X✝ Y✝ : Limits.Cone F} (f : X✝ ⟶ Y✝) : ((conePost F i).map f).hom = homMk f.hom ⋯

@[simp]

theorem CategoryTheory.Over.conePost_obj_pt {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] (F : Functor J C) (i : J) (c : Limits.Cone F) : ((conePost F i).obj c).pt = mk (c.π.app i)

@[simp]

theorem CategoryTheory.Over.conePost_obj_π_app {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] (F : Functor J C) (i : J) (c : Limits.Cone F) (X : Over i) : ((conePost F i).obj c).π.app X = homMk (c.π.app X.left) ⋯

def CategoryTheory.Over.conePostIso {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] (F : Functor J C) (i : J) : (conePost F i).comp (Limits.Cone.functoriality (post F) (forget (F.obj i))) ≅ Limits.Cone.whiskering (forget i)

conePost is compatible with the forgetful functors on over categories.

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.Over.conePostIso_inv_app_hom {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] (F : Functor J C) (i : J) (X : Limits.Cone F) : ((conePostIso F i).inv.app X).hom = CategoryStruct.id X.pt

@[simp]

theorem CategoryTheory.Over.conePostIso_hom_app_hom {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] (F : Functor J C) (i : J) (X : Limits.Cone F) : ((conePostIso F i).hom.app X).hom = CategoryStruct.id X.pt

noncomputable def CategoryTheory.Over.isLimitConePost {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] [IsCofilteredOrEmpty J] {F : Functor J C} {c : Limits.Cone F} (i : J) (hc : Limits.IsLimit c) : Limits.IsLimit ((conePost F i).obj c)

The functor taking a cone over F to a cone over Over.post F : Over i ⥤ Over (F.obj i) preserves limit cones

Equations

• One or more equations did not get rendered due to their size.

instance CategoryTheory.instPreservesLimitsOfShapeCostructuredArrowOverToOverOfIsConnectedOfHasLimitsOfShape {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} {B : D} [IsConnected J] [Limits.HasLimitsOfShape J C] [Limits.PreservesLimitsOfShape J K] : Limits.PreservesLimitsOfShape J (CostructuredArrow.toOver K B)

@[implicit_reducible]

noncomputable instance CategoryTheory.Under.createsColimitsOfShapeForgetOfIsConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] [IsConnected J] {B : C} : CreatesColimitsOfShape J (forget B)

The forgetful functor from the under category creates any connected limit.

Equations

• CategoryTheory.Under.createsColimitsOfShapeForgetOfIsConnected = { CreatesColimit := @CategoryTheory.Under.createsColimitsOfShapeForgetOfIsConnected._aux_1 J inst✝² C inst✝¹ inst✝ B }

instance CategoryTheory.Under.preservesColimitsOfShape_forget_of_isConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] [IsConnected J] {B : C} : Limits.PreservesColimitsOfShape J (forget B)

The forgetful functor from the under category preserves any connected limit.

instance CategoryTheory.Under.hasColimitsOfShape_of_isConnected {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {B : C} [IsConnected J] [Limits.HasColimitsOfShape J C] : Limits.HasColimitsOfShape J (Under B)

The under category has any connected limit which the original category has.

instance CategoryTheory.instPreservesColimitsOfShapeStructuredArrowUnderToUnderOfIsConnectedOfHasColimitsOfShape {J : Type u'} [Category.{v', u'} J] {C : Type u} [Category.{v, u} C] {D : Type u_1} [Category.{v_1, u_1} D] {K : Functor C D} {B : D} [IsConnected J] [Limits.HasColimitsOfShape J C] [Limits.PreservesColimitsOfShape J K] : Limits.PreservesColimitsOfShape J (StructuredArrow.toUnder B K)