File: Mathlib/CategoryTheory/Limits/Yoneda.lean

full_name: CategoryTheory.Coyoneda.colimitCocone
code: /-- The colimit cocone over `coyoneda.obj X`, with cocone point `PUnit`.
-/
@[simps]
def colimitCocone (X : Cᵒᵖ) : Cocone (coyoneda.obj X) 
goal: CategoryTheory.Limits.Cocone (CategoryTheory.coyoneda.obj X)

full_name: CategoryTheory.Coyoneda.colimitCocone_pt
code: /-- The colimit cocone over `coyoneda.obj X`, with cocone point `PUnit`.
-/
@[simps]
def colimitCocone (X : Cᵒᵖ) : Cocone (coyoneda.obj X) 
goal: (CategoryTheory.Coyoneda.colimitCocone X).pt = PUnit.{v + 1}

full_name: CategoryTheory.Coyoneda.colimitCocone_ι_app
code: /-- The colimit cocone over `coyoneda.obj X`, with cocone point `PUnit`.
-/
@[simps]
def colimitCocone (X : Cᵒᵖ) : Cocone (coyoneda.obj X) 
goal: (CategoryTheory.Coyoneda.colimitCocone X).ι.app X_1 a = id PUnit.unit

full_name: CategoryTheory.Coyoneda.colimitCoconeIsColimit
code: /-- The proposed colimit cocone over `coyoneda.obj X` is a colimit cocone.
-/
@[simps]
def colimitCoconeIsColimit (X : Cᵒᵖ) : IsColimit (colimitCocone X) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Coyoneda.colimitCocone X)

full_name: CategoryTheory.Coyoneda.colimitCoconeIsColimit_desc
code: /-- The proposed colimit cocone over `coyoneda.obj X` is a colimit cocone.
-/
@[simps]
def colimitCoconeIsColimit (X : Cᵒᵖ) : IsColimit (colimitCocone X) 
goal: ∀ (x : (CategoryTheory.Coyoneda.colimitCocone X).pt),
  (CategoryTheory.Coyoneda.colimitCoconeIsColimit X).desc s x = s.ι.app (Opposite.unop X) (𝟙 (Opposite.unop X))

full_name: CategoryTheory.Coyoneda.instHasColimitObjOppositeFunctorTypeCoyoneda
code: instance (X : Cᵒᵖ) : HasColimit (coyoneda.obj X) 
goal: CategoryTheory.Limits.HasColimit (CategoryTheory.coyoneda.obj X)

full_name: CategoryTheory.Coyoneda.colimitCoyonedaIso
code: /-- The colimit of `coyoneda.obj X` is isomorphic to `PUnit`.
-/
noncomputable def colimitCoyonedaIso (X : Cᵒᵖ) : colimit (coyoneda.obj X) ≅ PUnit 
goal: CategoryTheory.Limits.colimit (CategoryTheory.coyoneda.obj X) ≅ PUnit.{v + 1}

full_name: CategoryTheory.Limits.coneOfSectionCompYoneda
code: /-- The cone of `F` corresponding to an element in `(F ⋙ yoneda.obj X).sections`. -/
@[simps]
def Limits.coneOfSectionCompYoneda (F : J ⥤ Cᵒᵖ) (X : C)
    (s : (F ⋙ yoneda.obj X).sections) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.coneOfSectionCompYoneda_pt
code: /-- The cone of `F` corresponding to an element in `(F ⋙ yoneda.obj X).sections`. -/
@[simps]
def Limits.coneOfSectionCompYoneda (F : J ⥤ Cᵒᵖ) (X : C)
    (s : (F ⋙ yoneda.obj X).sections) : Cone F 
goal: (CategoryTheory.Limits.coneOfSectionCompYoneda F X s).pt = Opposite.op X

full_name: CategoryTheory.Limits.coneOfSectionCompYoneda_π
code: /-- The cone of `F` corresponding to an element in `(F ⋙ yoneda.obj X).sections`. -/
@[simps]
def Limits.coneOfSectionCompYoneda (F : J ⥤ Cᵒᵖ) (X : C)
    (s : (F ⋙ yoneda.obj X).sections) : Cone F 
goal: (CategoryTheory.Limits.coneOfSectionCompYoneda F X s).π = (CategoryTheory.Limits.compYonedaSectionsEquiv F X) s

full_name: CategoryTheory.yonedaPreservesLimit
code: noncomputable instance yonedaPreservesLimit (F : J ⥤ Cᵒᵖ) (X : C) :
    PreservesLimit F (yoneda.obj X) 
goal: CategoryTheory.Limits.PreservesLimit F (CategoryTheory.yoneda.obj X)

full_name: CategoryTheory.yonedaPreservesLimitsOfShape
code: noncomputable instance yonedaPreservesLimitsOfShape (X : C) :
    PreservesLimitsOfShape J (yoneda.obj X) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.yoneda.obj X)

full_name: CategoryTheory.yonedaJointlyReflectsLimits
code: /-- The yoneda embeddings jointly reflect limits. -/
def yonedaJointlyReflectsLimits (F : J ⥤ Cᵒᵖ) (c : Cone F)
    (hc : ∀ X : C, IsLimit ((yoneda.obj X).mapCone c)) : IsLimit c 
goal: CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.Cocone.isColimitYonedaEquiv
code: /-- A cocone is colimit iff it becomes limit after the
application of `yoneda.obj X` for all `X : C`. -/
noncomputable def Limits.Cocone.isColimitYonedaEquiv {F : J ⥤ C} (c : Cocone F) :
    IsColimit c ≃ ∀ (X : C), IsLimit ((yoneda.obj X).mapCone c.op) 
goal: CategoryTheory.Limits.IsColimit c ≃
  ((X : C) → CategoryTheory.Limits.IsLimit ((CategoryTheory.yoneda.obj X).mapCone c.op))

full_name: CategoryTheory.Limits.coneOfSectionCompCoyoneda_pt
code: /-- The cone of `F` corresponding to an element in `(F ⋙ coyoneda.obj X).sections`. -/
@[simps]
def Limits.coneOfSectionCompCoyoneda (F : J ⥤ C) (X : Cᵒᵖ)
    (s : (F ⋙ coyoneda.obj X).sections) : Cone F 
goal: (CategoryTheory.Limits.coneOfSectionCompCoyoneda F X s).pt = Opposite.unop X

full_name: CategoryTheory.Limits.coneOfSectionCompCoyoneda
code: /-- The cone of `F` corresponding to an element in `(F ⋙ coyoneda.obj X).sections`. -/
@[simps]
def Limits.coneOfSectionCompCoyoneda (F : J ⥤ C) (X : Cᵒᵖ)
    (s : (F ⋙ coyoneda.obj X).sections) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.coneOfSectionCompCoyoneda_π
code: /-- The cone of `F` corresponding to an element in `(F ⋙ coyoneda.obj X).sections`. -/
@[simps]
def Limits.coneOfSectionCompCoyoneda (F : J ⥤ C) (X : Cᵒᵖ)
    (s : (F ⋙ coyoneda.obj X).sections) : Cone F 
goal: (CategoryTheory.Limits.coneOfSectionCompCoyoneda F X s).π =
  (CategoryTheory.Limits.compCoyonedaSectionsEquiv F (Opposite.unop X)) s

full_name: CategoryTheory.coyonedaPreservesLimit
code: noncomputable instance coyonedaPreservesLimit (F : J ⥤ C) (X : Cᵒᵖ) :
    PreservesLimit F (coyoneda.obj X) 
goal: CategoryTheory.Limits.PreservesLimit F (CategoryTheory.coyoneda.obj X)

full_name: CategoryTheory.coyonedaPreservesLimitsOfShape
code: noncomputable instance coyonedaPreservesLimitsOfShape (X : Cᵒᵖ) :
    PreservesLimitsOfShape J (coyoneda.obj X) 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.coyoneda.obj X)

full_name: CategoryTheory.coyonedaJointlyReflectsLimits
code: /-- The coyoneda embeddings jointly reflect limits. -/
def coyonedaJointlyReflectsLimits (F : J ⥤ C) (c : Cone F)
    (hc : ∀ X : Cᵒᵖ, IsLimit ((coyoneda.obj X).mapCone c)) : IsLimit c 
goal: CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.Cone.isLimitCoyonedaEquiv
code: /-- A cone is limit iff it is so after the application of `coyoneda.obj X` for all `X : Cᵒᵖ`. -/
noncomputable def Limits.Cone.isLimitCoyonedaEquiv {F : J ⥤ C} (c : Cone F) :
    IsLimit c ≃ ∀ (X : Cᵒᵖ), IsLimit ((coyoneda.obj X).mapCone c) 
goal: CategoryTheory.Limits.IsLimit c ≃
  ((X : Cᵒᵖ) → CategoryTheory.Limits.IsLimit ((CategoryTheory.coyoneda.obj X).mapCone c))

full_name: CategoryTheory.yonedaPreservesLimits
code: /-- The yoneda embedding `yoneda.obj X : Cᵒᵖ ⥤ Type v` for `X : C` preserves limits. -/
noncomputable instance yonedaPreservesLimits (X : C) :
    PreservesLimitsOfSize.{t, w} (yoneda.obj X) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} (CategoryTheory.yoneda.obj X)

full_name: CategoryTheory.coyonedaPreservesLimits
code: /-- The coyoneda embedding `coyoneda.obj X : C ⥤ Type v` for `X : Cᵒᵖ` preserves limits. -/
noncomputable instance coyonedaPreservesLimits (X : Cᵒᵖ) :
    PreservesLimitsOfSize.{t, w} (coyoneda.obj X) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} (CategoryTheory.coyoneda.obj X)

full_name: CategoryTheory.yonedaFunctorPreservesLimits
code: noncomputable instance yonedaFunctorPreservesLimits :
    PreservesLimitsOfSize.{t, w} (@yoneda C _) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{t, w, v, max u v, u, max u (v + 1)} CategoryTheory.yoneda

full_name: CategoryTheory.coyonedaFunctorPreservesLimits
code: noncomputable instance coyonedaFunctorPreservesLimits :
    PreservesLimitsOfSize.{t, w} (@coyoneda C _) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{t, w, v, max u v, u, max u (v + 1)} CategoryTheory.coyoneda

full_name: CategoryTheory.yonedaFunctorReflectsLimits
code: noncomputable instance yonedaFunctorReflectsLimits :
    ReflectsLimitsOfSize.{t, w} (@yoneda C _) 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{t, w, v, max u v, u, max u (v + 1)} CategoryTheory.yoneda

full_name: CategoryTheory.coyonedaFunctorReflectsLimits
code: noncomputable instance coyonedaFunctorReflectsLimits :
    ReflectsLimitsOfSize.{t, w} (@coyoneda C _) 
goal: CategoryTheory.Limits.ReflectsLimitsOfSize.{t, w, v, max u v, u, max u (v + 1)} CategoryTheory.coyoneda

full_name: CategoryTheory.Functor.representablePreservesLimit
code: noncomputable instance representablePreservesLimit (G : J ⥤ Cᵒᵖ) :
    PreservesLimit G F 
goal: CategoryTheory.Limits.PreservesLimit G F

full_name: CategoryTheory.Functor.representablePreservesLimitsOfShape
code: noncomputable instance representablePreservesLimitsOfShape :
    PreservesLimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J F

full_name: CategoryTheory.Functor.representablePreservesLimits
code: noncomputable instance representablePreservesLimits :
    PreservesLimitsOfSize.{t, w} F 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} F

full_name: CategoryTheory.Functor.corepresentablePreservesLimit
code: noncomputable instance corepresentablePreservesLimit (G : J ⥤ C) :
    PreservesLimit G F 
goal: CategoryTheory.Limits.PreservesLimit G F

full_name: CategoryTheory.Functor.corepresentablePreservesLimitsOfShape
code: noncomputable instance corepresentablePreservesLimitsOfShape :
    PreservesLimitsOfShape J F 
goal: CategoryTheory.Limits.PreservesLimitsOfShape J F

full_name: CategoryTheory.Functor.corepresentablePreservesLimits
code: noncomputable instance corepresentablePreservesLimits :
    PreservesLimitsOfSize.{t, w} F 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{t, w, v, v, u, v + 1} F