File: Mathlib/CategoryTheory/Limits/ConeCategory.lean

full_name: CategoryTheory.Limits.Cone.toStructuredArrow_obj
code: /-- Given a cone `c` over `F`, we can interpret the legs of `c` as structured arrows
    `c.pt ⟶ F.obj -`. -/
@[simps]
def Cone.toStructuredArrow {F : J ⥤ C} (c : Cone F) : J ⥤ StructuredArrow c.pt F 
goal: c.toStructuredArrow.obj j = CategoryTheory.StructuredArrow.mk (c.π.app j)

full_name: CategoryTheory.Limits.Cone.toStructuredArrow_map
code: /-- Given a cone `c` over `F`, we can interpret the legs of `c` as structured arrows
    `c.pt ⟶ F.obj -`. -/
@[simps]
def Cone.toStructuredArrow {F : J ⥤ C} (c : Cone F) : J ⥤ StructuredArrow c.pt F 
goal: ∀ {X Y : J} (f : X ⟶ Y), c.toStructuredArrow.map f = CategoryTheory.StructuredArrow.homMk f ⋯

full_name: CategoryTheory.Limits.Cone.toStructuredArrow
code: /-- Given a cone `c` over `F`, we can interpret the legs of `c` as structured arrows
    `c.pt ⟶ F.obj -`. -/
@[simps]
def Cone.toStructuredArrow {F : J ⥤ C} (c : Cone F) : J ⥤ StructuredArrow c.pt F 
goal: CategoryTheory.Functor J (CategoryTheory.StructuredArrow c.pt F)

full_name: CategoryTheory.Limits.limit.toStructuredArrow
code: /-- If `F` has a limit, then the limit projections can be interpreted as structured arrows
    `limit F ⟶ F.obj -`. -/
@[simps]
noncomputable def limit.toStructuredArrow (F : J ⥤ C) [HasLimit F] :
    J ⥤ StructuredArrow (limit F) F 
goal: CategoryTheory.Functor J (CategoryTheory.StructuredArrow (CategoryTheory.Limits.limit F) F)

full_name: CategoryTheory.Limits.limit.toStructuredArrow_map
code: /-- If `F` has a limit, then the limit projections can be interpreted as structured arrows
    `limit F ⟶ F.obj -`. -/
@[simps]
noncomputable def limit.toStructuredArrow (F : J ⥤ C) [HasLimit F] :
    J ⥤ StructuredArrow (limit F) F 
goal: ∀ {X Y : J} (f : X ⟶ Y),
  (CategoryTheory.Limits.limit.toStructuredArrow F).map f = CategoryTheory.StructuredArrow.homMk f ⋯

full_name: CategoryTheory.Limits.limit.toStructuredArrow_obj
code: /-- If `F` has a limit, then the limit projections can be interpreted as structured arrows
    `limit F ⟶ F.obj -`. -/
@[simps]
noncomputable def limit.toStructuredArrow (F : J ⥤ C) [HasLimit F] :
    J ⥤ StructuredArrow (limit F) F 
goal: (CategoryTheory.Limits.limit.toStructuredArrow F).obj j =
  CategoryTheory.StructuredArrow.mk (CategoryTheory.Limits.limit.π F j)

full_name: CategoryTheory.Limits.Cone.toStructuredArrowIsoToStructuredArrow
code: /-- `Cone.toStructuredArrow` can be expressed in terms of `Functor.toStructuredArrow`. -/
def Cone.toStructuredArrowIsoToStructuredArrow {F : J ⥤ C} (c : Cone F) :
    c.toStructuredArrow ≅ (𝟭 J).toStructuredArrow c.pt F c.π.app (by simp) 
goal: c.toStructuredArrow ≅ (CategoryTheory.Functor.id J).toStructuredArrow c.pt F c.π.app ⋯

full_name: CategoryTheory.Functor.toStructuredArrowIsoToStructuredArrow
code: /-- `Functor.toStructuredArrow` can be expressed in terms of `Cone.toStructuredArrow`. -/
def _root_.CategoryTheory.Functor.toStructuredArrowIsoToStructuredArrow (G : J ⥤ K) (X : C)
    (F : K ⥤ C) (f : (Y : J) → X ⟶ F.obj (G.obj Y))
    (h : ∀ {Y Z : J} (g : Y ⟶ Z), f Y ≫ F.map (G.map g) = f Z) :
    G.toStructuredArrow X F f h ≅
      (Cone.mk X ⟨f, by simp [h]⟩).toStructuredArrow ⋙ StructuredArrow.pre _ _ _ 
goal: G.toStructuredArrow X F f ⋯ ≅
  { pt := X, π := { app := f, naturality := ⋯ } }.toStructuredArrow.comp
    (CategoryTheory.StructuredArrow.pre { pt := X, π := { app := f, naturality := ⋯ } }.pt G F)

full_name: CategoryTheory.Limits.Cone.toStructuredArrowCompProj
code: /-- Interpreting the legs of a cone as a structured arrow and then forgetting the arrow again does
    nothing. -/
@[simps!]
def Cone.toStructuredArrowCompProj {F : J ⥤ C} (c : Cone F) :
    c.toStructuredArrow ⋙ StructuredArrow.proj _ _ ≅ 𝟭 J 
goal: c.toStructuredArrow.comp (CategoryTheory.StructuredArrow.proj c.pt F) ≅ CategoryTheory.Functor.id J

full_name: CategoryTheory.Limits.Cone.toStructuredArrowCompProj_inv_app
code: /-- Interpreting the legs of a cone as a structured arrow and then forgetting the arrow again does
    nothing. -/
@[simps!]
def Cone.toStructuredArrowCompProj {F : J ⥤ C} (c : Cone F) :
    c.toStructuredArrow ⋙ StructuredArrow.proj _ _ ≅ 𝟭 J 
goal: c.toStructuredArrowCompProj.inv.app X = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Limits.Cone.toStructuredArrowCompProj_hom_app
code: /-- Interpreting the legs of a cone as a structured arrow and then forgetting the arrow again does
    nothing. -/
@[simps!]
def Cone.toStructuredArrowCompProj {F : J ⥤ C} (c : Cone F) :
    c.toStructuredArrow ⋙ StructuredArrow.proj _ _ ≅ 𝟭 J 
goal: c.toStructuredArrowCompProj.hom.app X = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Limits.Cone.toStructuredArrow_comp_proj
code: @[simp]
lemma Cone.toStructuredArrow_comp_proj {F : J ⥤ C} (c : Cone F) :
    c.toStructuredArrow ⋙ StructuredArrow.proj _ _ = 𝟭 J 
goal: c.toStructuredArrow.comp (CategoryTheory.StructuredArrow.proj c.pt F) = CategoryTheory.Functor.id J

full_name: CategoryTheory.Limits.Cone.toStructuredArrowCompToUnderCompForget_inv_app
code: /-- Interpreting the legs of a cone as a structured arrow, interpreting this arrow as an arrow over
    the cone point, and finally forgetting the arrow is the same as just applying the functor the
    cone was over. -/
@[simps!]
def Cone.toStructuredArrowCompToUnderCompForget {F : J ⥤ C} (c : Cone F) :
    c.toStructuredArrow ⋙ StructuredArrow.toUnder _ _ ⋙ Under.forget _ ≅ F 
goal: c.toStructuredArrowCompToUnderCompForget.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Limits.Cone.toStructuredArrowCompToUnderCompForget
code: /-- Interpreting the legs of a cone as a structured arrow, interpreting this arrow as an arrow over
    the cone point, and finally forgetting the arrow is the same as just applying the functor the
    cone was over. -/
@[simps!]
def Cone.toStructuredArrowCompToUnderCompForget {F : J ⥤ C} (c : Cone F) :
    c.toStructuredArrow ⋙ StructuredArrow.toUnder _ _ ⋙ Under.forget _ ≅ F 
goal: c.toStructuredArrow.comp ((CategoryTheory.StructuredArrow.toUnder c.pt F).comp (CategoryTheory.Under.forget c.pt)) ≅ F

full_name: CategoryTheory.Limits.Cone.toStructuredArrowCompToUnderCompForget_hom_app
code: /-- Interpreting the legs of a cone as a structured arrow, interpreting this arrow as an arrow over
    the cone point, and finally forgetting the arrow is the same as just applying the functor the
    cone was over. -/
@[simps!]
def Cone.toStructuredArrowCompToUnderCompForget {F : J ⥤ C} (c : Cone F) :
    c.toStructuredArrow ⋙ StructuredArrow.toUnder _ _ ⋙ Under.forget _ ≅ F 
goal: c.toStructuredArrowCompToUnderCompForget.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Limits.Cone.toStructuredArrow_comp_toUnder_comp_forget
code: @[simp]
lemma Cone.toStructuredArrow_comp_toUnder_comp_forget {F : J ⥤ C} (c : Cone F) :
    c.toStructuredArrow ⋙ StructuredArrow.toUnder _ _ ⋙ Under.forget _ = F 
goal: c.toStructuredArrow.comp ((CategoryTheory.StructuredArrow.toUnder c.pt F).comp (CategoryTheory.Under.forget c.pt)) = F

full_name: CategoryTheory.Limits.Cone.toUnder_π_app
code: /-- A cone `c` on `F : J ⥤ C` lifts to a cone in `Over c.pt` with cone point `𝟙 c.pt`. -/
@[simps]
def Cone.toUnder {F : J ⥤ C} (c : Cone F) :
    Cone (c.toStructuredArrow ⋙ StructuredArrow.toUnder _ _) 
goal: c.toUnder.π.app j = CategoryTheory.Under.homMk (c.π.app j) ⋯

full_name: CategoryTheory.Limits.Cone.toUnder
code: /-- A cone `c` on `F : J ⥤ C` lifts to a cone in `Over c.pt` with cone point `𝟙 c.pt`. -/
@[simps]
def Cone.toUnder {F : J ⥤ C} (c : Cone F) :
    Cone (c.toStructuredArrow ⋙ StructuredArrow.toUnder _ _) 
goal: CategoryTheory.Limits.Cone (c.toStructuredArrow.comp (CategoryTheory.StructuredArrow.toUnder c.pt F))

full_name: CategoryTheory.Limits.Cone.toUnder_pt
code: /-- A cone `c` on `F : J ⥤ C` lifts to a cone in `Over c.pt` with cone point `𝟙 c.pt`. -/
@[simps]
def Cone.toUnder {F : J ⥤ C} (c : Cone F) :
    Cone (c.toStructuredArrow ⋙ StructuredArrow.toUnder _ _) 
goal: c.toUnder.pt = CategoryTheory.Under.mk (CategoryTheory.CategoryStruct.id c.pt)

full_name: CategoryTheory.Limits.limit.toUnder
code: /-- The limit cone for `F : J ⥤ C` lifts to a cocone in `Under (limit F)` with cone point
    `𝟙 (limit F)`. This is automatically also a limit cone. -/
noncomputable def limit.toUnder (F : J ⥤ C) [HasLimit F] :
    Cone (limit.toStructuredArrow F ⋙ StructuredArrow.toUnder _ _) 
goal: CategoryTheory.Limits.Cone
  ((CategoryTheory.Limits.limit.toStructuredArrow F).comp
    (CategoryTheory.StructuredArrow.toUnder (CategoryTheory.Limits.limit F) F))

full_name: CategoryTheory.Limits.Cone.mapConeToUnder_hom_hom
code: /-- `c.toUnder` is a lift of `c` under the forgetful functor. -/
@[simps!]
def Cone.mapConeToUnder {F : J ⥤ C} (c : Cone F) : (Under.forget c.pt).mapCone c.toUnder ≅ c 
goal: c.mapConeToUnder.hom.hom = CategoryTheory.CategoryStruct.id c.pt

full_name: CategoryTheory.Limits.Cone.mapConeToUnder
code: /-- `c.toUnder` is a lift of `c` under the forgetful functor. -/
@[simps!]
def Cone.mapConeToUnder {F : J ⥤ C} (c : Cone F) : (Under.forget c.pt).mapCone c.toUnder ≅ c 
goal: (CategoryTheory.Under.forget c.pt).mapCone c.toUnder ≅ c

full_name: CategoryTheory.Limits.Cone.mapConeToUnder_inv_hom
code: /-- `c.toUnder` is a lift of `c` under the forgetful functor. -/
@[simps!]
def Cone.mapConeToUnder {F : J ⥤ C} (c : Cone F) : (Under.forget c.pt).mapCone c.toUnder ≅ c 
goal: c.mapConeToUnder.inv.hom = CategoryTheory.CategoryStruct.id c.pt

full_name: CategoryTheory.Limits.Cone.fromStructuredArrow_pt
code: /-- Given a diagram of `StructuredArrow X F`s, we may obtain a cone with cone point `X`. -/
@[simps!]
def Cone.fromStructuredArrow (F : C ⥤ D) {X : D} (G : J ⥤ StructuredArrow X F) :
    Cone (G ⋙ StructuredArrow.proj X F ⋙ F) 
goal: (CategoryTheory.Limits.Cone.fromStructuredArrow F G).pt = X

full_name: CategoryTheory.Limits.Cone.fromStructuredArrow_π_app
code: /-- Given a diagram of `StructuredArrow X F`s, we may obtain a cone with cone point `X`. -/
@[simps!]
def Cone.fromStructuredArrow (F : C ⥤ D) {X : D} (G : J ⥤ StructuredArrow X F) :
    Cone (G ⋙ StructuredArrow.proj X F ⋙ F) 
goal: (CategoryTheory.Limits.Cone.fromStructuredArrow F G).π.app j = (G.obj j).hom

full_name: CategoryTheory.Limits.Cone.fromStructuredArrow
code: /-- Given a diagram of `StructuredArrow X F`s, we may obtain a cone with cone point `X`. -/
@[simps!]
def Cone.fromStructuredArrow (F : C ⥤ D) {X : D} (G : J ⥤ StructuredArrow X F) :
    Cone (G ⋙ StructuredArrow.proj X F ⋙ F) 
goal: CategoryTheory.Limits.Cone (G.comp ((CategoryTheory.StructuredArrow.proj X F).comp F))

full_name: CategoryTheory.Limits.Cone.toStructuredArrowCone_pt
code: /-- Given a cone `c : Cone K` and a map `f : X ⟶ F.obj c.X`, we can construct a cone of structured
arrows over `X` with `f` as the cone point.
-/
@[simps]
def Cone.toStructuredArrowCone {K : J ⥤ C} (c : Cone K) (F : C ⥤ D) {X : D} (f : X ⟶ F.obj c.pt) :
    Cone ((F.mapCone c).toStructuredArrow ⋙ StructuredArrow.map f ⋙ StructuredArrow.pre _ K F) 
goal: (c.toStructuredArrowCone F f).pt = CategoryTheory.StructuredArrow.mk f

full_name: CategoryTheory.Limits.Cone.toStructuredArrowCone_π_app
code: /-- Given a cone `c : Cone K` and a map `f : X ⟶ F.obj c.X`, we can construct a cone of structured
arrows over `X` with `f` as the cone point.
-/
@[simps]
def Cone.toStructuredArrowCone {K : J ⥤ C} (c : Cone K) (F : C ⥤ D) {X : D} (f : X ⟶ F.obj c.pt) :
    Cone ((F.mapCone c).toStructuredArrow ⋙ StructuredArrow.map f ⋙ StructuredArrow.pre _ K F) 
goal: (c.toStructuredArrowCone F f).π.app j = CategoryTheory.StructuredArrow.homMk (c.π.app j) ⋯

full_name: CategoryTheory.Limits.Cone.toStructuredArrowCone
code: /-- Given a cone `c : Cone K` and a map `f : X ⟶ F.obj c.X`, we can construct a cone of structured
arrows over `X` with `f` as the cone point.
-/
@[simps]
def Cone.toStructuredArrowCone {K : J ⥤ C} (c : Cone K) (F : C ⥤ D) {X : D} (f : X ⟶ F.obj c.pt) :
    Cone ((F.mapCone c).toStructuredArrow ⋙ StructuredArrow.map f ⋙ StructuredArrow.pre _ K F) 
goal: CategoryTheory.Limits.Cone
  ((F.mapCone c).toStructuredArrow.comp
    ((CategoryTheory.StructuredArrow.map f).comp (CategoryTheory.StructuredArrow.pre X K F)))

full_name: CategoryTheory.Limits.Cone.toCostructuredArrow
code: /-- Construct an object of the category `(Δ ↓ F)` from a cone on `F`. This is part of an
    equivalence, see `Cone.equivCostructuredArrow`. -/
@[simps]
def Cone.toCostructuredArrow (F : J ⥤ C) : Cone F ⥤ CostructuredArrow (const J) F 
goal: CategoryTheory.Functor (CategoryTheory.Limits.Cone F)
  (CategoryTheory.CostructuredArrow (CategoryTheory.Functor.const J) F)

full_name: CategoryTheory.Limits.Cone.toCostructuredArrow_map
code: /-- Construct an object of the category `(Δ ↓ F)` from a cone on `F`. This is part of an
    equivalence, see `Cone.equivCostructuredArrow`. -/
@[simps]
def Cone.toCostructuredArrow (F : J ⥤ C) : Cone F ⥤ CostructuredArrow (const J) F 
goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y),
  (CategoryTheory.Limits.Cone.toCostructuredArrow F).map f = CategoryTheory.CostructuredArrow.homMk f.hom ⋯

full_name: CategoryTheory.Limits.Cone.toCostructuredArrow_obj
code: /-- Construct an object of the category `(Δ ↓ F)` from a cone on `F`. This is part of an
    equivalence, see `Cone.equivCostructuredArrow`. -/
@[simps]
def Cone.toCostructuredArrow (F : J ⥤ C) : Cone F ⥤ CostructuredArrow (const J) F 
goal: (CategoryTheory.Limits.Cone.toCostructuredArrow F).obj c = CategoryTheory.CostructuredArrow.mk c.π

full_name: CategoryTheory.Limits.Cone.fromCostructuredArrow_obj_π
code: /-- Construct a cone on `F` from an object of the category `(Δ ↓ F)`. This is part of an
    equivalence, see `Cone.equivCostructuredArrow`. -/
@[simps]
def Cone.fromCostructuredArrow (F : J ⥤ C) : CostructuredArrow (const J) F ⥤ Cone F 
goal: ((CategoryTheory.Limits.Cone.fromCostructuredArrow F).obj c).π = c.hom

full_name: CategoryTheory.Limits.Cone.fromCostructuredArrow_map_hom
code: /-- Construct a cone on `F` from an object of the category `(Δ ↓ F)`. This is part of an
    equivalence, see `Cone.equivCostructuredArrow`. -/
@[simps]
def Cone.fromCostructuredArrow (F : J ⥤ C) : CostructuredArrow (const J) F ⥤ Cone F 
goal: ∀ {X Y : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.const J) F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cone.fromCostructuredArrow F).map f).hom = f.left

full_name: CategoryTheory.Limits.Cone.fromCostructuredArrow_obj_pt
code: /-- Construct a cone on `F` from an object of the category `(Δ ↓ F)`. This is part of an
    equivalence, see `Cone.equivCostructuredArrow`. -/
@[simps]
def Cone.fromCostructuredArrow (F : J ⥤ C) : CostructuredArrow (const J) F ⥤ Cone F 
goal: ((CategoryTheory.Limits.Cone.fromCostructuredArrow F).obj c).pt = c.left

full_name: CategoryTheory.Limits.Cone.fromCostructuredArrow
code: /-- Construct a cone on `F` from an object of the category `(Δ ↓ F)`. This is part of an
    equivalence, see `Cone.equivCostructuredArrow`. -/
@[simps]
def Cone.fromCostructuredArrow (F : J ⥤ C) : CostructuredArrow (const J) F ⥤ Cone F 
goal: CategoryTheory.Functor (CategoryTheory.CostructuredArrow (CategoryTheory.Functor.const J) F)
  (CategoryTheory.Limits.Cone F)

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_inverse_obj_pt
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).inverse.obj c).pt = c.left

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_functor_map_left
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).functor.map f).left = f.hom

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_inverse_map_hom
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ∀ {X Y : CategoryTheory.CostructuredArrow (CategoryTheory.Functor.const J) F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).inverse.map f).hom = f.left

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_counitIso_hom_app_left
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).counitIso.hom.app X).left =
  CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_functor_obj_left
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).functor.obj c).left = c.pt

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_functor_obj_hom
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).functor.obj c).hom = c.π

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_functor_map_right
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).functor.map f).right =
    CategoryTheory.CategoryStruct.id { as := PUnit.unit }

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_counitIso_hom_app_right
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).counitIso.hom.app X).right =
  CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_unitIso_hom_app_hom
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).unitIso.hom.app X).hom = CategoryTheory.CategoryStruct.id X.pt

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_counitIso_inv_app_left
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).counitIso.inv.app X).left =
  CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_counitIso_inv_app_right
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).counitIso.inv.app X).right =
  CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_functor_obj_right_as
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).functor.obj c).right.as = PUnit.unit

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_inverse_obj_π
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).inverse.obj c).π = c.hom

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow_unitIso_inv_app_hom
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: ((CategoryTheory.Limits.Cone.equivCostructuredArrow F).unitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.pt

full_name: CategoryTheory.Limits.Cone.equivCostructuredArrow
code: /-- The category of cones on `F` is just the comma category `(Δ ↓ F)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cone.equivCostructuredArrow (F : J ⥤ C) : Cone F ≌ CostructuredArrow (const J) F 
goal: CategoryTheory.Limits.Cone F ≌ CategoryTheory.CostructuredArrow (CategoryTheory.Functor.const J) F

full_name: CategoryTheory.Limits.Cone.isLimitEquivIsTerminal
code: /-- A cone is a limit cone iff it is terminal. -/
def Cone.isLimitEquivIsTerminal {F : J ⥤ C} (c : Cone F) : IsLimit c ≃ IsTerminal c 
goal: CategoryTheory.Limits.IsLimit c ≃ CategoryTheory.Limits.IsTerminal c

full_name: CategoryTheory.Limits.hasLimit_iff_hasTerminal_cone
code: theorem hasLimit_iff_hasTerminal_cone (F : J ⥤ C) : HasLimit F ↔ HasTerminal (Cone F) 
goal: CategoryTheory.Limits.HasLimit F ↔ CategoryTheory.Limits.HasTerminal (CategoryTheory.Limits.Cone F)

full_name: CategoryTheory.Limits.hasLimitsOfShape_iff_isLeftAdjoint_const
code: theorem hasLimitsOfShape_iff_isLeftAdjoint_const :
    HasLimitsOfShape J C ↔ IsLeftAdjoint (const J : C ⥤ _) 
goal: CategoryTheory.Limits.HasLimitsOfShape J C ↔ (CategoryTheory.Functor.const J).IsLeftAdjoint

full_name: CategoryTheory.Limits.IsLimit.liftConeMorphism_eq_isTerminal_from
code: theorem IsLimit.liftConeMorphism_eq_isTerminal_from {F : J ⥤ C} {c : Cone F} (hc : IsLimit c)
    (s : Cone F) : hc.liftConeMorphism s = IsTerminal.from (Cone.isLimitEquivIsTerminal _ hc) _ 
goal: hc.liftConeMorphism s = (c.isLimitEquivIsTerminal hc).from s

full_name: CategoryTheory.Limits.IsTerminal.from_eq_liftConeMorphism
code: theorem IsTerminal.from_eq_liftConeMorphism {F : J ⥤ C} {c : Cone F} (hc : IsTerminal c)
    (s : Cone F) :
    IsTerminal.from hc s = ((Cone.isLimitEquivIsTerminal _).symm hc).liftConeMorphism s 
goal: hc.from s = (c.isLimitEquivIsTerminal.symm hc).liftConeMorphism s

full_name: CategoryTheory.Limits.IsLimit.ofPreservesConeTerminal
code: /-- If `G : Cone F ⥤ Cone F'` preserves terminal objects, it preserves limit cones. -/
def IsLimit.ofPreservesConeTerminal {F : J ⥤ C} {F' : K ⥤ D} (G : Cone F ⥤ Cone F')
    [PreservesLimit (Functor.empty.{0} _) G] {c : Cone F} (hc : IsLimit c) : IsLimit (G.obj c) 
goal: CategoryTheory.Limits.IsLimit (G.obj c)

full_name: CategoryTheory.Limits.IsLimit.ofReflectsConeTerminal
code: /-- If `G : Cone F ⥤ Cone F'` reflects terminal objects, it reflects limit cones. -/
def IsLimit.ofReflectsConeTerminal {F : J ⥤ C} {F' : K ⥤ D} (G : Cone F ⥤ Cone F')
    [ReflectsLimit (Functor.empty.{0} _) G] {c : Cone F} (hc : IsLimit (G.obj c)) : IsLimit c 
goal: CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrow_obj
code: /-- Given a cocone `c` over `F`, we can interpret the legs of `c` as costructured arrows
    `F.obj - ⟶ c.pt`. -/
@[simps]
def Cocone.toCostructuredArrow {F : J ⥤ C} (c : Cocone F) : J ⥤ CostructuredArrow F c.pt 
goal: c.toCostructuredArrow.obj j = CategoryTheory.CostructuredArrow.mk (c.ι.app j)

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrow
code: /-- Given a cocone `c` over `F`, we can interpret the legs of `c` as costructured arrows
    `F.obj - ⟶ c.pt`. -/
@[simps]
def Cocone.toCostructuredArrow {F : J ⥤ C} (c : Cocone F) : J ⥤ CostructuredArrow F c.pt 
goal: CategoryTheory.Functor J (CategoryTheory.CostructuredArrow F c.pt)

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrow_map
code: /-- Given a cocone `c` over `F`, we can interpret the legs of `c` as costructured arrows
    `F.obj - ⟶ c.pt`. -/
@[simps]
def Cocone.toCostructuredArrow {F : J ⥤ C} (c : Cocone F) : J ⥤ CostructuredArrow F c.pt 
goal: ∀ {X Y : J} (f : X ⟶ Y), c.toCostructuredArrow.map f = CategoryTheory.CostructuredArrow.homMk f ⋯

full_name: CategoryTheory.Limits.colimit.toCostructuredArrow_map
code: /-- If `F` has a colimit, then the colimit inclusions can be interpreted as costructured arrows
    `F.obj - ⟶ colimit F`. -/
@[simps]
noncomputable def colimit.toCostructuredArrow (F : J ⥤ C) [HasColimit F] :
    J ⥤ CostructuredArrow F (colimit F) 
goal: ∀ {X Y : J} (f : X ⟶ Y),
  (CategoryTheory.Limits.colimit.toCostructuredArrow F).map f = CategoryTheory.CostructuredArrow.homMk f ⋯

full_name: CategoryTheory.Limits.colimit.toCostructuredArrow
code: /-- If `F` has a colimit, then the colimit inclusions can be interpreted as costructured arrows
    `F.obj - ⟶ colimit F`. -/
@[simps]
noncomputable def colimit.toCostructuredArrow (F : J ⥤ C) [HasColimit F] :
    J ⥤ CostructuredArrow F (colimit F) 
goal: CategoryTheory.Functor J (CategoryTheory.CostructuredArrow F (CategoryTheory.Limits.colimit F))

full_name: CategoryTheory.Limits.colimit.toCostructuredArrow_obj
code: /-- If `F` has a colimit, then the colimit inclusions can be interpreted as costructured arrows
    `F.obj - ⟶ colimit F`. -/
@[simps]
noncomputable def colimit.toCostructuredArrow (F : J ⥤ C) [HasColimit F] :
    J ⥤ CostructuredArrow F (colimit F) 
goal: (CategoryTheory.Limits.colimit.toCostructuredArrow F).obj j =
  CategoryTheory.CostructuredArrow.mk (CategoryTheory.Limits.colimit.ι F j)

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrowIsoToCostructuredArrow
code: /-- `Cocone.toCostructuredArrow` can be expressed in terms of `Functor.toCostructuredArrow`. -/
def Cocone.toCostructuredArrowIsoToCostructuredArrow {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ≅ (𝟭 J).toCostructuredArrow F c.pt c.ι.app (by simp) 
goal: c.toCostructuredArrow ≅ (CategoryTheory.Functor.id J).toCostructuredArrow F c.pt c.ι.app ⋯

full_name: CategoryTheory.Functor.toCostructuredArrowIsoToCostructuredArrow
code: /-- `Functor.toCostructuredArrow` can be expressed in terms of `Cocone.toCostructuredArrow`. -/
def _root_.CategoryTheory.Functor.toCostructuredArrowIsoToCostructuredArrow (G : J ⥤ K)
    (F : K ⥤ C) (X : C) (f : (Y : J) → F.obj (G.obj Y) ⟶ X)
    (h : ∀ {Y Z : J} (g : Y ⟶ Z), F.map (G.map g) ≫ f Z = f Y) :
    G.toCostructuredArrow F X f h ≅
      (Cocone.mk X ⟨f, by simp [h]⟩).toCostructuredArrow ⋙ CostructuredArrow.pre _ _ _ 
goal: G.toCostructuredArrow F X f ⋯ ≅
  { pt := X, ι := { app := f, naturality := ⋯ } }.toCostructuredArrow.comp
    (CategoryTheory.CostructuredArrow.pre G F { pt := X, ι := { app := f, naturality := ⋯ } }.pt)

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrowCompProj_inv_app
code: /-- Interpreting the legs of a cocone as a costructured arrow and then forgetting the arrow again
    does nothing. -/
@[simps!]
def Cocone.toCostructuredArrowCompProj {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.proj _ _ ≅ 𝟭 J 
goal: c.toCostructuredArrowCompProj.inv.app X = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrowCompProj
code: /-- Interpreting the legs of a cocone as a costructured arrow and then forgetting the arrow again
    does nothing. -/
@[simps!]
def Cocone.toCostructuredArrowCompProj {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.proj _ _ ≅ 𝟭 J 
goal: c.toCostructuredArrow.comp (CategoryTheory.CostructuredArrow.proj F c.pt) ≅ CategoryTheory.Functor.id J

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrowCompProj_hom_app
code: /-- Interpreting the legs of a cocone as a costructured arrow and then forgetting the arrow again
    does nothing. -/
@[simps!]
def Cocone.toCostructuredArrowCompProj {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.proj _ _ ≅ 𝟭 J 
goal: c.toCostructuredArrowCompProj.hom.app X = CategoryTheory.CategoryStruct.id X

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrow_comp_proj
code: @[simp]
lemma Cocone.toCostructuredArrow_comp_proj {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.proj _ _ = 𝟭 J 
goal: c.toCostructuredArrow.comp (CategoryTheory.CostructuredArrow.proj F c.pt) = CategoryTheory.Functor.id J

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrowCompToOverCompForget
code: /-- Interpreting the legs of a cocone as a costructured arrow, interpreting this arrow as an arrow
    over the cocone point, and finally forgetting the arrow is the same as just applying the
    functor the cocone was over. -/
@[simps!]
def Cocone.toCostructuredArrowCompToOverCompForget {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _ ⋙ Over.forget _ ≅ F 
goal: c.toCostructuredArrow.comp ((CategoryTheory.CostructuredArrow.toOver F c.pt).comp (CategoryTheory.Over.forget c.pt)) ≅ F

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrowCompToOverCompForget_inv_app
code: /-- Interpreting the legs of a cocone as a costructured arrow, interpreting this arrow as an arrow
    over the cocone point, and finally forgetting the arrow is the same as just applying the
    functor the cocone was over. -/
@[simps!]
def Cocone.toCostructuredArrowCompToOverCompForget {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _ ⋙ Over.forget _ ≅ F 
goal: c.toCostructuredArrowCompToOverCompForget.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrowCompToOverCompForget_hom_app
code: /-- Interpreting the legs of a cocone as a costructured arrow, interpreting this arrow as an arrow
    over the cocone point, and finally forgetting the arrow is the same as just applying the
    functor the cocone was over. -/
@[simps!]
def Cocone.toCostructuredArrowCompToOverCompForget {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _ ⋙ Over.forget _ ≅ F 
goal: c.toCostructuredArrowCompToOverCompForget.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrow_comp_toOver_comp_forget
code: @[simp]
lemma Cocone.toCostructuredArrow_comp_toOver_comp_forget {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _ ⋙ Over.forget _ = F 
goal: c.toCostructuredArrow.comp ((CategoryTheory.CostructuredArrow.toOver F c.pt).comp (CategoryTheory.Over.forget c.pt)) = F

full_name: CategoryTheory.Limits.Cocone.toOver
code: /-- A cocone `c` on `F : J ⥤ C` lifts to a cocone in `Over c.pt` with cone point `𝟙 c.pt`. -/
@[simps]
def Cocone.toOver {F : J ⥤ C} (c : Cocone F) :
    Cocone (c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _) 
goal: CategoryTheory.Limits.Cocone (c.toCostructuredArrow.comp (CategoryTheory.CostructuredArrow.toOver F c.pt))

full_name: CategoryTheory.Limits.Cocone.toOver_ι_app
code: /-- A cocone `c` on `F : J ⥤ C` lifts to a cocone in `Over c.pt` with cone point `𝟙 c.pt`. -/
@[simps]
def Cocone.toOver {F : J ⥤ C} (c : Cocone F) :
    Cocone (c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _) 
goal: c.toOver.ι.app j = CategoryTheory.Over.homMk (c.ι.app j) ⋯

full_name: CategoryTheory.Limits.Cocone.toOver_pt
code: /-- A cocone `c` on `F : J ⥤ C` lifts to a cocone in `Over c.pt` with cone point `𝟙 c.pt`. -/
@[simps]
def Cocone.toOver {F : J ⥤ C} (c : Cocone F) :
    Cocone (c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _) 
goal: c.toOver.pt = CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id c.pt)

full_name: CategoryTheory.Limits.colimit.toOver_ι_app
code: /-- The colimit cocone for `F : J ⥤ C` lifts to a cocone in `Over (colimit F)` with cone point
    `𝟙 (colimit F)`. This is automatically also a colimit cocone. -/
@[simps]
noncomputable def colimit.toOver (F : J ⥤ C) [HasColimit F] :
    Cocone (colimit.toCostructuredArrow F ⋙ CostructuredArrow.toOver _ _) 
goal: (CategoryTheory.Limits.colimit.toOver F).ι.app j = CategoryTheory.Over.homMk (CategoryTheory.Limits.colimit.ι F j) ⋯

full_name: CategoryTheory.Limits.colimit.toOver
code: /-- The colimit cocone for `F : J ⥤ C` lifts to a cocone in `Over (colimit F)` with cone point
    `𝟙 (colimit F)`. This is automatically also a colimit cocone. -/
@[simps]
noncomputable def colimit.toOver (F : J ⥤ C) [HasColimit F] :
    Cocone (colimit.toCostructuredArrow F ⋙ CostructuredArrow.toOver _ _) 
goal: CategoryTheory.Limits.Cocone
  ((CategoryTheory.Limits.colimit.toCostructuredArrow F).comp
    (CategoryTheory.CostructuredArrow.toOver F (CategoryTheory.Limits.colimit F)))

full_name: CategoryTheory.Limits.colimit.toOver_pt
code: /-- The colimit cocone for `F : J ⥤ C` lifts to a cocone in `Over (colimit F)` with cone point
    `𝟙 (colimit F)`. This is automatically also a colimit cocone. -/
@[simps]
noncomputable def colimit.toOver (F : J ⥤ C) [HasColimit F] :
    Cocone (colimit.toCostructuredArrow F ⋙ CostructuredArrow.toOver _ _) 
goal: (CategoryTheory.Limits.colimit.toOver F).pt =
  CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.colimit F))

full_name: CategoryTheory.Limits.Cocone.mapCoconeToOver_inv_hom
code: /-- `c.toOver` is a lift of `c` under the forgetful functor. -/
@[simps!]
def Cocone.mapCoconeToOver {F : J ⥤ C} (c : Cocone F) : (Over.forget c.pt).mapCocone c.toOver ≅ c 
goal: c.mapCoconeToOver.inv.hom = CategoryTheory.CategoryStruct.id c.pt

full_name: CategoryTheory.Limits.Cocone.mapCoconeToOver
code: /-- `c.toOver` is a lift of `c` under the forgetful functor. -/
@[simps!]
def Cocone.mapCoconeToOver {F : J ⥤ C} (c : Cocone F) : (Over.forget c.pt).mapCocone c.toOver ≅ c 
goal: (CategoryTheory.Over.forget c.pt).mapCocone c.toOver ≅ c

full_name: CategoryTheory.Limits.Cocone.mapCoconeToOver_hom_hom
code: /-- `c.toOver` is a lift of `c` under the forgetful functor. -/
@[simps!]
def Cocone.mapCoconeToOver {F : J ⥤ C} (c : Cocone F) : (Over.forget c.pt).mapCocone c.toOver ≅ c 
goal: c.mapCoconeToOver.hom.hom = CategoryTheory.CategoryStruct.id c.pt

full_name: CategoryTheory.Limits.Cocone.fromCostructuredArrow_pt
code: /-- Given a diagram `CostructuredArrow F X`s, we may obtain a cocone with cone point `X`. -/
@[simps!]
def Cocone.fromCostructuredArrow (F : C ⥤ D) {X : D} (G : J ⥤ CostructuredArrow F X) :
    Cocone (G ⋙ CostructuredArrow.proj F X ⋙ F) 
goal: (CategoryTheory.Limits.Cocone.fromCostructuredArrow F G).pt = X

full_name: CategoryTheory.Limits.Cocone.fromCostructuredArrow_ι_app
code: /-- Given a diagram `CostructuredArrow F X`s, we may obtain a cocone with cone point `X`. -/
@[simps!]
def Cocone.fromCostructuredArrow (F : C ⥤ D) {X : D} (G : J ⥤ CostructuredArrow F X) :
    Cocone (G ⋙ CostructuredArrow.proj F X ⋙ F) 
goal: (CategoryTheory.Limits.Cocone.fromCostructuredArrow F G).ι.app j = (G.obj j).hom

full_name: CategoryTheory.Limits.Cocone.fromCostructuredArrow
code: /-- Given a diagram `CostructuredArrow F X`s, we may obtain a cocone with cone point `X`. -/
@[simps!]
def Cocone.fromCostructuredArrow (F : C ⥤ D) {X : D} (G : J ⥤ CostructuredArrow F X) :
    Cocone (G ⋙ CostructuredArrow.proj F X ⋙ F) 
goal: CategoryTheory.Limits.Cocone (G.comp ((CategoryTheory.CostructuredArrow.proj F X).comp F))

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrowCocone_pt
code: /-- Given a cocone `c : Cocone K` and a map `f : F.obj c.X ⟶ X`, we can construct a cocone of
    costructured arrows over `X` with `f` as the cone point. -/
@[simps]
def Cocone.toCostructuredArrowCocone {K : J ⥤ C} (c : Cocone K) (F : C ⥤ D) {X : D}
    (f : F.obj c.pt ⟶ X) : Cocone ((F.mapCocone c).toCostructuredArrow ⋙
      CostructuredArrow.map f ⋙ CostructuredArrow.pre _ _ _) 
goal: (c.toCostructuredArrowCocone F f).pt = CategoryTheory.CostructuredArrow.mk f

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrowCocone_ι_app
code: /-- Given a cocone `c : Cocone K` and a map `f : F.obj c.X ⟶ X`, we can construct a cocone of
    costructured arrows over `X` with `f` as the cone point. -/
@[simps]
def Cocone.toCostructuredArrowCocone {K : J ⥤ C} (c : Cocone K) (F : C ⥤ D) {X : D}
    (f : F.obj c.pt ⟶ X) : Cocone ((F.mapCocone c).toCostructuredArrow ⋙
      CostructuredArrow.map f ⋙ CostructuredArrow.pre _ _ _) 
goal: (c.toCostructuredArrowCocone F f).ι.app j = CategoryTheory.CostructuredArrow.homMk (c.ι.app j) ⋯

full_name: CategoryTheory.Limits.Cocone.toCostructuredArrowCocone
code: /-- Given a cocone `c : Cocone K` and a map `f : F.obj c.X ⟶ X`, we can construct a cocone of
    costructured arrows over `X` with `f` as the cone point. -/
@[simps]
def Cocone.toCostructuredArrowCocone {K : J ⥤ C} (c : Cocone K) (F : C ⥤ D) {X : D}
    (f : F.obj c.pt ⟶ X) : Cocone ((F.mapCocone c).toCostructuredArrow ⋙
      CostructuredArrow.map f ⋙ CostructuredArrow.pre _ _ _) 
goal: CategoryTheory.Limits.Cocone
  ((F.mapCocone c).toCostructuredArrow.comp
    ((CategoryTheory.CostructuredArrow.map f).comp (CategoryTheory.CostructuredArrow.pre K F X)))

full_name: CategoryTheory.Limits.Cocone.toStructuredArrow_obj
code: /-- Construct an object of the category `(F ↓ Δ)` from a cocone on `F`. This is part of an
    equivalence, see `Cocone.equivStructuredArrow`. -/
@[simps]
def Cocone.toStructuredArrow (F : J ⥤ C) : Cocone F ⥤ StructuredArrow F (const J) 
goal: (CategoryTheory.Limits.Cocone.toStructuredArrow F).obj c = CategoryTheory.StructuredArrow.mk c.ι

full_name: CategoryTheory.Limits.Cocone.toStructuredArrow_map
code: /-- Construct an object of the category `(F ↓ Δ)` from a cocone on `F`. This is part of an
    equivalence, see `Cocone.equivStructuredArrow`. -/
@[simps]
def Cocone.toStructuredArrow (F : J ⥤ C) : Cocone F ⥤ StructuredArrow F (const J) 
goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y),
  (CategoryTheory.Limits.Cocone.toStructuredArrow F).map f = CategoryTheory.StructuredArrow.homMk f.hom ⋯

full_name: CategoryTheory.Limits.Cocone.toStructuredArrow
code: /-- Construct an object of the category `(F ↓ Δ)` from a cocone on `F`. This is part of an
    equivalence, see `Cocone.equivStructuredArrow`. -/
@[simps]
def Cocone.toStructuredArrow (F : J ⥤ C) : Cocone F ⥤ StructuredArrow F (const J) 
goal: CategoryTheory.Functor (CategoryTheory.Limits.Cocone F)
  (CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J))

full_name: CategoryTheory.Limits.Cocone.fromStructuredArrow
code: /-- Construct a cocone on `F` from an object of the category `(F ↓ Δ)`. This is part of an
    equivalence, see `Cocone.equivStructuredArrow`. -/
@[simps]
def Cocone.fromStructuredArrow (F : J ⥤ C) : StructuredArrow F (const J) ⥤ Cocone F 
goal: CategoryTheory.Functor (CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J))
  (CategoryTheory.Limits.Cocone F)

full_name: CategoryTheory.Limits.Cocone.fromStructuredArrow_obj_ι
code: /-- Construct a cocone on `F` from an object of the category `(F ↓ Δ)`. This is part of an
    equivalence, see `Cocone.equivStructuredArrow`. -/
@[simps]
def Cocone.fromStructuredArrow (F : J ⥤ C) : StructuredArrow F (const J) ⥤ Cocone F 
goal: ((CategoryTheory.Limits.Cocone.fromStructuredArrow F).obj c).ι = c.hom

full_name: CategoryTheory.Limits.Cocone.fromStructuredArrow_obj_pt
code: /-- Construct a cocone on `F` from an object of the category `(F ↓ Δ)`. This is part of an
    equivalence, see `Cocone.equivStructuredArrow`. -/
@[simps]
def Cocone.fromStructuredArrow (F : J ⥤ C) : StructuredArrow F (const J) ⥤ Cocone F 
goal: ((CategoryTheory.Limits.Cocone.fromStructuredArrow F).obj c).pt = c.right

full_name: CategoryTheory.Limits.Cocone.fromStructuredArrow_map_hom
code: /-- Construct a cocone on `F` from an object of the category `(F ↓ Δ)`. This is part of an
    equivalence, see `Cocone.equivStructuredArrow`. -/
@[simps]
def Cocone.fromStructuredArrow (F : J ⥤ C) : StructuredArrow F (const J) ⥤ Cocone F 
goal: ∀ {X Y : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J)} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cocone.fromStructuredArrow F).map f).hom = f.right

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_counitIso_hom_app_right
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).counitIso.hom.app X).right =
  CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_unitIso_hom_app_hom
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).unitIso.hom.app X).hom = CategoryTheory.CategoryStruct.id X.pt

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_unitIso_inv_app_hom
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).unitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.pt

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: CategoryTheory.Limits.Cocone F ≌ CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J)

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_functor_obj_left_as
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).functor.obj c).left.as = PUnit.unit

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_functor_obj_hom
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).functor.obj c).hom = c.ι

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_counitIso_inv_app_right
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).counitIso.inv.app X).right =
  CategoryTheory.CategoryStruct.id X.right

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_inverse_obj_ι
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).inverse.obj c).ι = c.hom

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_counitIso_hom_app_left
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).counitIso.hom.app X).left =
  CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_inverse_obj_pt
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).inverse.obj c).pt = c.right

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_counitIso_inv_app_left
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).counitIso.inv.app X).left =
  CategoryTheory.CategoryStruct.id X.left

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_functor_map_left
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).functor.map f).left =
    CategoryTheory.CategoryStruct.id { as := PUnit.unit }

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_inverse_map_hom
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ∀ {X Y : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J)} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).inverse.map f).hom = f.right

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_functor_map_right
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).functor.map f).right = f.hom

full_name: CategoryTheory.Limits.Cocone.equivStructuredArrow_functor_obj_right
code: /-- The category of cocones on `F` is just the comma category `(F ↓ Δ)`, where `Δ` is the constant
    functor. -/
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).functor.obj c).right = c.pt

full_name: CategoryTheory.Limits.Cocone.isColimitEquivIsInitial
code: /-- A cocone is a colimit cocone iff it is initial. -/
def Cocone.isColimitEquivIsInitial {F : J ⥤ C} (c : Cocone F) : IsColimit c ≃ IsInitial c 
goal: CategoryTheory.Limits.IsColimit c ≃ CategoryTheory.Limits.IsInitial c

full_name: CategoryTheory.Limits.hasColimit_iff_hasInitial_cocone
code: theorem hasColimit_iff_hasInitial_cocone (F : J ⥤ C) : HasColimit F ↔ HasInitial (Cocone F) 
goal: CategoryTheory.Limits.HasColimit F ↔ CategoryTheory.Limits.HasInitial (CategoryTheory.Limits.Cocone F)

full_name: CategoryTheory.Limits.hasColimitsOfShape_iff_isRightAdjoint_const
code: theorem hasColimitsOfShape_iff_isRightAdjoint_const :
    HasColimitsOfShape J C ↔ IsRightAdjoint (const J : C ⥤ _) 
goal: CategoryTheory.Limits.HasColimitsOfShape J C ↔ (CategoryTheory.Functor.const J).IsRightAdjoint

full_name: CategoryTheory.Limits.IsColimit.descCoconeMorphism_eq_isInitial_to
code: theorem IsColimit.descCoconeMorphism_eq_isInitial_to {F : J ⥤ C} {c : Cocone F} (hc : IsColimit c)
    (s : Cocone F) :
    hc.descCoconeMorphism s = IsInitial.to (Cocone.isColimitEquivIsInitial _ hc) _ 
goal: hc.descCoconeMorphism s = (c.isColimitEquivIsInitial hc).to s

full_name: CategoryTheory.Limits.IsInitial.to_eq_descCoconeMorphism
code: theorem IsInitial.to_eq_descCoconeMorphism {F : J ⥤ C} {c : Cocone F} (hc : IsInitial c)
    (s : Cocone F) :
    IsInitial.to hc s = ((Cocone.isColimitEquivIsInitial _).symm hc).descCoconeMorphism s 
goal: hc.to s = (c.isColimitEquivIsInitial.symm hc).descCoconeMorphism s

full_name: CategoryTheory.Limits.IsColimit.ofPreservesCoconeInitial
code: /-- If `G : Cocone F ⥤ Cocone F'` preserves initial objects, it preserves colimit cocones. -/
def IsColimit.ofPreservesCoconeInitial {F : J ⥤ C} {F' : K ⥤ D} (G : Cocone F ⥤ Cocone F')
    [PreservesColimit (Functor.empty.{0} _) G] {c : Cocone F} (hc : IsColimit c) :
    IsColimit (G.obj c) 
goal: CategoryTheory.Limits.IsColimit (G.obj c)

full_name: CategoryTheory.Limits.IsColimit.ofReflectsCoconeInitial
code: /-- If `G : Cocone F ⥤ Cocone F'` reflects initial objects, it reflects colimit cocones. -/
def IsColimit.ofReflectsCoconeInitial {F : J ⥤ C} {F' : K ⥤ D} (G : Cocone F ⥤ Cocone F')
    [ReflectsColimit (Functor.empty.{0} _) G] {c : Cocone F} (hc : IsColimit (G.obj c)) :
    IsColimit c 
goal: CategoryTheory.Limits.IsColimit c