Limit properties relating to the (co)yoneda embedding.

We calculate the colimit of Y ↦ (X ⟶ Y), which is just PUnit. (This is used in characterising cofinal functors.)

We also show the (co)yoneda embeddings preserve limits and jointly reflect them.

def CategoryTheory.Coyoneda.colimitCocone {C : Type u} [Category.{v, u} C] (X : Cᵒᵖ) : Limits.Cocone (coyoneda.obj X)

The colimit cocone over coyoneda.obj X, with cocone point PUnit.

@[simp]

theorem CategoryTheory.Coyoneda.colimitCocone_ι_app {C : Type u} [Category.{v, u} C] (X : Cᵒᵖ) (X_1 : C) (a : (coyoneda.obj X).obj X_1) : (colimitCocone X).ι.app X_1 a = id PUnit.unit

@[simp]

theorem CategoryTheory.Coyoneda.colimitCocone_pt {C : Type u} [Category.{v, u} C] (X : Cᵒᵖ) : (colimitCocone X).pt = PUnit.{v + 1}

def CategoryTheory.Coyoneda.colimitCoconeIsColimit {C : Type u} [Category.{v, u} C] (X : Cᵒᵖ) : Limits.IsColimit (colimitCocone X)

The proposed colimit cocone over coyoneda.obj X is a colimit cocone.

@[simp]

theorem CategoryTheory.Coyoneda.colimitCoconeIsColimit_desc {C : Type u} [Category.{v, u} C] (X : Cᵒᵖ) (s : Limits.Cocone (coyoneda.obj X)) (x✝ : (colimitCocone X).pt) : (colimitCoconeIsColimit X).desc s x✝ = s.ι.app (Opposite.unop X) (CategoryStruct.id (Opposite.unop X))

instance CategoryTheory.Coyoneda.instHasColimitObjOppositeFunctorTypeCoyoneda {C : Type u} [Category.{v, u} C] (X : Cᵒᵖ) : Limits.HasColimit (coyoneda.obj X)

noncomputable def CategoryTheory.Coyoneda.colimitCoyonedaIso {C : Type u} [Category.{v, u} C] (X : Cᵒᵖ) : Limits.colimit (coyoneda.obj X) ≅ PUnit.{v + 1}

The colimit of coyoneda.obj X is isomorphic to PUnit.

def CategoryTheory.Limits.coneOfSectionCompYoneda {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J Cᵒᵖ) (X : C) (s : ↑(F.comp (yoneda.obj X)).sections) : Cone F

The cone of F corresponding to an element in (F ⋙ yoneda.obj X).sections.

@[simp]

theorem CategoryTheory.Limits.coneOfSectionCompYoneda_π {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J Cᵒᵖ) (X : C) (s : ↑(F.comp (yoneda.obj X)).sections) : (coneOfSectionCompYoneda F X s).π = (compYonedaSectionsEquiv F X) s

@[simp]

theorem CategoryTheory.Limits.coneOfSectionCompYoneda_pt {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J Cᵒᵖ) (X : C) (s : ↑(F.comp (yoneda.obj X)).sections) : (coneOfSectionCompYoneda F X s).pt = Opposite.op X

instance CategoryTheory.yoneda_preservesLimit {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J Cᵒᵖ) (X : C) : Limits.PreservesLimit F (yoneda.obj X)

instance CategoryTheory.yoneda_preservesLimitsOfShape {C : Type u} [Category.{v, u} C] (J : Type w) [Category.{t, w} J] (X : C) : Limits.PreservesLimitsOfShape J (yoneda.obj X)

def CategoryTheory.yonedaJointlyReflectsLimits {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J Cᵒᵖ) (c : Limits.Cone F) (hc : (X : C) → Limits.IsLimit ((yoneda.obj X).mapCone c)) : Limits.IsLimit c

The yoneda embeddings jointly reflect limits.

noncomputable def CategoryTheory.Limits.Cocone.isColimitYonedaEquiv {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {F : Functor J C} (c : Cocone F) : IsColimit c ≃ ((X : C) → IsLimit ((yoneda.obj X).mapCone c.op))

A cocone is colimit iff it becomes limit after the application of yoneda.obj X for all X : C.

def CategoryTheory.Limits.coneOfSectionCompCoyoneda {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J C) (X : Cᵒᵖ) (s : ↑(F.comp (coyoneda.obj X)).sections) : Cone F

The cone of F corresponding to an element in (F ⋙ coyoneda.obj X).sections.

@[simp]

theorem CategoryTheory.Limits.coneOfSectionCompCoyoneda_π {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J C) (X : Cᵒᵖ) (s : ↑(F.comp (coyoneda.obj X)).sections) : (coneOfSectionCompCoyoneda F X s).π = (compCoyonedaSectionsEquiv F (Opposite.unop X)) s

@[simp]

theorem CategoryTheory.Limits.coneOfSectionCompCoyoneda_pt {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J C) (X : Cᵒᵖ) (s : ↑(F.comp (coyoneda.obj X)).sections) : (coneOfSectionCompCoyoneda F X s).pt = Opposite.unop X

instance CategoryTheory.coyoneda_preservesLimit {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J C) (X : Cᵒᵖ) : Limits.PreservesLimit F (coyoneda.obj X)

instance CategoryTheory.coyonedaPreservesLimitsOfShape {C : Type u} [Category.{v, u} C] (J : Type w) [Category.{t, w} J] (X : Cᵒᵖ) : Limits.PreservesLimitsOfShape J (coyoneda.obj X)

def CategoryTheory.coyonedaJointlyReflectsLimits {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J C) (c : Limits.Cone F) (hc : (X : Cᵒᵖ) → Limits.IsLimit ((coyoneda.obj X).mapCone c)) : Limits.IsLimit c

The coyoneda embeddings jointly reflect limits.

noncomputable def CategoryTheory.Limits.Cone.isLimitCoyonedaEquiv {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {F : Functor J C} (c : Cone F) : IsLimit c ≃ ((X : Cᵒᵖ) → IsLimit ((coyoneda.obj X).mapCone c))

A cone is limit iff it is so after the application of coyoneda.obj X for all X : Cᵒᵖ.

instance CategoryTheory.yoneda_preservesLimits {C : Type u} [Category.{v, u} C] (X : C) : Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} (yoneda.obj X)

The yoneda embedding yoneda.obj X : Cᵒᵖ ⥤ Type v for X : C preserves limits.

instance CategoryTheory.coyoneda_preservesLimits {C : Type u} [Category.{v, u} C] (X : Cᵒᵖ) : Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} (coyoneda.obj X)

The coyoneda embedding coyoneda.obj X : C ⥤ Type v for X : Cᵒᵖ preserves limits.

instance CategoryTheory.yonedaFunctor_preservesLimits {C : Type u} [Category.{v, u} C] : Limits.PreservesLimitsOfSize.{t, w, v, max u v, u, max u (v + 1)} yoneda

instance CategoryTheory.coyonedaFunctor_preservesLimits {C : Type u} [Category.{v, u} C] : Limits.PreservesLimitsOfSize.{t, w, v, max u v, u, max u (v + 1)} coyoneda

instance CategoryTheory.yonedaFunctor_reflectsLimits {C : Type u} [Category.{v, u} C] : Limits.ReflectsLimitsOfSize.{t, w, v, max u v, u, max u (v + 1)} yoneda

instance CategoryTheory.coyonedaFunctor_reflectsLimits {C : Type u} [Category.{v, u} C] : Limits.ReflectsLimitsOfSize.{t, w, v, max u v, u, max u (v + 1)} coyoneda

instance CategoryTheory.uliftYonedaFunctor_preservesLimits {C : Type u} [Category.{v, u} C] : Limits.PreservesLimitsOfSize.{t, w, v, max (max u v) w', u, max (max u (v + 1)) (w' + 1)} uliftYoneda.{w', v, u}

instance CategoryTheory.instPreservesLimitsOfSizeFunctorOppositeTypeShrinkYoneda {C : Type u} [Category.{v, u} C] [LocallySmall.{w', v, u} C] : Limits.PreservesLimitsOfSize.{t, w, v, max u w', u, max (max u v) (w' + 1)} shrinkYoneda.{w', v, u}

instance CategoryTheory.Functor.representable_preservesLimit {C : Type u} [Category.{v, u} C] (F : Functor Cᵒᵖ (Type v)) [F.IsRepresentable] {J : Type u_1} [Category.{v_1, u_1} J] (G : Functor J Cᵒᵖ) : Limits.PreservesLimit G F

instance CategoryTheory.Functor.representable_preservesLimitsOfShape {C : Type u} [Category.{v, u} C] (F : Functor Cᵒᵖ (Type v)) [F.IsRepresentable] (J : Type u_1) [Category.{v_1, u_1} J] : Limits.PreservesLimitsOfShape J F

instance CategoryTheory.Functor.representable_preservesLimits {C : Type u} [Category.{v, u} C] (F : Functor Cᵒᵖ (Type v)) [F.IsRepresentable] : Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} F

instance CategoryTheory.Functor.corepresentable_preservesLimit {C : Type u} [Category.{v, u} C] (F : Functor C (Type v)) [F.IsCorepresentable] {J : Type u_1} [Category.{v_1, u_1} J] (G : Functor J C) : Limits.PreservesLimit G F

instance CategoryTheory.Functor.corepresentable_preservesLimitsOfShape {C : Type u} [Category.{v, u} C] (F : Functor C (Type v)) [F.IsCorepresentable] (J : Type u_1) [Category.{v_1, u_1} J] : Limits.PreservesLimitsOfShape J F

instance CategoryTheory.Functor.corepresentable_preservesLimits {C : Type u} [Category.{v, u} C] (F : Functor C (Type v)) [F.IsCorepresentable] : Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} F