ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.Cones.postcomposeComp_inv_app_hom
@[simps!]
def postcomposeComp {G H : J ⥤ C} (α : F ⟶ G) (β : G ⟶ H) :
    postcompose (α ≫ β) ≅ postcompose α ⋙ postcompose β 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G H : J ⥤ C} (α : F ⟶ G) (β : G ⟶ H) (X : CategoryTheory.Limits.Cone F)
Goal: ((CategoryTheory.Limits.Cones.postcomposeComp α β).inv.app X).hom = 𝟙 X.pt
-- CategoryTheory.Limits.Cones.postcomposeComp_hom_app_hom
@[simps!]
def postcomposeComp {G H : J ⥤ C} (α : F ⟶ G) (β : G ⟶ H) :
    postcompose (α ≫ β) ≅ postcompose α ⋙ postcompose β 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G H : J ⥤ C} (α : F ⟶ G) (β : G ⟶ H) (X : CategoryTheory.Limits.Cone F)
Goal: ((CategoryTheory.Limits.Cones.postcomposeComp α β).hom.app X).hom = 𝟙 X.pt
-- CategoryTheory.Limits.Cones.postcomposeId_inv_app_hom
@[simps!]
def postcomposeId : postcompose (𝟙 F) ≅ 𝟭 (Cone F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (X : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.Cones.postcomposeId.inv.app X).hom = 𝟙 X.pt
-- CategoryTheory.Limits.Cones.postcomposeId_hom_app_hom
@[simps!]
def postcomposeId : postcompose (𝟙 F) ≅ 𝟭 (Cone F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (X : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.Cones.postcomposeId.hom.app X).hom = 𝟙 X.pt
-- CategoryTheory.Limits.Cones.postcomposeEquivalence_counitIso
@[simps]
def postcomposeEquivalence {G : J ⥤ C} (α : F ≅ G) : Cone F ≌ Cone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : F ≅ G)
Goal: (CategoryTheory.Limits.Cones.postcomposeEquivalence α).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cones.ext
        (CategoryTheory.Iso.refl
          ((CategoryTheory.Limits.Cones.postcompose α.inv ⋙ CategoryTheory.Limits.Cones.postcompose α.hom).obj s).pt)
        ⋯)
    ⋯
-- CategoryTheory.Limits.Cones.postcomposeEquivalence_inverse
@[simps]
def postcomposeEquivalence {G : J ⥤ C} (α : F ≅ G) : Cone F ≌ Cone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : F ≅ G)
Goal: (CategoryTheory.Limits.Cones.postcomposeEquivalence α).inverse = CategoryTheory.Limits.Cones.postcompose α.inv
-- CategoryTheory.Limits.Cones.postcomposeEquivalence_unitIso
@[simps]
def postcomposeEquivalence {G : J ⥤ C} (α : F ≅ G) : Cone F ≌ Cone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : F ≅ G)
Goal: (CategoryTheory.Limits.Cones.postcomposeEquivalence α).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl ((𝟭 (CategoryTheory.Limits.Cone F)).obj s).pt) ⋯)
    ⋯
-- CategoryTheory.Limits.Cones.postcomposeEquivalence_functor
@[simps]
def postcomposeEquivalence {G : J ⥤ C} (α : F ≅ G) : Cone F ≌ Cone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : F ≅ G)
Goal: (CategoryTheory.Limits.Cones.postcomposeEquivalence α).functor = CategoryTheory.Limits.Cones.postcompose α.hom
-- CategoryTheory.Limits.Cones.whiskering_map_hom
@[simps]
def whiskering (E : K ⥤ J) : Cone F ⥤ Cone (E ⋙ F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (E : K ⥤ J)
Goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y), ((CategoryTheory.Limits.Cones.whiskering E).map f).hom = f.hom
-- CategoryTheory.Limits.Cones.whiskering_obj
@[simps]
def whiskering (E : K ⥤ J) : Cone F ⥤ Cone (E ⋙ F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (E : K ⥤ J) (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.Cones.whiskering E).obj c = CategoryTheory.Limits.Cone.whisker E c
-- CategoryTheory.Limits.Cones.whiskeringEquivalence_counitIso
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cone F ≌ Cone (e.functor ⋙ F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (e : K ≌ J)
Goal: (CategoryTheory.Limits.Cones.whiskeringEquivalence e).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cones.ext
        (CategoryTheory.Iso.refl
          (((CategoryTheory.Limits.Cones.whiskering e.inverse ⋙
                    CategoryTheory.Limits.Cones.postcompose (e.invFunIdAssoc F).hom) ⋙
                  CategoryTheory.Limits.Cones.whiskering e.functor).obj
              s).pt)
        ⋯)
    ⋯
-- CategoryTheory.Limits.Cones.whiskeringEquivalence_inverse
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cone F ≌ Cone (e.functor ⋙ F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (e : K ≌ J)
Goal: (CategoryTheory.Limits.Cones.whiskeringEquivalence e).inverse =
  CategoryTheory.Limits.Cones.whiskering e.inverse ⋙ CategoryTheory.Limits.Cones.postcompose (e.invFunIdAssoc F).hom
-- CategoryTheory.Limits.Cones.whiskeringEquivalence_functor
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cone F ≌ Cone (e.functor ⋙ F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (e : K ≌ J)
Goal: (CategoryTheory.Limits.Cones.whiskeringEquivalence e).functor = CategoryTheory.Limits.Cones.whiskering e.functor
-- CategoryTheory.Limits.Cones.whiskeringEquivalence_unitIso
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cone F ≌ Cone (e.functor ⋙ F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (e : K ≌ J)
Goal: (CategoryTheory.Limits.Cones.whiskeringEquivalence e).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl ((𝟭 (CategoryTheory.Limits.Cone F)).obj s).pt) ⋯)
    ⋯
-- CategoryTheory.Limits.Cones.equivalenceOfReindexing_functor
@[simps! functor inverse unitIso counitIso]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cone F ≌ Cone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G)
Goal: (CategoryTheory.Limits.Cones.equivalenceOfReindexing e α).functor =
  CategoryTheory.Limits.Cones.whiskering e.functor ⋙ CategoryTheory.Limits.Cones.postcompose α.hom
-- CategoryTheory.Limits.Cones.equivalenceOfReindexing_unitIso
@[simps! functor inverse unitIso counitIso]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cone F ≌ Cone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G)
Goal: (CategoryTheory.Limits.Cones.equivalenceOfReindexing e α).unitIso =
  CategoryTheory.NatIso.ofComponents (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl s.pt) ⋯) ⋯ ≪≫
    CategoryTheory.isoWhiskerLeft (CategoryTheory.Limits.Cones.whiskering e.functor)
      (CategoryTheory.isoWhiskerRight
        (CategoryTheory.NatIso.ofComponents (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl s.pt) ⋯)
          ⋯)
        (CategoryTheory.Limits.Cones.whiskering e.inverse ⋙
          CategoryTheory.Limits.Cones.postcompose (e.invFunIdAssoc F).hom))
-- CategoryTheory.Limits.Cones.equivalenceOfReindexing_inverse
@[simps! functor inverse unitIso counitIso]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cone F ≌ Cone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G)
Goal: (CategoryTheory.Limits.Cones.equivalenceOfReindexing e α).inverse =
  CategoryTheory.Limits.Cones.postcompose α.inv ⋙
    CategoryTheory.Limits.Cones.whiskering e.inverse ⋙ CategoryTheory.Limits.Cones.postcompose (e.invFunIdAssoc F).hom
-- CategoryTheory.Limits.Cones.equivalenceOfReindexing_counitIso
@[simps! functor inverse unitIso counitIso]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cone F ≌ Cone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G)
Goal: (CategoryTheory.Limits.Cones.equivalenceOfReindexing e α).counitIso =
  CategoryTheory.isoWhiskerLeft (CategoryTheory.Limits.Cones.postcompose α.inv)
      (CategoryTheory.isoWhiskerRight
        (CategoryTheory.NatIso.ofComponents (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl s.pt) ⋯)
          ⋯)
        (CategoryTheory.Limits.Cones.postcompose α.hom)) ≪≫
    CategoryTheory.NatIso.ofComponents (fun s => CategoryTheory.Limits.Cones.ext (CategoryTheory.Iso.refl s.pt) ⋯) ⋯
-- CategoryTheory.Limits.Cones.forget_map
@[simps]
def forget : Cone F ⥤ C 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : J ⥤ C)
Goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y), (CategoryTheory.Limits.Cones.forget F).map f = f.hom
-- CategoryTheory.Limits.Cones.forget_obj
@[simps]
def forget : Cone F ⥤ C 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : J ⥤ C) (t : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.Cones.forget F).obj t = t.pt
-- CategoryTheory.Limits.Cones.functoriality_obj_pt
@[simps]
def functoriality : Cone F ⥤ Cone (F ⋙ G) 
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 : J ⥤ C) (G : C ⥤ D) (A : CategoryTheory.Limits.Cone F)
Goal: ((CategoryTheory.Limits.Cones.functoriality F G).obj A).pt = G.obj A.pt
-- CategoryTheory.Limits.Cones.functoriality_obj_π_app
@[simps]
def functoriality : Cone F ⥤ Cone (F ⋙ G) 
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 : J ⥤ C) (G : C ⥤ D) (A : CategoryTheory.Limits.Cone F) (j : J)
Goal: ((CategoryTheory.Limits.Cones.functoriality F G).obj A).π.app j = G.map (A.π.app j)
-- CategoryTheory.Limits.Cones.functoriality_map_hom
@[simps]
def functoriality : Cone F ⥤ Cone (F ⋙ G) 
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 : J ⥤ C) (G : C ⥤ D)
Goal: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cones.functoriality F G).map f).hom = G.map f.hom
-- CategoryTheory.Limits.Cones.functorialityEquivalence_unitIso
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cone F ≌ Cone (F ⋙ e.functor) 
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 : J ⥤ C) (e : C ≌ D)
Goal: (CategoryTheory.Limits.Cones.functorialityEquivalence F e).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun c => CategoryTheory.Limits.Cones.ext (e.unitIso.app ((𝟭 (CategoryTheory.Limits.Cone F)).obj c).1) ⋯) ⋯
-- CategoryTheory.Limits.Cones.functorialityEquivalence_counitIso
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cone F ≌ Cone (F ⋙ e.functor) 
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 : J ⥤ C) (e : C ≌ D)
Goal: (CategoryTheory.Limits.Cones.functorialityEquivalence F e).counitIso =
  CategoryTheory.NatIso.ofComponents (fun c => CategoryTheory.Limits.Cones.ext (e.counitIso.app c.pt) ⋯) ⋯
-- CategoryTheory.Limits.Cones.functorialityEquivalence_inverse
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cone F ≌ Cone (F ⋙ e.functor) 
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 : J ⥤ C) (e : C ≌ D)
Goal: (CategoryTheory.Limits.Cones.functorialityEquivalence F e).inverse =
  CategoryTheory.Limits.Cones.functoriality (F ⋙ e.functor) e.inverse ⋙
    (CategoryTheory.Limits.Cones.postcomposeEquivalence
        (F.associator e.functor e.inverse ≪≫ CategoryTheory.isoWhiskerLeft F e.unitIso.symm ≪≫ F.rightUnitor)).functor
-- CategoryTheory.Limits.Cones.functorialityEquivalence_functor
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cone F ≌ Cone (F ⋙ e.functor) 
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 : J ⥤ C) (e : C ≌ D)
Goal: (CategoryTheory.Limits.Cones.functorialityEquivalence F e).functor =
  CategoryTheory.Limits.Cones.functoriality F e.functor
-- CategoryTheory.Limits.CoconeMorphism.w
structure CoconeMorphism (A B : Cocone F) where
    hom : A.pt ⟶ B.pt
    w : ∀ j : J, A.ι.app j ≫ hom = B.ι.app j := by aesop_cat
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {A B : CategoryTheory.Limits.Cocone F} (self : CategoryTheory.Limits.CoconeMorphism A B) (j : J)
Goal: A.ι.app j ≫ self.hom = B.ι.app j
-- CategoryTheory.Limits.Cocone.category_comp_hom
@[simps]
instance Cocone.category : Category (Cocone F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C}
Goal: ∀ {X Y Z : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y) (g : Y ⟶ Z), (f ≫ g).hom = f.hom ≫ g.hom
-- CategoryTheory.Limits.Cocone.category_id_hom
@[simps]
instance Cocone.category : Category (Cocone F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (B : CategoryTheory.Limits.Cocone F)
Goal: (𝟙 B).hom = 𝟙 B.pt
-- CategoryTheory.Limits.CoconeMorphism.ext
@[ext]
theorem CoconeMorphism.ext {c c' : Cocone F} (f g : c ⟶ c') (w : f.hom = g.hom) : f = g 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {c c' : CategoryTheory.Limits.Cocone F} (f g : c ⟶ c') (w : f.hom = g.hom)
Goal: f = g
-- CategoryTheory.Limits.Cocones.ext_inv_hom
-- Porting note: `@[ext]` used to accept lemmas like this. Now we add an aesop rule
@[aesop apply safe (rule_sets := [CategoryTheory]), simps]
def ext {c c' : Cocone F} (φ : c.pt ≅ c'.pt)
    (w : ∀ j, c.ι.app j ≫ φ.hom = c'.ι.app j := by aesop_cat) : c ≅ c' 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {c c' : CategoryTheory.Limits.Cocone F} (φ : c.pt ≅ c'.pt) (w : ∀ (j : J), c.ι.app j ≫ φ.hom = c'.ι.app j := by aesop_cat)
Goal: (CategoryTheory.Limits.Cocones.ext φ w).inv.hom = φ.inv
-- CategoryTheory.Limits.Cocones.ext_hom_hom
-- Porting note: `@[ext]` used to accept lemmas like this. Now we add an aesop rule
@[aesop apply safe (rule_sets := [CategoryTheory]), simps]
def ext {c c' : Cocone F} (φ : c.pt ≅ c'.pt)
    (w : ∀ j, c.ι.app j ≫ φ.hom = c'.ι.app j := by aesop_cat) : c ≅ c' 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {c c' : CategoryTheory.Limits.Cocone F} (φ : c.pt ≅ c'.pt) (w : ∀ (j : J), c.ι.app j ≫ φ.hom = c'.ι.app j := by aesop_cat)
Goal: (CategoryTheory.Limits.Cocones.ext φ w).hom.hom = φ.hom
-- CategoryTheory.Limits.Cocones.eta_inv_hom
@[simps!]
def eta (c : Cocone F) : c ≅ ⟨c.pt, c.ι⟩ 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.Cocones.eta c).inv.hom = 𝟙 c.pt
-- CategoryTheory.Limits.Cocones.eta_hom_hom
@[simps!]
def eta (c : Cocone F) : c ≅ ⟨c.pt, c.ι⟩ 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.Cocones.eta c).hom.hom = 𝟙 c.pt
-- CategoryTheory.Limits.Cocones.cocone_iso_of_hom_iso
theorem cocone_iso_of_hom_iso {K : J ⥤ C} {c d : Cocone K} (f : c ⟶ d) [i : IsIso f.hom] :
    IsIso f 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {K : J ⥤ C} {c d : CategoryTheory.Limits.Cocone K} (f : c ⟶ d) [i : CategoryTheory.IsIso f.hom]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Limits.Cocones.extend_hom
@[simps]
def extend (s : Cocone F) {X : C} (f : s.pt ⟶ X) : s ⟶ s.extend f 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cocone F) {X : C} (f : s.pt ⟶ X)
Goal: (CategoryTheory.Limits.Cocones.extend s f).hom = f
-- CategoryTheory.Limits.Cocones.extendId_inv_hom
@[simps!]
def extendId (s : Cocone F) : s ≅ s.extend (𝟙 s.pt) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.Cocones.extendId s).inv.hom = 𝟙 s.pt
-- CategoryTheory.Limits.Cocones.extendId_hom_hom
@[simps!]
def extendId (s : Cocone F) : s ≅ s.extend (𝟙 s.pt) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.Cocones.extendId s).hom.hom = 𝟙 s.pt
-- CategoryTheory.Limits.Cocones.extendComp_inv_hom
@[simps!]
def extendComp (s : Cocone F) {X Y : C} (f : s.pt ⟶ X) (g : X ⟶ Y) :
    s.extend (f ≫ g) ≅ (s.extend f).extend g 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cocone F) {X Y : C} (f : s.pt ⟶ X) (g : X ⟶ Y)
Goal: (CategoryTheory.Limits.Cocones.extendComp s f g).inv.hom = 𝟙 Y
-- CategoryTheory.Limits.Cocones.extendComp_hom_hom
@[simps!]
def extendComp (s : Cocone F) {X Y : C} (f : s.pt ⟶ X) (g : X ⟶ Y) :
    s.extend (f ≫ g) ≅ (s.extend f).extend g 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cocone F) {X Y : C} (f : s.pt ⟶ X) (g : X ⟶ Y)
Goal: (CategoryTheory.Limits.Cocones.extendComp s f g).hom.hom = 𝟙 Y
-- CategoryTheory.Limits.Cocones.extendIso_inv_hom
@[simps]
def extendIso (s : Cocone F) {X : C} (f : s.pt ≅ X) : s ≅ s.extend f.hom 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cocone F) {X : C} (f : s.pt ≅ X)
Goal: (CategoryTheory.Limits.Cocones.extendIso s f).inv.hom = f.inv
-- CategoryTheory.Limits.Cocones.extendIso_hom_hom
@[simps]
def extendIso (s : Cocone F) {X : C} (f : s.pt ≅ X) : s ≅ s.extend f.hom 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cocone F) {X : C} (f : s.pt ≅ X)
Goal: (CategoryTheory.Limits.Cocones.extendIso s f).hom.hom = f.hom
-- CategoryTheory.Limits.Cocones.precompose_map_hom
@[simps]
def precompose {G : J ⥤ C} (α : G ⟶ F) : Cocone F ⥤ Cocone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : G ⟶ F)
Goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y), ((CategoryTheory.Limits.Cocones.precompose α).map f).hom = f.hom
-- CategoryTheory.Limits.Cocones.precompose_obj_pt
@[simps]
def precompose {G : J ⥤ C} (α : G ⟶ F) : Cocone F ⥤ Cocone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : G ⟶ F) (c : CategoryTheory.Limits.Cocone F)
Goal: ((CategoryTheory.Limits.Cocones.precompose α).obj c).pt = c.pt
-- CategoryTheory.Limits.Cocones.precompose_obj_ι
@[simps]
def precompose {G : J ⥤ C} (α : G ⟶ F) : Cocone F ⥤ Cocone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : G ⟶ F) (c : CategoryTheory.Limits.Cocone F)
Goal: ((CategoryTheory.Limits.Cocones.precompose α).obj c).ι = α ≫ c.ι
-- CategoryTheory.Limits.Cocones.precomposeEquivalence_functor
@[simps]
def precomposeEquivalence {G : J ⥤ C} (α : G ≅ F) : Cocone F ≌ Cocone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : G ≅ F)
Goal: (CategoryTheory.Limits.Cocones.precomposeEquivalence α).functor = CategoryTheory.Limits.Cocones.precompose α.hom
-- CategoryTheory.Limits.Cocones.precomposeEquivalence_unitIso
@[simps]
def precomposeEquivalence {G : J ⥤ C} (α : G ≅ F) : Cocone F ≌ Cocone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : G ≅ F)
Goal: (CategoryTheory.Limits.Cocones.precomposeEquivalence α).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cocones.ext (CategoryTheory.Iso.refl ((𝟭 (CategoryTheory.Limits.Cocone F)).obj s).pt) ⋯)
    ⋯
-- CategoryTheory.Limits.Cocones.precomposeEquivalence_counitIso
@[simps]
def precomposeEquivalence {G : J ⥤ C} (α : G ≅ F) : Cocone F ≌ Cocone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : G ≅ F)
Goal: (CategoryTheory.Limits.Cocones.precomposeEquivalence α).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cocones.ext
        (CategoryTheory.Iso.refl
          ((CategoryTheory.Limits.Cocones.precompose α.inv ⋙ CategoryTheory.Limits.Cocones.precompose α.hom).obj s).pt)
        ⋯)
    ⋯
-- CategoryTheory.Limits.Cocones.precomposeEquivalence_inverse
@[simps]
def precomposeEquivalence {G : J ⥤ C} (α : G ≅ F) : Cocone F ≌ Cocone G 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (α : G ≅ F)
Goal: (CategoryTheory.Limits.Cocones.precomposeEquivalence α).inverse = CategoryTheory.Limits.Cocones.precompose α.inv
-- CategoryTheory.Limits.Cocones.whiskering_map_hom
@[simps]
def whiskering (E : K ⥤ J) : Cocone F ⥤ Cocone (E ⋙ F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (E : K ⥤ J)
Goal: ∀ {X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y), ((CategoryTheory.Limits.Cocones.whiskering E).map f).hom = f.hom
-- CategoryTheory.Limits.Cocones.whiskering_obj
@[simps]
def whiskering (E : K ⥤ J) : Cocone F ⥤ Cocone (E ⋙ F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [CategoryTheory.Category.{v₂, u₂} K] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (E : K ⥤ J) (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.Cocones.whiskering E).obj c = CategoryTheory.Limits.Cocone.whisker E c