File: Mathlib/CategoryTheory/Limits/Types.lean

full_name: CategoryTheory.Limits.Types.coneOfSection
code: /-- Given a section of a functor F into `Type*`,
  construct a cone over F with `PUnit` as the cone point. -/
def coneOfSection {s} (hs : s ∈ F.sections) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.Types.sectionOfCone
code: /-- Given a cone over a functor F into `Type*` and an element in the cone point,
  construct a section of F. -/
def sectionOfCone (c : Cone F) (x : c.pt) : F.sections 
goal: ↑F.sections

full_name: CategoryTheory.Limits.Types.isLimit_iff
code: theorem isLimit_iff (c : Cone F) :
    Nonempty (IsLimit c) ↔ ∀ s ∈ F.sections, ∃! x : c.pt, ∀ j, c.π.app j x = s j 
goal: Nonempty (CategoryTheory.Limits.IsLimit c) ↔ ∀ s ∈ F.sections, ∃! x, ∀ (j : J), c.π.app j x = s j

full_name: CategoryTheory.Limits.Types.isLimit_iff_bijective_sectionOfCone
code: theorem isLimit_iff_bijective_sectionOfCone (c : Cone F) :
    Nonempty (IsLimit c) ↔ (Types.sectionOfCone c).Bijective 
goal: Nonempty (CategoryTheory.Limits.IsLimit c) ↔ Function.Bijective (CategoryTheory.Limits.Types.sectionOfCone c)

full_name: CategoryTheory.Limits.Types.isLimitEquivSections
code: /-- The equivalence between a limiting cone of `F` in `Type u` and the "concrete" definition as the
  sections of `F`. -/
noncomputable def isLimitEquivSections {c : Cone F} (t : IsLimit c) :
    c.pt ≃ F.sections 
goal: c.pt ≃ ↑F.sections

full_name: CategoryTheory.Limits.Types.isLimitEquivSections_apply
code: @[simp]
theorem isLimitEquivSections_apply {c : Cone F} (t : IsLimit c) (j : J)
    (x : c.pt) : (isLimitEquivSections t x : ∀ j, F.obj j) j = c.π.app j x 
goal: ↑((CategoryTheory.Limits.Types.isLimitEquivSections t) x) j = c.π.app j x

full_name: CategoryTheory.Limits.Types.isLimitEquivSections_symm_apply
code: @[simp]
theorem isLimitEquivSections_symm_apply {c : Cone F} (t : IsLimit c)
    (x : F.sections) (j : J) :
    c.π.app j ((isLimitEquivSections t).symm x) = (x : ∀ j, F.obj j) j 
goal: c.π.app j ((CategoryTheory.Limits.Types.isLimitEquivSections t).symm x) = ↑x j

full_name: CategoryTheory.Limits.Types.Small.limitCone_pt
code: /-- (internal implementation) the limit cone of a functor,
implemented as flat sections of a pi type
-/
@[simps]
noncomputable def limitCone : Cone F 
goal: (CategoryTheory.Limits.Types.Small.limitCone F).pt = Shrink.{u, max u v} ↑F.sections

full_name: CategoryTheory.Limits.Types.Small.limitCone
code: /-- (internal implementation) the limit cone of a functor,
implemented as flat sections of a pi type
-/
@[simps]
noncomputable def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.Types.Small.limitCone_π_app
code: /-- (internal implementation) the limit cone of a functor,
implemented as flat sections of a pi type
-/
@[simps]
noncomputable def limitCone : Cone F 
goal: (CategoryTheory.Limits.Types.Small.limitCone F).π.app j u = ↑((equivShrink ↑F.sections).symm u) j

full_name: CategoryTheory.Limits.Types.Small.limitCone_pt_ext
code: @[ext]
lemma limitCone_pt_ext {x y : (limitCone F).pt}
    (w : (equivShrink F.sections).symm x = (equivShrink F.sections).symm y) : x = y 
goal: x = y

full_name: CategoryTheory.Limits.Types.Small.limitConeIsLimit
code: /-- (internal implementation) the fact that the proposed limit cone is the limit -/
@[simps]
noncomputable def limitConeIsLimit : IsLimit (limitCone.{v, u} F) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Types.Small.limitCone F)

full_name: CategoryTheory.Limits.Types.Small.limitConeIsLimit_lift
code: /-- (internal implementation) the fact that the proposed limit cone is the limit -/
@[simps]
noncomputable def limitConeIsLimit : IsLimit (limitCone.{v, u} F) 
goal: (CategoryTheory.Limits.Types.Small.limitConeIsLimit F).lift s v = (equivShrink ↑F.sections) ⟨fun j => s.π.app j v, ⋯⟩

full_name: CategoryTheory.Limits.Types.hasLimit_iff_small_sections
code: theorem hasLimit_iff_small_sections (F : J ⥤ Type u) : HasLimit F ↔ Small.{u} F.sections 
goal: CategoryTheory.Limits.HasLimit F ↔ Small.{u, max u v} ↑F.sections

full_name: CategoryTheory.Limits.Types.limitCone_π_app
code: /-- (internal implementation) the limit cone of a functor,
implemented as flat sections of a pi type
-/
@[simps]
noncomputable def limitCone (F : J ⥤ TypeMax.{v, u}) : Cone F 
goal: (CategoryTheory.Limits.Types.limitCone F).π.app j u = ↑u j

full_name: CategoryTheory.Limits.Types.limitCone_pt
code: /-- (internal implementation) the limit cone of a functor,
implemented as flat sections of a pi type
-/
@[simps]
noncomputable def limitCone (F : J ⥤ TypeMax.{v, u}) : Cone F 
goal: (CategoryTheory.Limits.Types.limitCone F).pt = ↑F.sections

full_name: CategoryTheory.Limits.Types.limitCone
code: /-- (internal implementation) the limit cone of a functor,
implemented as flat sections of a pi type
-/
@[simps]
noncomputable def limitCone (F : J ⥤ TypeMax.{v, u}) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.Types.limitConeIsLimit
code: /-- (internal implementation) the fact that the proposed limit cone is the limit -/
@[simps]
noncomputable def limitConeIsLimit (F : J ⥤ TypeMax.{v, u}) : IsLimit (limitCone F) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Types.limitCone F)

full_name: CategoryTheory.Limits.Types.limitConeIsLimit_lift_coe
code: /-- (internal implementation) the fact that the proposed limit cone is the limit -/
@[simps]
noncomputable def limitConeIsLimit (F : J ⥤ TypeMax.{v, u}) : IsLimit (limitCone F) 
goal: ↑((CategoryTheory.Limits.Types.limitConeIsLimit F).lift s v) j = s.π.app j v

full_name: CategoryTheory.Limits.Types.hasLimit
code: instance hasLimit [Small.{u} J] (F : J ⥤ Type u) : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.Types.hasLimitsOfShape
code: instance hasLimitsOfShape [Small.{u} J] : HasLimitsOfShape J (Type u) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (Type u)

full_name: CategoryTheory.Limits.Types.hasLimitsOfSize
code: /--
The category of types has all limits.

More specifically, when `UnivLE.{v, u}`, the category `Type u` has all `v`-small limits.

See <https://stacks.math.columbia.edu/tag/002U>.
-/
instance (priority := 1300) hasLimitsOfSize [UnivLE.{v, u}] : HasLimitsOfSize.{w, v} (Type u) 
goal: CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} (Type u)

full_name: CategoryTheory.Limits.Types.limitEquivSections
code: /-- The equivalence between the abstract limit of `F` in `TypeMax.{v, u}`
and the "concrete" definition as the sections of `F`.
-/
noncomputable def limitEquivSections : limit F ≃ F.sections 
goal: CategoryTheory.Limits.limit F ≃ ↑F.sections

full_name: CategoryTheory.Limits.Types.limitEquivSections_apply
code: @[simp]
theorem limitEquivSections_apply (x : limit F) (j : J) :
    ((limitEquivSections F) x : ∀ j, F.obj j) j = limit.π F j x 
goal: ↑((CategoryTheory.Limits.Types.limitEquivSections F) x) j = CategoryTheory.Limits.limit.π F j x

full_name: CategoryTheory.Limits.Types.limitEquivSections_symm_apply
code: @[simp]
theorem limitEquivSections_symm_apply (x : F.sections) (j : J) :
    limit.π F j ((limitEquivSections F).symm x) = (x : ∀ j, F.obj j) j 
goal: CategoryTheory.Limits.limit.π F j ((CategoryTheory.Limits.Types.limitEquivSections F).symm x) = ↑x j

full_name: CategoryTheory.Limits.Types.Limit.mk
code: /-- Construct a term of `limit F : Type u` from a family of terms `x : Π j, F.obj j`
which are "coherent": `∀ (j j') (f : j ⟶ j'), F.map f (x j) = x j'`.
-/
noncomputable def Limit.mk (x : ∀ j, F.obj j) (h : ∀ (j j') (f : j ⟶ j'), F.map f (x j) = x j') :
    limit F 
goal: CategoryTheory.Limits.limit F

full_name: CategoryTheory.Limits.Types.Limit.π_mk
code: @[simp]
theorem Limit.π_mk (x : ∀ j, F.obj j) (h : ∀ (j j') (f : j ⟶ j'), F.map f (x j) = x j') (j) :
    limit.π F j (Limit.mk F x h) = x j 
goal: CategoryTheory.Limits.limit.π F j (CategoryTheory.Limits.Types.Limit.mk F x h) = x j

full_name: CategoryTheory.Limits.Types.limit_ext
code: @[ext]
theorem limit_ext (x y : limit F) (w : ∀ j, limit.π F j x = limit.π F j y) : x = y 
goal: x = y

full_name: CategoryTheory.Limits.Types.limit_ext'
code: @[ext]
theorem limit_ext' (F : J ⥤ Type v) (x y : limit F) (w : ∀ j, limit.π F j x = limit.π F j y) :
    x = y 
goal: x = y

full_name: CategoryTheory.Limits.Types.limit_ext_iff
code: theorem limit_ext_iff (x y : limit F) : x = y ↔ ∀ j, limit.π F j x = limit.π F j y 
goal: x = y ↔ ∀ (j : J), CategoryTheory.Limits.limit.π F j x = CategoryTheory.Limits.limit.π F j y

full_name: CategoryTheory.Limits.Types.limit_ext_iff'
code: theorem limit_ext_iff' (F : J ⥤ Type v) (x y : limit F) :
    x = y ↔ ∀ j, limit.π F j x = limit.π F j y 
goal: x = y ↔ ∀ (j : J), CategoryTheory.Limits.limit.π F j x = CategoryTheory.Limits.limit.π F j y

full_name: CategoryTheory.Limits.Types.Limit.w_apply
code: theorem Limit.w_apply {j j' : J} {x : limit F} (f : j ⟶ j') :
    F.map f (limit.π F j x) = limit.π F j' x 
goal: F.map f (CategoryTheory.Limits.limit.π F j x) = CategoryTheory.Limits.limit.π F j' x

full_name: CategoryTheory.Limits.Types.Limit.lift_π_apply
code: theorem Limit.lift_π_apply (s : Cone F) (j : J) (x : s.pt) :
    limit.π F j (limit.lift F s x) = s.π.app j x 
goal: CategoryTheory.Limits.limit.π F j (CategoryTheory.Limits.limit.lift F s x) = s.π.app j x

full_name: CategoryTheory.Limits.Types.Limit.map_π_apply
code: theorem Limit.map_π_apply {F G : J ⥤ Type u} [HasLimit F] [HasLimit G] (α : F ⟶ G) (j : J)
    (x : limit F) : limit.π G j (limMap α x) = α.app j (limit.π F j x) 
goal: CategoryTheory.Limits.limit.π G j (CategoryTheory.Limits.limMap α x) = α.app j (CategoryTheory.Limits.limit.π F j x)

full_name: CategoryTheory.Limits.Types.Limit.w_apply'
code: @[simp]
theorem Limit.w_apply' {F : J ⥤ Type v} {j j' : J} {x : limit F} (f : j ⟶ j') :
    F.map f (limit.π F j x) = limit.π F j' x 
goal: F.map f (CategoryTheory.Limits.limit.π F j x) = CategoryTheory.Limits.limit.π F j' x

full_name: CategoryTheory.Limits.Types.Limit.lift_π_apply'
code: @[simp]
theorem Limit.lift_π_apply' (F : J ⥤ Type v) (s : Cone F) (j : J) (x : s.pt) :
    limit.π F j (limit.lift F s x) = s.π.app j x 
goal: CategoryTheory.Limits.limit.π F j (CategoryTheory.Limits.limit.lift F s x) = s.π.app j x

full_name: CategoryTheory.Limits.Types.Limit.map_π_apply'
code: @[simp]
theorem Limit.map_π_apply' {F G : J ⥤ Type v} (α : F ⟶ G) (j : J) (x : limit F) :
    limit.π G j (limMap α x) = α.app j (limit.π F j x) 
goal: CategoryTheory.Limits.limit.π G j (CategoryTheory.Limits.limMap α x) = α.app j (CategoryTheory.Limits.limit.π F j x)

full_name: CategoryTheory.Limits.Types.Quot.Rel
code: /--
The relation defining the quotient type which implements the colimit of a functor `F : J ⥤ Type u`.
See `CategoryTheory.Limits.Types.Quot`.
-/
def Quot.Rel (F : J ⥤ Type u) : (Σ j, F.obj j) → (Σ j, F.obj j) → Prop 
goal: (j : J) × F.obj j → (j : J) × F.obj j → Prop

full_name: CategoryTheory.Limits.Types.Quot
code: /-- A quotient type implementing the colimit of a functor `F : J ⥤ Type u`,
as pairs `⟨j, x⟩` where `x : F.obj j`, modulo the equivalence relation generated by
`⟨j, x⟩ ~ ⟨j', x'⟩` whenever there is a morphism `f : j ⟶ j'` so `F.map f x = x'`.
-/
def Quot (F : J ⥤ Type u) : Type (max v u) 
goal: Type (max v u)

full_name: CategoryTheory.Limits.Types.instSmallQuot
code: instance [Small.{u} J] (F : J ⥤ Type u) : Small.{u} (Quot F) 
goal: Small.{u, max u v} (CategoryTheory.Limits.Types.Quot F)

full_name: CategoryTheory.Limits.Types.Quot.ι
code: /-- Inclusion into the quotient type implementing the colimit. -/
def Quot.ι (F : J ⥤ Type u) (j : J) : F.obj j → Quot F 
goal: F.obj j → CategoryTheory.Limits.Types.Quot F

full_name: CategoryTheory.Limits.Types.Quot.jointly_surjective
code: lemma Quot.jointly_surjective {F : J ⥤ Type u} (x : Quot F) : ∃ j y, x = Quot.ι F j y 
goal: ∃ j y, x = CategoryTheory.Limits.Types.Quot.ι F j y

full_name: CategoryTheory.Limits.Types.Quot.desc
code: /-- (implementation detail) Part of the universal property of the colimit cocone, but without
    assuming that `Quot F` lives in the correct universe. -/
def Quot.desc : Quot F → c.pt 
goal: CategoryTheory.Limits.Types.Quot F → c.pt

full_name: CategoryTheory.Limits.Types.Quot.ι_desc
code: @[simp]
lemma Quot.ι_desc (j : J) (x : F.obj j) : Quot.desc c (Quot.ι F j x) = c.ι.app j x 
goal: CategoryTheory.Limits.Types.Quot.desc c (CategoryTheory.Limits.Types.Quot.ι F j x) = c.ι.app j x

full_name: CategoryTheory.Limits.Types.Quot.map_ι
code: @[simp]
lemma Quot.map_ι {j j' : J} {f : j ⟶ j'} (x : F.obj j) : Quot.ι F j' (F.map f x) = Quot.ι F j x 
goal: CategoryTheory.Limits.Types.Quot.ι F j' (F.map f x) = CategoryTheory.Limits.Types.Quot.ι F j x

full_name: CategoryTheory.Limits.Types.toCocone_pt
code: /-- (implementation detail) A function `Quot F → α` induces a cocone on `F` as long as the universes
    work out. -/
@[simps]
def toCocone {α : Type u} (f : Quot F → α) : Cocone F 
goal: (CategoryTheory.Limits.Types.toCocone f).pt = α

full_name: CategoryTheory.Limits.Types.toCocone
code: /-- (implementation detail) A function `Quot F → α` induces a cocone on `F` as long as the universes
    work out. -/
@[simps]
def toCocone {α : Type u} (f : Quot F → α) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.Types.toCocone_ι_app
code: /-- (implementation detail) A function `Quot F → α` induces a cocone on `F` as long as the universes
    work out. -/
@[simps]
def toCocone {α : Type u} (f : Quot F → α) : Cocone F 
goal: ∀ (a : F.obj j), (CategoryTheory.Limits.Types.toCocone f).ι.app j a = (f ∘ CategoryTheory.Limits.Types.Quot.ι F j) a

full_name: CategoryTheory.Limits.Types.Quot.desc_toCocone_desc
code: lemma Quot.desc_toCocone_desc {α : Type u} (f : Quot F → α) (hc : IsColimit c) (x : Quot F) :
    hc.desc (toCocone f) (Quot.desc c x) = f x 
goal: hc.desc (CategoryTheory.Limits.Types.toCocone f) (CategoryTheory.Limits.Types.Quot.desc c x) = f x

full_name: CategoryTheory.Limits.Types.isColimit_iff_bijective_desc
code: theorem isColimit_iff_bijective_desc : Nonempty (IsColimit c) ↔ (Quot.desc c).Bijective 
goal: Nonempty (CategoryTheory.Limits.IsColimit c) ↔ Function.Bijective (CategoryTheory.Limits.Types.Quot.desc c)

full_name: CategoryTheory.Limits.Types.colimitCocone_pt
code: /-- (internal implementation) the colimit cocone of a functor,
implemented as a quotient of a sigma type
-/
@[simps]
noncomputable def colimitCocone (F : J ⥤ Type u) [Small.{u} (Quot F)] : Cocone F 
goal: (CategoryTheory.Limits.Types.colimitCocone F).pt = Shrink.{u, max u v} (CategoryTheory.Limits.Types.Quot F)

full_name: CategoryTheory.Limits.Types.colimitCocone_ι_app
code: /-- (internal implementation) the colimit cocone of a functor,
implemented as a quotient of a sigma type
-/
@[simps]
noncomputable def colimitCocone (F : J ⥤ Type u) [Small.{u} (Quot F)] : Cocone F 
goal: (CategoryTheory.Limits.Types.colimitCocone F).ι.app j x =
  (equivShrink (CategoryTheory.Limits.Types.Quot F)) (Quot.mk (CategoryTheory.Limits.Types.Quot.Rel F) ⟨j, x⟩)

full_name: CategoryTheory.Limits.Types.colimitCocone
code: /-- (internal implementation) the colimit cocone of a functor,
implemented as a quotient of a sigma type
-/
@[simps]
noncomputable def colimitCocone (F : J ⥤ Type u) [Small.{u} (Quot F)] : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.Types.Quot.desc_colimitCocone
code: @[simp]
theorem Quot.desc_colimitCocone (F : J ⥤ Type u) [Small.{u} (Quot F)] :
    Quot.desc (colimitCocone F) = equivShrink.{u} (Quot F) 
goal: CategoryTheory.Limits.Types.Quot.desc (CategoryTheory.Limits.Types.colimitCocone F) =
  ⇑(equivShrink (CategoryTheory.Limits.Types.Quot F))

full_name: CategoryTheory.Limits.Types.colimitCoconeIsColimit
code: /-- (internal implementation) the fact that the proposed colimit cocone is the colimit -/
noncomputable def colimitCoconeIsColimit (F : J ⥤ Type u) [Small.{u} (Quot F)] :
    IsColimit (colimitCocone F) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Types.colimitCocone F)

full_name: CategoryTheory.Limits.Types.hasColimit_iff_small_quot
code: theorem hasColimit_iff_small_quot (F : J ⥤ Type u) : HasColimit F ↔ Small.{u} (Quot F) 
goal: CategoryTheory.Limits.HasColimit F ↔ Small.{u, max u v} (CategoryTheory.Limits.Types.Quot F)

full_name: CategoryTheory.Limits.Types.small_quot_of_hasColimit
code: theorem small_quot_of_hasColimit (F : J ⥤ Type u) [HasColimit F] : Small.{u} (Quot F) 
goal: Small.{u, max u v} (CategoryTheory.Limits.Types.Quot F)

full_name: CategoryTheory.Limits.Types.hasColimit
code: instance hasColimit [Small.{u} J] (F : J ⥤ Type u) : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.Types.hasColimitsOfShape
code: instance hasColimitsOfShape [Small.{u} J] : HasColimitsOfShape J (Type u) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (Type u)

full_name: CategoryTheory.Limits.Types.hasColimitsOfSize
code: /-- The category of types has all colimits.

See <https://stacks.math.columbia.edu/tag/002U>.
-/
instance (priority := 1300) hasColimitsOfSize [UnivLE.{v, u}] :
    HasColimitsOfSize.{w, v} (Type u) 
goal: CategoryTheory.Limits.HasColimitsOfSize.{w, v, u, u + 1} (Type u)

full_name: CategoryTheory.Limits.Types.TypeMax.colimitCocone
code: /-- (internal implementation) the colimit cocone of a functor,
implemented as a quotient of a sigma type
-/
@[simps]
def colimitCocone (F : J ⥤ TypeMax.{v, u}) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.Types.TypeMax.colimitCocone_pt
code: /-- (internal implementation) the colimit cocone of a functor,
implemented as a quotient of a sigma type
-/
@[simps]
def colimitCocone (F : J ⥤ TypeMax.{v, u}) : Cocone F 
goal: (CategoryTheory.Limits.Types.TypeMax.colimitCocone F).pt = CategoryTheory.Limits.Types.Quot F

full_name: CategoryTheory.Limits.Types.TypeMax.colimitCocone_ι_app
code: /-- (internal implementation) the colimit cocone of a functor,
implemented as a quotient of a sigma type
-/
@[simps]
def colimitCocone (F : J ⥤ TypeMax.{v, u}) : Cocone F 
goal: (CategoryTheory.Limits.Types.TypeMax.colimitCocone F).ι.app j x =
  Quot.mk (CategoryTheory.Limits.Types.Quot.Rel F) ⟨j, x⟩

full_name: CategoryTheory.Limits.Types.TypeMax.colimitCoconeIsColimit
code: /-- (internal implementation) the fact that the proposed colimit cocone is the colimit -/
def colimitCoconeIsColimit (F : J ⥤ TypeMax.{v, u}) : IsColimit (colimitCocone F) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Types.TypeMax.colimitCocone F)

full_name: CategoryTheory.Limits.Types.colimitEquivQuot
code: /-- The equivalence between the abstract colimit of `F` in `Type u`
and the "concrete" definition as a quotient.
-/
noncomputable def colimitEquivQuot : colimit F ≃ Quot F 
goal: CategoryTheory.Limits.colimit F ≃ CategoryTheory.Limits.Types.Quot F

full_name: CategoryTheory.Limits.Types.colimitEquivQuot_symm_apply
code: @[simp]
theorem colimitEquivQuot_symm_apply (j : J) (x : F.obj j) :
    (colimitEquivQuot F).symm (Quot.mk _ ⟨j, x⟩) = colimit.ι F j x 
goal: (CategoryTheory.Limits.Types.colimitEquivQuot F).symm (Quot.mk (CategoryTheory.Limits.Types.Quot.Rel F) ⟨j, x⟩) =
  CategoryTheory.Limits.colimit.ι F j x

full_name: CategoryTheory.Limits.Types.colimitEquivQuot_apply
code: @[simp]
theorem colimitEquivQuot_apply (j : J) (x : F.obj j) :
    (colimitEquivQuot F) (colimit.ι F j x) = Quot.mk _ ⟨j, x⟩ 
goal: (CategoryTheory.Limits.Types.colimitEquivQuot F) (CategoryTheory.Limits.colimit.ι F j x) =
  Quot.mk (CategoryTheory.Limits.Types.Quot.Rel F) ⟨j, x⟩

full_name: CategoryTheory.Limits.Types.Colimit.w_apply
code: theorem Colimit.w_apply {j j' : J} {x : F.obj j} (f : j ⟶ j') :
    colimit.ι F j' (F.map f x) = colimit.ι F j x 
goal: CategoryTheory.Limits.colimit.ι F j' (F.map f x) = CategoryTheory.Limits.colimit.ι F j x

full_name: CategoryTheory.Limits.Types.Colimit.ι_desc_apply
code: theorem Colimit.ι_desc_apply (s : Cocone F) (j : J) (x : F.obj j) :
    colimit.desc F s (colimit.ι F j x) = s.ι.app j x 
goal: CategoryTheory.Limits.colimit.desc F s (CategoryTheory.Limits.colimit.ι F j x) = s.ι.app j x

full_name: CategoryTheory.Limits.Types.Colimit.ι_map_apply
code: theorem Colimit.ι_map_apply {F G : J ⥤ Type u} [HasColimitsOfShape J (Type u)] (α : F ⟶ G) (j : J)
    (x : F.obj j) : colim.map α (colimit.ι F j x) = colimit.ι G j (α.app j x) 
goal: CategoryTheory.Limits.colim.map α (CategoryTheory.Limits.colimit.ι F j x) =
  CategoryTheory.Limits.colimit.ι G j (α.app j x)

full_name: CategoryTheory.Limits.Types.Colimit.w_apply'
code: @[simp]
theorem Colimit.w_apply' {F : J ⥤ Type v} {j j' : J} {x : F.obj j} (f : j ⟶ j') :
    colimit.ι F j' (F.map f x) = colimit.ι F j x 
goal: CategoryTheory.Limits.colimit.ι F j' (F.map f x) = CategoryTheory.Limits.colimit.ι F j x

full_name: CategoryTheory.Limits.Types.Colimit.ι_desc_apply'
code: @[simp]
theorem Colimit.ι_desc_apply' (F : J ⥤ Type v) (s : Cocone F) (j : J) (x : F.obj j) :
    colimit.desc F s (colimit.ι F j x) = s.ι.app j x 
goal: CategoryTheory.Limits.colimit.desc F s (CategoryTheory.Limits.colimit.ι F j x) = s.ι.app j x

full_name: CategoryTheory.Limits.Types.Colimit.ι_map_apply'
code: @[simp]
theorem Colimit.ι_map_apply' {F G : J ⥤ Type v} (α : F ⟶ G) (j : J) (x) :
    colim.map α (colimit.ι F j x) = colimit.ι G j (α.app j x) 
goal: CategoryTheory.Limits.colim.map α (CategoryTheory.Limits.colimit.ι F j x) =
  CategoryTheory.Limits.colimit.ι G j (α.app j x)

full_name: CategoryTheory.Limits.Types.colimit_sound
code: theorem colimit_sound {j j' : J} {x : F.obj j} {x' : F.obj j'} (f : j ⟶ j')
    (w : F.map f x = x') : colimit.ι F j x = colimit.ι F j' x' 
goal: CategoryTheory.Limits.colimit.ι F j x = CategoryTheory.Limits.colimit.ι F j' x'

full_name: CategoryTheory.Limits.Types.colimit_sound'
code: theorem colimit_sound' {j j' : J} {x : F.obj j} {x' : F.obj j'} {j'' : J}
    (f : j ⟶ j'') (f' : j' ⟶ j'') (w : F.map f x = F.map f' x') :
    colimit.ι F j x = colimit.ι F j' x' 
goal: CategoryTheory.Limits.colimit.ι F j x = CategoryTheory.Limits.colimit.ι F j' x'

full_name: CategoryTheory.Limits.Types.colimit_eq
code: theorem colimit_eq {j j' : J} {x : F.obj j} {x' : F.obj j'}
    (w : colimit.ι F j x = colimit.ι F j' x') :
      EqvGen (Quot.Rel F) ⟨j, x⟩ ⟨j', x'⟩ 
goal: EqvGen (CategoryTheory.Limits.Types.Quot.Rel F) ⟨j, x⟩ ⟨j', x'⟩

full_name: CategoryTheory.Limits.Types.jointly_surjective_of_isColimit
code: theorem jointly_surjective_of_isColimit {F : J ⥤ Type u} {t : Cocone F} (h : IsColimit t)
    (x : t.pt) : ∃ j y, t.ι.app j y = x 
goal: ∃ j y, t.ι.app j y = x

full_name: CategoryTheory.Limits.Types.jointly_surjective
code: theorem jointly_surjective (F : J ⥤ Type u) {t : Cocone F} (h : IsColimit t) (x : t.pt) :
    ∃ j y, t.ι.app j y = x 
goal: ∃ j y, t.ι.app j y = x

full_name: CategoryTheory.Limits.Types.jointly_surjective'
code: /-- A variant of `jointly_surjective` for `x : colimit F`. -/
theorem jointly_surjective' (x : colimit F) :
    ∃ j y, colimit.ι F j y = x 
goal: ∃ j y, CategoryTheory.Limits.colimit.ι F j y = x

full_name: CategoryTheory.Limits.Types.nonempty_of_nonempty_colimit
code: /-- If a colimit is nonempty, also its index category is nonempty. -/
theorem nonempty_of_nonempty_colimit {F : J ⥤ Type u} [HasColimit F] :
    Nonempty (colimit F) → Nonempty J 
goal: Nonempty (CategoryTheory.Limits.colimit F) → Nonempty J

full_name: CategoryTheory.Limits.Types.Image
code: /-- the image of a morphism in Type is just `Set.range f` -/
def Image : Type u 
goal: Type u

full_name: CategoryTheory.Limits.Types.instInhabitedImage
code: instance [Inhabited α] : Inhabited (Image f) 
goal: Inhabited (CategoryTheory.Limits.Types.Image f)

full_name: CategoryTheory.Limits.Types.Image.ι
code: /-- the inclusion of `Image f` into the target -/
def Image.ι : Image f ⟶ β 
goal: CategoryTheory.Limits.Types.Image f ⟶ β

full_name: CategoryTheory.Limits.Types.instMonoImageι
code: instance : Mono (Image.ι f) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.Types.Image.ι f)

full_name: CategoryTheory.Limits.Types.Image.lift
code: /-- the universal property for the image factorisation -/
noncomputable def Image.lift (F' : MonoFactorisation f) : Image f ⟶ F'.I 
goal: CategoryTheory.Limits.Types.Image f ⟶ F'.I

full_name: CategoryTheory.Limits.Types.Image.lift_fac
code: theorem Image.lift_fac (F' : MonoFactorisation f) : Image.lift F' ≫ F'.m = Image.ι f 
goal: CategoryTheory.Limits.Types.Image.lift F' ≫ F'.m = CategoryTheory.Limits.Types.Image.ι f

full_name: CategoryTheory.Limits.Types.monoFactorisation
code: /-- the factorisation of any morphism in Type through a mono. -/
def monoFactorisation : MonoFactorisation f 
goal: CategoryTheory.Limits.MonoFactorisation f

full_name: CategoryTheory.Limits.Types.isImage
code: /-- the factorisation through a mono has the universal property of the image. -/
noncomputable def isImage : IsImage (monoFactorisation f) 
goal: CategoryTheory.Limits.IsImage (CategoryTheory.Limits.Types.monoFactorisation f)

full_name: CategoryTheory.Limits.Types.instHasImage
code: instance : HasImage f 
goal: CategoryTheory.Limits.HasImage f

full_name: CategoryTheory.Limits.Types.instHasImagesType
code: instance : HasImages (Type u) 
goal: CategoryTheory.Limits.HasImages (Type u)

full_name: CategoryTheory.Limits.Types.instHasImageMapsType
code: instance : HasImageMaps (Type u) 
goal: CategoryTheory.Limits.HasImageMaps (Type u)

full_name: _private.Mathlib.CategoryTheory.Limits.Types.0.CategoryTheory.Limits.Types.limitOfSurjectionsSurjective.preimage
code: private noncomputable def limitOfSurjectionsSurjective.preimage
    (a : F.obj ⟨0⟩) : (n : ℕ) → F.obj ⟨n⟩
    
goal: F.obj (Opposite.op n)

full_name: CategoryTheory.Limits.Types.surjective_π_app_zero_of_surjective_map_aux
code: /-- Auxiliary lemma. Use `limit_of_surjections_surjective` instead. -/
lemma surjective_π_app_zero_of_surjective_map_aux :
    Function.Surjective ((limitCone F).π.app ⟨0⟩) 
goal: Function.Surjective ((CategoryTheory.Limits.Types.limitCone F).π.app (Opposite.op 0))

full_name: CategoryTheory.Limits.Types.surjective_π_app_zero_of_surjective_map
code: /--
Given surjections `⋯ ⟶ Xₙ₊₁ ⟶ Xₙ ⟶ ⋯ ⟶ X₀`, the projection map `lim Xₙ ⟶ X₀` is surjective.
-/
lemma surjective_π_app_zero_of_surjective_map
    (hc : IsLimit c)
    (hF : ∀ n, Function.Surjective (F.map (homOfLE (Nat.le_succ n)).op)) :
    Function.Surjective (c.π.app ⟨0⟩) 
goal: Function.Surjective (c.π.app (Opposite.op 0))

full_name: CategoryTheory.Limits.compCoyonedaSectionsEquiv_apply_app
code: /-- Sections of `F ⋙ coyoneda.obj (op X)` identify to natural
transformations `(const J).obj X ⟶ F`. -/
@[simps]
def compCoyonedaSectionsEquiv (F : J ⥤ C) (X : C) :
    (F ⋙ coyoneda.obj (op X)).sections ≃ ((const J).obj X ⟶ F) 
goal: ((CategoryTheory.Limits.compCoyonedaSectionsEquiv F X) s).app j = ↑s j

full_name: CategoryTheory.Limits.compCoyonedaSectionsEquiv
code: /-- Sections of `F ⋙ coyoneda.obj (op X)` identify to natural
transformations `(const J).obj X ⟶ F`. -/
@[simps]
def compCoyonedaSectionsEquiv (F : J ⥤ C) (X : C) :
    (F ⋙ coyoneda.obj (op X)).sections ≃ ((const J).obj X ⟶ F) 
goal: ↑(F ⋙ CategoryTheory.coyoneda.obj (Opposite.op X)).sections ≃ ((CategoryTheory.Functor.const J).obj X ⟶ F)

full_name: CategoryTheory.Limits.compCoyonedaSectionsEquiv_symm_apply_coe
code: /-- Sections of `F ⋙ coyoneda.obj (op X)` identify to natural
transformations `(const J).obj X ⟶ F`. -/
@[simps]
def compCoyonedaSectionsEquiv (F : J ⥤ C) (X : C) :
    (F ⋙ coyoneda.obj (op X)).sections ≃ ((const J).obj X ⟶ F) 
goal: ∀ (X_1 : J), ↑((CategoryTheory.Limits.compCoyonedaSectionsEquiv F X).symm τ) X_1 = τ.app X_1

full_name: CategoryTheory.Limits.opCompYonedaSectionsEquiv
code: /-- Sections of `F.op ⋙ yoneda.obj X` identify to natural
transformations `F ⟶ (const J).obj X`. -/
@[simps]
def opCompYonedaSectionsEquiv (F : J ⥤ C) (X : C) :
    (F.op ⋙ yoneda.obj X).sections ≃ (F ⟶ (const J).obj X) 
goal: ↑(F.op ⋙ CategoryTheory.yoneda.obj X).sections ≃ (F ⟶ (CategoryTheory.Functor.const J).obj X)

full_name: CategoryTheory.Limits.opCompYonedaSectionsEquiv_symm_apply_coe
code: /-- Sections of `F.op ⋙ yoneda.obj X` identify to natural
transformations `F ⟶ (const J).obj X`. -/
@[simps]
def opCompYonedaSectionsEquiv (F : J ⥤ C) (X : C) :
    (F.op ⋙ yoneda.obj X).sections ≃ (F ⟶ (const J).obj X) 
goal: ↑((CategoryTheory.Limits.opCompYonedaSectionsEquiv F X).symm τ) j = τ.app (Opposite.unop j)

full_name: CategoryTheory.Limits.opCompYonedaSectionsEquiv_apply_app
code: /-- Sections of `F.op ⋙ yoneda.obj X` identify to natural
transformations `F ⟶ (const J).obj X`. -/
@[simps]
def opCompYonedaSectionsEquiv (F : J ⥤ C) (X : C) :
    (F.op ⋙ yoneda.obj X).sections ≃ (F ⟶ (const J).obj X) 
goal: ((CategoryTheory.Limits.opCompYonedaSectionsEquiv F X) s).app j = ↑s (Opposite.op j)

full_name: CategoryTheory.Limits.compYonedaSectionsEquiv_apply_app
code: /-- Sections of `F ⋙ yoneda.obj X` identify to natural
transformations `(const J).obj X ⟶ F`. -/
@[simps]
def compYonedaSectionsEquiv (F : J ⥤ Cᵒᵖ) (X : C) :
    (F ⋙ yoneda.obj X).sections ≃ ((const J).obj (op X) ⟶ F) 
goal: ((CategoryTheory.Limits.compYonedaSectionsEquiv F X) s).app j = Quiver.Hom.op (↑s j)

full_name: CategoryTheory.Limits.compYonedaSectionsEquiv
code: /-- Sections of `F ⋙ yoneda.obj X` identify to natural
transformations `(const J).obj X ⟶ F`. -/
@[simps]
def compYonedaSectionsEquiv (F : J ⥤ Cᵒᵖ) (X : C) :
    (F ⋙ yoneda.obj X).sections ≃ ((const J).obj (op X) ⟶ F) 
goal: ↑(F ⋙ CategoryTheory.yoneda.obj X).sections ≃ ((CategoryTheory.Functor.const J).obj (Opposite.op X) ⟶ F)

full_name: CategoryTheory.Limits.compYonedaSectionsEquiv_symm_apply_coe
code: /-- Sections of `F ⋙ yoneda.obj X` identify to natural
transformations `(const J).obj X ⟶ F`. -/
@[simps]
def compYonedaSectionsEquiv (F : J ⥤ Cᵒᵖ) (X : C) :
    (F ⋙ yoneda.obj X).sections ≃ ((const J).obj (op X) ⟶ F) 
goal: ↑((CategoryTheory.Limits.compYonedaSectionsEquiv F X).symm τ) j = (τ.app j).unop

full_name: CategoryTheory.Limits.limitCompCoyonedaIsoCone_hom_app
code: /-- A cone on `F` with cone point `X` is the same as an element of `lim Hom(X, F·)`. -/
@[simps!]
noncomputable def limitCompCoyonedaIsoCone (F : J ⥤ C) (X : C) :
    limit (F ⋙ coyoneda.obj (op X)) ≅ ((const J).obj X ⟶ F) 
goal: ∀ (a : CategoryTheory.Limits.limit (F ⋙ CategoryTheory.coyoneda.obj (Opposite.op X))) (j : J),
  ((CategoryTheory.Limits.limitCompCoyonedaIsoCone F X).hom a).app j =
    CategoryTheory.Limits.limit.π (F ⋙ CategoryTheory.coyoneda.obj (Opposite.op X)) j a

full_name: CategoryTheory.Limits.limitCompCoyonedaIsoCone_inv
code: /-- A cone on `F` with cone point `X` is the same as an element of `lim Hom(X, F·)`. -/
@[simps!]
noncomputable def limitCompCoyonedaIsoCone (F : J ⥤ C) (X : C) :
    limit (F ⋙ coyoneda.obj (op X)) ≅ ((const J).obj X ⟶ F) 
goal: ∀ (a : (CategoryTheory.Functor.const J).obj X ⟶ F),
  (CategoryTheory.Limits.limitCompCoyonedaIsoCone F X).inv a =
    (CategoryTheory.Limits.Types.limitEquivSections (F ⋙ CategoryTheory.coyoneda.obj (Opposite.op X))).symm
      ((CategoryTheory.Limits.compCoyonedaSectionsEquiv F X).symm a)

full_name: CategoryTheory.Limits.limitCompCoyonedaIsoCone
code: /-- A cone on `F` with cone point `X` is the same as an element of `lim Hom(X, F·)`. -/
@[simps!]
noncomputable def limitCompCoyonedaIsoCone (F : J ⥤ C) (X : C) :
    limit (F ⋙ coyoneda.obj (op X)) ≅ ((const J).obj X ⟶ F) 
goal: CategoryTheory.Limits.limit (F ⋙ CategoryTheory.coyoneda.obj (Opposite.op X)) ≅
  (CategoryTheory.Functor.const J).obj X ⟶ F

full_name: CategoryTheory.Limits.coyonedaCompLimIsoCones_inv_app
code: /-- A cone on `F` with cone point `X` is the same as an element of `lim Hom(X, F·)`,
    naturally in `X`. -/
@[simps!]
noncomputable def coyonedaCompLimIsoCones (F : J ⥤ C) :
    coyoneda ⋙ (whiskeringLeft _ _ _).obj F ⋙ lim ≅ F.cones 
goal: ∀ (a : F.cones.obj X),
  (CategoryTheory.Limits.coyonedaCompLimIsoCones F).inv.app X a =
    (CategoryTheory.Limits.Types.limitEquivSections (F ⋙ CategoryTheory.coyoneda.obj X)).symm
      ((CategoryTheory.Limits.compCoyonedaSectionsEquiv F (Opposite.unop X)).symm a)

full_name: CategoryTheory.Limits.coyonedaCompLimIsoCones
code: /-- A cone on `F` with cone point `X` is the same as an element of `lim Hom(X, F·)`,
    naturally in `X`. -/
@[simps!]
noncomputable def coyonedaCompLimIsoCones (F : J ⥤ C) :
    coyoneda ⋙ (whiskeringLeft _ _ _).obj F ⋙ lim ≅ F.cones 
goal: CategoryTheory.coyoneda ⋙ (CategoryTheory.whiskeringLeft J C (Type v)).obj F ⋙ CategoryTheory.Limits.lim ≅ F.cones

full_name: CategoryTheory.Limits.coyonedaCompLimIsoCones_hom_app_app
code: /-- A cone on `F` with cone point `X` is the same as an element of `lim Hom(X, F·)`,
    naturally in `X`. -/
@[simps!]
noncomputable def coyonedaCompLimIsoCones (F : J ⥤ C) :
    coyoneda ⋙ (whiskeringLeft _ _ _).obj F ⋙ lim ≅ F.cones 
goal: ∀ (a : (CategoryTheory.coyoneda ⋙ (CategoryTheory.whiskeringLeft J C (Type v)).obj F ⋙ CategoryTheory.Limits.lim).obj X)
  (j : J),
  ((CategoryTheory.Limits.coyonedaCompLimIsoCones F).hom.app X a).app j =
    CategoryTheory.Limits.limit.π (F ⋙ CategoryTheory.coyoneda.obj X) j a

full_name: CategoryTheory.Limits.whiskeringLimYonedaIsoCones
code: /-- A cone on `F` with cone point `X` is the same as an element of `lim Hom(X, F·)`,
    naturally in `F` and `X`. -/
@[simps!]
noncomputable def whiskeringLimYonedaIsoCones : whiskeringLeft _ _ _ ⋙
    (whiskeringRight _ _ _).obj lim ⋙ (whiskeringLeft _ _ _).obj coyoneda ≅ cones J C 
goal: CategoryTheory.whiskeringLeft J C (Type v) ⋙
    (CategoryTheory.whiskeringRight (C ⥤ Type v) (J ⥤ Type v) (Type v)).obj CategoryTheory.Limits.lim ⋙
      (CategoryTheory.whiskeringLeft Cᵒᵖ (C ⥤ Type v) (Type v)).obj CategoryTheory.coyoneda ≅
  CategoryTheory.cones J C

full_name: CategoryTheory.Limits.whiskeringLimYonedaIsoCones_inv_app_app
code: /-- A cone on `F` with cone point `X` is the same as an element of `lim Hom(X, F·)`,
    naturally in `F` and `X`. -/
@[simps!]
noncomputable def whiskeringLimYonedaIsoCones : whiskeringLeft _ _ _ ⋙
    (whiskeringRight _ _ _).obj lim ⋙ (whiskeringLeft _ _ _).obj coyoneda ≅ cones J C 
goal: ∀ (X_1 : Cᵒᵖ) (a : X.cones.obj X_1),
  ((CategoryTheory.Limits.whiskeringLimYonedaIsoCones J C).inv.app X).app X_1 a =
    (CategoryTheory.Limits.Types.limitEquivSections (X ⋙ CategoryTheory.coyoneda.obj X_1)).symm
      ((CategoryTheory.Limits.compCoyonedaSectionsEquiv X (Opposite.unop X_1)).symm a)

full_name: CategoryTheory.Limits.whiskeringLimYonedaIsoCones_hom_app_app_app
code: /-- A cone on `F` with cone point `X` is the same as an element of `lim Hom(X, F·)`,
    naturally in `F` and `X`. -/
@[simps!]
noncomputable def whiskeringLimYonedaIsoCones : whiskeringLeft _ _ _ ⋙
    (whiskeringRight _ _ _).obj lim ⋙ (whiskeringLeft _ _ _).obj coyoneda ≅ cones J C 
goal: ∀ (X_1 : Cᵒᵖ)
  (a :
    (CategoryTheory.coyoneda ⋙ (CategoryTheory.whiskeringLeft J C (Type v)).obj X ⋙ CategoryTheory.Limits.lim).obj X_1)
  (j : J),
  (((CategoryTheory.Limits.whiskeringLimYonedaIsoCones J C).hom.app X).app X_1 a).app j =
    CategoryTheory.Limits.limit.π (X ⋙ CategoryTheory.coyoneda.obj X_1) j a

full_name: CategoryTheory.Limits.limitCompYonedaIsoCocone_inv
code: /-- A cocone on `F` with cocone point `X` is the same as an element of `lim Hom(F·, X)`. -/
@[simps!]
noncomputable def limitCompYonedaIsoCocone (F : J ⥤ C) (X : C) :
    limit (F.op ⋙ yoneda.obj X) ≅ (F ⟶ (const J).obj X) 
goal: ∀ (a : F ⟶ (CategoryTheory.Functor.const J).obj X),
  (CategoryTheory.Limits.limitCompYonedaIsoCocone F X).inv a =
    (CategoryTheory.Limits.Types.limitEquivSections (F.op ⋙ CategoryTheory.yoneda.obj X)).symm
      ((CategoryTheory.Limits.opCompYonedaSectionsEquiv F X).symm a)

full_name: CategoryTheory.Limits.limitCompYonedaIsoCocone
code: /-- A cocone on `F` with cocone point `X` is the same as an element of `lim Hom(F·, X)`. -/
@[simps!]
noncomputable def limitCompYonedaIsoCocone (F : J ⥤ C) (X : C) :
    limit (F.op ⋙ yoneda.obj X) ≅ (F ⟶ (const J).obj X) 
goal: CategoryTheory.Limits.limit (F.op ⋙ CategoryTheory.yoneda.obj X) ≅ F ⟶ (CategoryTheory.Functor.const J).obj X

full_name: CategoryTheory.Limits.limitCompYonedaIsoCocone_hom_app
code: /-- A cocone on `F` with cocone point `X` is the same as an element of `lim Hom(F·, X)`. -/
@[simps!]
noncomputable def limitCompYonedaIsoCocone (F : J ⥤ C) (X : C) :
    limit (F.op ⋙ yoneda.obj X) ≅ (F ⟶ (const J).obj X) 
goal: ∀ (a : CategoryTheory.Limits.limit (F.op ⋙ CategoryTheory.yoneda.obj X)) (j : J),
  ((CategoryTheory.Limits.limitCompYonedaIsoCocone F X).hom a).app j =
    CategoryTheory.Limits.limit.π (F.op ⋙ CategoryTheory.yoneda.obj X) (Opposite.op j) a

full_name: CategoryTheory.Limits.yonedaCompLimIsoCocones_inv_app
code: /-- A cocone on `F` with cocone point `X` is the same as an element of `lim Hom(F·, X)`,
    naturally in `X`. -/
@[simps!]
noncomputable def yonedaCompLimIsoCocones (F : J ⥤ C) :
    yoneda ⋙ (whiskeringLeft _ _ _).obj F.op ⋙ lim ≅ F.cocones 
goal: ∀ (a : F.cocones.obj X),
  (CategoryTheory.Limits.yonedaCompLimIsoCocones F).inv.app X a =
    (CategoryTheory.Limits.Types.limitEquivSections (F.op ⋙ CategoryTheory.yoneda.obj X)).symm
      ((CategoryTheory.Limits.opCompYonedaSectionsEquiv F X).symm a)

full_name: CategoryTheory.Limits.yonedaCompLimIsoCocones_hom_app_app
code: /-- A cocone on `F` with cocone point `X` is the same as an element of `lim Hom(F·, X)`,
    naturally in `X`. -/
@[simps!]
noncomputable def yonedaCompLimIsoCocones (F : J ⥤ C) :
    yoneda ⋙ (whiskeringLeft _ _ _).obj F.op ⋙ lim ≅ F.cocones 
goal: ∀
  (a :
    (CategoryTheory.yoneda ⋙ (CategoryTheory.whiskeringLeft Jᵒᵖ Cᵒᵖ (Type v)).obj F.op ⋙ CategoryTheory.Limits.lim).obj
      X)
  (j : J),
  ((CategoryTheory.Limits.yonedaCompLimIsoCocones F).hom.app X a).app j =
    CategoryTheory.Limits.limit.π (F.op ⋙ CategoryTheory.yoneda.obj X) (Opposite.op j) a

full_name: CategoryTheory.Limits.yonedaCompLimIsoCocones
code: /-- A cocone on `F` with cocone point `X` is the same as an element of `lim Hom(F·, X)`,
    naturally in `X`. -/
@[simps!]
noncomputable def yonedaCompLimIsoCocones (F : J ⥤ C) :
    yoneda ⋙ (whiskeringLeft _ _ _).obj F.op ⋙ lim ≅ F.cocones 
goal: CategoryTheory.yoneda ⋙ (CategoryTheory.whiskeringLeft Jᵒᵖ Cᵒᵖ (Type v)).obj F.op ⋙ CategoryTheory.Limits.lim ≅
  F.cocones

full_name: CategoryTheory.Limits.opHomCompWhiskeringLimYonedaIsoCocones_hom_app_app_app
code: /-- A cocone on `F` with cocone point `X` is the same as an element of `lim Hom(F·, X)`,
    naturally in `F` and `X`. -/
@[simps!]
noncomputable def opHomCompWhiskeringLimYonedaIsoCocones : opHom _ _ ⋙ whiskeringLeft _ _ _ ⋙
      (whiskeringRight _ _ _).obj lim ⋙ (whiskeringLeft _ _ _).obj yoneda ≅ cocones J C 
goal: ∀ (X_1 : C)
  (a :
    (CategoryTheory.yoneda ⋙
          (CategoryTheory.whiskeringLeft Jᵒᵖ Cᵒᵖ (Type v)).obj (Opposite.unop X).op ⋙ CategoryTheory.Limits.lim).obj
      X_1)
  (j : J),
  (((CategoryTheory.Limits.opHomCompWhiskeringLimYonedaIsoCocones J C).hom.app X).app X_1 a).app j =
    CategoryTheory.Limits.limit.π ((Opposite.unop X).op ⋙ CategoryTheory.yoneda.obj X_1) (Opposite.op j) a

full_name: CategoryTheory.Limits.opHomCompWhiskeringLimYonedaIsoCocones
code: /-- A cocone on `F` with cocone point `X` is the same as an element of `lim Hom(F·, X)`,
    naturally in `F` and `X`. -/
@[simps!]
noncomputable def opHomCompWhiskeringLimYonedaIsoCocones : opHom _ _ ⋙ whiskeringLeft _ _ _ ⋙
      (whiskeringRight _ _ _).obj lim ⋙ (whiskeringLeft _ _ _).obj yoneda ≅ cocones J C 
goal: CategoryTheory.Functor.opHom J C ⋙
    CategoryTheory.whiskeringLeft Jᵒᵖ Cᵒᵖ (Type v) ⋙
      (CategoryTheory.whiskeringRight (Cᵒᵖ ⥤ Type v) (Jᵒᵖ ⥤ Type v) (Type v)).obj CategoryTheory.Limits.lim ⋙
        (CategoryTheory.whiskeringLeft C (Cᵒᵖ ⥤ Type v) (Type v)).obj CategoryTheory.yoneda ≅
  CategoryTheory.cocones J C

full_name: CategoryTheory.Limits.opHomCompWhiskeringLimYonedaIsoCocones_inv_app_app
code: /-- A cocone on `F` with cocone point `X` is the same as an element of `lim Hom(F·, X)`,
    naturally in `F` and `X`. -/
@[simps!]
noncomputable def opHomCompWhiskeringLimYonedaIsoCocones : opHom _ _ ⋙ whiskeringLeft _ _ _ ⋙
      (whiskeringRight _ _ _).obj lim ⋙ (whiskeringLeft _ _ _).obj yoneda ≅ cocones J C 
goal: ∀ (X_1 : C) (a : (Opposite.unop X).cocones.obj X_1),
  ((CategoryTheory.Limits.opHomCompWhiskeringLimYonedaIsoCocones J C).inv.app X).app X_1 a =
    (CategoryTheory.Limits.Types.limitEquivSections ((Opposite.unop X).op ⋙ CategoryTheory.yoneda.obj X_1)).symm
      ((CategoryTheory.Limits.opCompYonedaSectionsEquiv (Opposite.unop X) X_1).symm a)