ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.Cocone.toCostructuredArrow_map
@[simps]
def Cocone.toCostructuredArrow {F : J ⥤ C} (c : Cocone F) : J ⥤ CostructuredArrow F c.pt 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F)
Goal: ∀ {X Y : J} (f : X ⟶ Y), c.toCostructuredArrow.map f = CategoryTheory.CostructuredArrow.homMk f ⋯
-- CategoryTheory.Limits.colimit.toCostructuredArrow_map
@[simps]
noncomputable def colimit.toCostructuredArrow (F : J ⥤ C) [HasColimit F] :
    J ⥤ CostructuredArrow F (colimit F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) [CategoryTheory.Limits.HasColimit F]
Goal: ∀ {X Y : J} (f : X ⟶ Y),
  (CategoryTheory.Limits.colimit.toCostructuredArrow F).map f = CategoryTheory.CostructuredArrow.homMk f ⋯
-- CategoryTheory.Limits.colimit.toCostructuredArrow_obj
@[simps]
noncomputable def colimit.toCostructuredArrow (F : J ⥤ C) [HasColimit F] :
    J ⥤ CostructuredArrow F (colimit F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) [CategoryTheory.Limits.HasColimit F] (j : J)
Goal: (CategoryTheory.Limits.colimit.toCostructuredArrow F).obj j =
  CategoryTheory.CostructuredArrow.mk (CategoryTheory.Limits.colimit.ι F j)
-- CategoryTheory.Limits.Cocone.toCostructuredArrowCompProj_inv_app
@[simps!]
def Cocone.toCostructuredArrowCompProj {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.proj _ _ ≅ 𝟭 J 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) (X : J)
Goal: c.toCostructuredArrowCompProj.inv.app X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Limits.Cocone.toCostructuredArrowCompProj_hom_app
@[simps!]
def Cocone.toCostructuredArrowCompProj {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.proj _ _ ≅ 𝟭 J 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) (X : J)
Goal: c.toCostructuredArrowCompProj.hom.app X = CategoryTheory.CategoryStruct.id X
-- CategoryTheory.Limits.Cocone.toCostructuredArrow_comp_proj
@[simp]
lemma Cocone.toCostructuredArrow_comp_proj {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.proj _ _ = 𝟭 J 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F)
Goal: c.toCostructuredArrow.comp (CategoryTheory.CostructuredArrow.proj F c.pt) = CategoryTheory.Functor.id J
-- CategoryTheory.Limits.Cocone.toCostructuredArrowCompToOverCompForget_inv_app
@[simps!]
def Cocone.toCostructuredArrowCompToOverCompForget {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _ ⋙ Over.forget _ ≅ F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) (X : J)
Goal: c.toCostructuredArrowCompToOverCompForget.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Limits.Cocone.toCostructuredArrowCompToOverCompForget_hom_app
@[simps!]
def Cocone.toCostructuredArrowCompToOverCompForget {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _ ⋙ Over.forget _ ≅ F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) (X : J)
Goal: c.toCostructuredArrowCompToOverCompForget.hom.app X = CategoryTheory.CategoryStruct.id (F.obj X)
-- CategoryTheory.Limits.Cocone.toCostructuredArrow_comp_toOver_comp_forget
@[simp]
lemma Cocone.toCostructuredArrow_comp_toOver_comp_forget {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _ ⋙ Over.forget _ = F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F)
Goal: c.toCostructuredArrow.comp ((CategoryTheory.CostructuredArrow.toOver F c.pt).comp (CategoryTheory.Over.forget c.pt)) = F
-- CategoryTheory.Limits.Cocone.toOver_ι_app
@[simps]
def Cocone.toOver {F : J ⥤ C} (c : Cocone F) :
    Cocone (c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F) (j : J)
Goal: c.toOver.ι.app j = CategoryTheory.Over.homMk (c.ι.app j) ⋯
-- CategoryTheory.Limits.Cocone.toOver_pt
@[simps]
def Cocone.toOver {F : J ⥤ C} (c : Cocone F) :
    Cocone (c.toCostructuredArrow ⋙ CostructuredArrow.toOver _ _) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F)
Goal: c.toOver.pt = CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id c.pt)
-- CategoryTheory.Limits.colimit.toOver_ι_app
@[simps]
noncomputable def colimit.toOver (F : J ⥤ C) [HasColimit F] :
    Cocone (colimit.toCostructuredArrow F ⋙ CostructuredArrow.toOver _ _) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) [CategoryTheory.Limits.HasColimit F] (j : J)
Goal: (CategoryTheory.Limits.colimit.toOver F).ι.app j = CategoryTheory.Over.homMk (CategoryTheory.Limits.colimit.ι F j) ⋯
-- CategoryTheory.Limits.colimit.toOver_pt
@[simps]
noncomputable def colimit.toOver (F : J ⥤ C) [HasColimit F] :
    Cocone (colimit.toCostructuredArrow F ⋙ CostructuredArrow.toOver _ _) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) [CategoryTheory.Limits.HasColimit F]
Goal: (CategoryTheory.Limits.colimit.toOver F).pt =
  CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id (CategoryTheory.Limits.colimit F))
-- CategoryTheory.Limits.Cocone.mapCoconeToOver_inv_hom
@[simps!]
def Cocone.mapCoconeToOver {F : J ⥤ C} (c : Cocone F) : (Over.forget c.pt).mapCocone c.toOver ≅ c 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F)
Goal: c.mapCoconeToOver.inv.hom = CategoryTheory.CategoryStruct.id c.pt
-- CategoryTheory.Limits.Cocone.mapCoconeToOver_hom_hom
@[simps!]
def Cocone.mapCoconeToOver {F : J ⥤ C} (c : Cocone F) : (Over.forget c.pt).mapCocone c.toOver ≅ c 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone F)
Goal: c.mapCoconeToOver.hom.hom = CategoryTheory.CategoryStruct.id c.pt
-- CategoryTheory.Limits.Cocone.fromCostructuredArrow_pt
@[simps!]
def Cocone.fromCostructuredArrow (F : C ⥤ D) {X : D} (G : J ⥤ CostructuredArrow F X) :
    Cocone (G ⋙ CostructuredArrow.proj F X ⋙ F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor C D) {X : D} (G : CategoryTheory.Functor J (CategoryTheory.CostructuredArrow F X))
Goal: (CategoryTheory.Limits.Cocone.fromCostructuredArrow F G).pt = X
-- CategoryTheory.Limits.Cocone.fromCostructuredArrow_ι_app
@[simps!]
def Cocone.fromCostructuredArrow (F : C ⥤ D) {X : D} (G : J ⥤ CostructuredArrow F X) :
    Cocone (G ⋙ CostructuredArrow.proj F X ⋙ F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor C D) {X : D} (G : CategoryTheory.Functor J (CategoryTheory.CostructuredArrow F X)) (j : J)
Goal: (CategoryTheory.Limits.Cocone.fromCostructuredArrow F G).ι.app j = (G.obj j).hom
-- CategoryTheory.Limits.Cocone.toCostructuredArrowCocone_pt
@[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 _ _ _) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {K : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone K) (F : CategoryTheory.Functor C D) {X : D} (f : F.obj c.pt ⟶ X)
Goal: (c.toCostructuredArrowCocone F f).pt = CategoryTheory.CostructuredArrow.mk f
-- CategoryTheory.Limits.Cocone.toCostructuredArrowCocone_ι_app
@[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 _ _ _) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {K : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone K) (F : CategoryTheory.Functor C D) {X : D} (f : F.obj c.pt ⟶ X) (j : J)
Goal: (c.toCostructuredArrowCocone F f).ι.app j = CategoryTheory.CostructuredArrow.homMk (c.ι.app j) ⋯
-- CategoryTheory.Limits.Cocone.toStructuredArrow_obj
@[simps]
def Cocone.toStructuredArrow (F : J ⥤ C) : Cocone F ⥤ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.Cocone.toStructuredArrow F).obj c = CategoryTheory.StructuredArrow.mk c.ι
-- CategoryTheory.Limits.Cocone.toStructuredArrow_map
@[simps]
def Cocone.toStructuredArrow (F : J ⥤ C) : Cocone F ⥤ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C)
Goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y),
  (CategoryTheory.Limits.Cocone.toStructuredArrow F).map f = CategoryTheory.StructuredArrow.homMk f.hom ⋯
-- CategoryTheory.Limits.Cocone.fromStructuredArrow_obj_ι
@[simps]
def Cocone.fromStructuredArrow (F : J ⥤ C) : StructuredArrow F (const J) ⥤ Cocone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (c : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J))
Goal: ((CategoryTheory.Limits.Cocone.fromStructuredArrow F).obj c).ι = c.hom
-- CategoryTheory.Limits.Cocone.fromStructuredArrow_obj_pt
@[simps]
def Cocone.fromStructuredArrow (F : J ⥤ C) : StructuredArrow F (const J) ⥤ Cocone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (c : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J))
Goal: ((CategoryTheory.Limits.Cocone.fromStructuredArrow F).obj c).pt = c.right
-- CategoryTheory.Limits.Cocone.fromStructuredArrow_map_hom
@[simps]
def Cocone.fromStructuredArrow (F : J ⥤ C) : StructuredArrow F (const J) ⥤ Cocone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C)
Goal: ∀ {X Y : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J)} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cocone.fromStructuredArrow F).map f).hom = f.right
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_counitIso_hom_app_right
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (X : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J))
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).counitIso.hom.app X).right =
  CategoryTheory.CategoryStruct.id X.right
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_unitIso_hom_app_hom
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (X : CategoryTheory.Limits.Cocone F)
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).unitIso.hom.app X).hom = CategoryTheory.CategoryStruct.id X.pt
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_unitIso_inv_app_hom
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (X : CategoryTheory.Limits.Cocone F)
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).unitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.pt
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_functor_obj_left_as
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (c : CategoryTheory.Limits.Cocone F)
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).functor.obj c).left.as = PUnit.unit
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_functor_obj_hom
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (c : CategoryTheory.Limits.Cocone F)
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).functor.obj c).hom = c.ι
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_counitIso_inv_app_right
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (X : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J))
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).counitIso.inv.app X).right =
  CategoryTheory.CategoryStruct.id X.right
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_inverse_obj_ι
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (c : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J))
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).inverse.obj c).ι = c.hom
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_counitIso_hom_app_left
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (X : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J))
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).counitIso.hom.app X).left =
  CategoryTheory.CategoryStruct.id X.left
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_inverse_obj_pt
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (c : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J))
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).inverse.obj c).pt = c.right
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_counitIso_inv_app_left
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (X : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J))
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).counitIso.inv.app X).left =
  CategoryTheory.CategoryStruct.id X.left
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_functor_map_left
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C)
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 }
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_inverse_map_hom
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C)
Goal: ∀ {X Y : CategoryTheory.StructuredArrow F (CategoryTheory.Functor.const J)} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).inverse.map f).hom = f.right
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_functor_map_right
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C)
Goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).functor.map f).right = f.hom
-- CategoryTheory.Limits.Cocone.equivStructuredArrow_functor_obj_right
@[simps! (config := { notRecursive := [`PLift, `ULift] })]
def Cocone.equivStructuredArrow (F : J ⥤ C) : Cocone F ≌ StructuredArrow F (const J) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C) (c : CategoryTheory.Limits.Cocone F)
Goal: ((CategoryTheory.Limits.Cocone.equivStructuredArrow F).functor.obj c).right = c.pt
-- CategoryTheory.Limits.hasColimit_iff_hasInitial_cocone
theorem hasColimit_iff_hasInitial_cocone (F : J ⥤ C) : HasColimit F ↔ HasInitial (Cocone F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor J C)
Goal: CategoryTheory.Limits.HasColimit F ↔ CategoryTheory.Limits.HasInitial (CategoryTheory.Limits.Cocone F)
-- CategoryTheory.Limits.hasColimitsOfShape_iff_isRightAdjoint_const
theorem hasColimitsOfShape_iff_isRightAdjoint_const :
    HasColimitsOfShape J C ↔ IsRightAdjoint (const J : C ⥤ _) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C]
Goal: CategoryTheory.Limits.HasColimitsOfShape J C ↔ (CategoryTheory.Functor.const J).IsRightAdjoint
-- CategoryTheory.Limits.IsColimit.descCoconeMorphism_eq_isInitial_to
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) _ 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cocone F)
Goal: hc.descCoconeMorphism s = (c.isColimitEquivIsInitial hc).to s
-- CategoryTheory.Limits.IsInitial.to_eq_descCoconeMorphism
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 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsInitial c) (s : CategoryTheory.Limits.Cocone F)
Goal: hc.to s = (c.isColimitEquivIsInitial.symm hc).descCoconeMorphism s
-- CategoryTheory.Functor.EffectivePresentation.effectiveEpi
structure EffectivePresentation (X : D) where
    p : C
    f : F.obj p ⟶ X
    effectiveEpi : EffectiveEpi f
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] {F : CategoryTheory.Functor C D} {X : D} (self : F.EffectivePresentation X)
Goal: CategoryTheory.EffectiveEpi self.f
-- CategoryTheory.Functor.EffectivelyEnough.presentation
class EffectivelyEnough : Prop where
    presentation : ∀ (X : D), Nonempty (F.EffectivePresentation X)
Arguments: {C : Type u_1} {D : Type u_2} [CategoryTheory.Category.{u_3, u_1} C] [CategoryTheory.Category.{u_4, u_2} D] {F : CategoryTheory.Functor C D} [self : F.EffectivelyEnough] (X : D)
Goal: Nonempty (F.EffectivePresentation X)
-- CategoryTheory.effectiveEpiOfKernelPair
theorem effectiveEpiOfKernelPair {B X : C} (f : X ⟶ B) [HasPullback f f]
    (hc : IsColimit (Cofork.ofπ f pullback.condition)) : EffectiveEpi f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] {B X : C} (f : X ⟶ B) [CategoryTheory.Limits.HasPullback f f] (hc : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofork.ofπ f ⋯))
Goal: CategoryTheory.EffectiveEpi f
-- CategoryTheory.LiftAdjoint.constructLeftAdjointEquiv_symm_apply
@[simps!] -- Porting note: Originally `@[simps (config := { rhsMd := semireducible })]`
noncomputable def constructLeftAdjointEquiv [∀ X : B, RegularEpi (adj₁.counit.app X)] (Y : A)
    (X : B) : (constructLeftAdjointObj _ _ adj₁ adj₂ X ⟶ Y) ≃ (X ⟶ R.obj Y) 
Arguments: {A : Type u₁} {B : Type u₂} {C : Type u₃} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Category.{v₃, u₃} C] {U : CategoryTheory.Functor B C} {F : CategoryTheory.Functor C B} (R : CategoryTheory.Functor A B) (F' : CategoryTheory.Functor C A) (adj₁ : F ⊣ U) (adj₂ : F' ⊣ R.comp U) [CategoryTheory.Limits.HasReflexiveCoequalizers A] [(X : B) → CategoryTheory.RegularEpi (adj₁.counit.app X)] (Y : A) (X : B)
Goal: ∀ (a : X ⟶ R.obj Y),
  (CategoryTheory.LiftAdjoint.constructLeftAdjointEquiv R F' adj₁ adj₂ Y X).symm a =
    (CategoryTheory.Limits.Cofork.IsColimit.homIso
          (CategoryTheory.Limits.colimit.isColimit
            (CategoryTheory.Limits.parallelPair (F'.map (U.map (adj₁.counit.app X)))
              (CategoryTheory.LiftAdjoint.otherMap R F' adj₁ adj₂ X)))
          Y).symm
      ⟨(adj₂.homEquiv (U.obj X) Y).symm
          (CategoryTheory.CategoryStruct.comp (adj₁.unit.app (U.obj X))
            (U.map
              ↑((CategoryTheory.Limits.Cofork.IsColimit.homIso (CategoryTheory.LiftAdjoint.counitCoequalises adj₁ X)
                    (R.obj Y))
                  a))),
        ⋯⟩