ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.Cocones.whiskeringEquivalence_inverse
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cocone F ≌ Cocone (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.Cocones.whiskeringEquivalence e).inverse =
  CategoryTheory.Limits.Cocones.whiskering e.inverse ⋙
    CategoryTheory.Limits.Cocones.precompose
      (F.leftUnitor.inv ≫ CategoryTheory.whiskerRight e.counitIso.inv F ≫ (e.inverse.associator e.functor F).inv)
-- CategoryTheory.Limits.Cocones.whiskeringEquivalence_counitIso
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cocone F ≌ Cocone (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.Cocones.whiskeringEquivalence e).counitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cocones.ext
        (CategoryTheory.Iso.refl
          (((CategoryTheory.Limits.Cocones.whiskering e.inverse ⋙
                    CategoryTheory.Limits.Cocones.precompose
                      (F.leftUnitor.inv ≫
                        CategoryTheory.whiskerRight e.counitIso.inv F ≫ (e.inverse.associator e.functor F).inv)) ⋙
                  CategoryTheory.Limits.Cocones.whiskering e.functor).obj
              s).pt)
        ⋯)
    ⋯
-- CategoryTheory.Limits.Cocones.whiskeringEquivalence_functor
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cocone F ≌ Cocone (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.Cocones.whiskeringEquivalence e).functor = CategoryTheory.Limits.Cocones.whiskering e.functor
-- CategoryTheory.Limits.Cocones.whiskeringEquivalence_unitIso
@[simps]
def whiskeringEquivalence (e : K ≌ J) : Cocone F ≌ Cocone (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.Cocones.whiskeringEquivalence e).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun s =>
      CategoryTheory.Limits.Cocones.ext (CategoryTheory.Iso.refl ((𝟭 (CategoryTheory.Limits.Cocone F)).obj s).pt) ⋯)
    ⋯
-- CategoryTheory.Limits.Cocones.equivalenceOfReindexing_functor_obj
@[simps! functor_obj]
def equivalenceOfReindexing {G : K ⥤ C} (e : K ≌ J) (α : e.functor ⋙ F ≅ G) : Cocone F ≌ Cocone 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) (X : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.Cocones.equivalenceOfReindexing e α).functor.obj X =
  (CategoryTheory.Limits.Cocones.precompose α.inv).obj (CategoryTheory.Limits.Cocone.whisker e.functor X)
-- CategoryTheory.Limits.Cocones.forget_obj
@[simps]
def forget : Cocone 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.Cocone F)
Goal: (CategoryTheory.Limits.Cocones.forget F).obj t = t.pt
-- CategoryTheory.Limits.Cocones.forget_map
@[simps]
def forget : Cocone 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.Cocone F} (f : X ⟶ Y), (CategoryTheory.Limits.Cocones.forget F).map f = f.hom
-- CategoryTheory.Limits.Cocones.functoriality_obj_pt
@[simps]
def functoriality : Cocone F ⥤ Cocone (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.Cocone F)
Goal: ((CategoryTheory.Limits.Cocones.functoriality F G).obj A).pt = G.obj A.pt
-- CategoryTheory.Limits.Cocones.functoriality_map_hom
@[simps]
def functoriality : Cocone F ⥤ Cocone (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.Cocone F} (f : X ⟶ Y),
  ((CategoryTheory.Limits.Cocones.functoriality F G).map f).hom = G.map f.hom
-- CategoryTheory.Limits.Cocones.functoriality_obj_ι_app
@[simps]
def functoriality : Cocone F ⥤ Cocone (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.Cocone F) (j : J)
Goal: ((CategoryTheory.Limits.Cocones.functoriality F G).obj A).ι.app j = G.map (A.ι.app j)
-- CategoryTheory.Limits.Cocones.functorialityEquivalence_counitIso
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cocone F ≌ Cocone (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.Cocones.functorialityEquivalence F e).counitIso =
  CategoryTheory.NatIso.ofComponents (fun c => CategoryTheory.Limits.Cocones.ext (e.counitIso.app c.pt) ⋯) ⋯
-- CategoryTheory.Limits.Cocones.functorialityEquivalence_unitIso
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cocone F ≌ Cocone (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.Cocones.functorialityEquivalence F e).unitIso =
  CategoryTheory.NatIso.ofComponents
    (fun c => CategoryTheory.Limits.Cocones.ext (e.unitIso.app ((𝟭 (CategoryTheory.Limits.Cocone F)).obj c).1) ⋯) ⋯
-- CategoryTheory.Limits.Cocones.functorialityEquivalence_functor
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cocone F ≌ Cocone (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.Cocones.functorialityEquivalence F e).functor =
  CategoryTheory.Limits.Cocones.functoriality F e.functor
-- CategoryTheory.Limits.Cocones.functorialityEquivalence_inverse
@[simps]
def functorialityEquivalence (e : C ≌ D) : Cocone F ≌ Cocone (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.Cocones.functorialityEquivalence F e).inverse =
  CategoryTheory.Limits.Cocones.functoriality (F ⋙ e.functor) e.inverse ⋙
    (CategoryTheory.Limits.Cocones.precomposeEquivalence
        (F.associator e.functor e.inverse ≪≫
            CategoryTheory.isoWhiskerLeft F e.unitIso.symm ≪≫ F.rightUnitor).symm).functor
-- CategoryTheory.Functor.mapCone_pt
@[simps!]
def mapCone (c : Cone F) : Cone (F ⋙ H) 
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] (H : C ⥤ D) {F : J ⥤ C} (c : CategoryTheory.Limits.Cone F)
Goal: (H.mapCone c).pt = H.obj c.pt
-- CategoryTheory.Functor.mapCone_π_app
@[simps!]
def mapCone (c : Cone F) : Cone (F ⋙ H) 
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] (H : C ⥤ D) {F : J ⥤ C} (c : CategoryTheory.Limits.Cone F) (j : J)
Goal: (H.mapCone c).π.app j = H.map (c.π.app j)
-- CategoryTheory.Functor.mapCocone_pt
@[simps!]
def mapCocone (c : Cocone F) : Cocone (F ⋙ H) 
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] (H : C ⥤ D) {F : J ⥤ C} (c : CategoryTheory.Limits.Cocone F)
Goal: (H.mapCocone c).pt = H.obj c.pt
-- CategoryTheory.Functor.mapCocone_ι_app
@[simps!]
def mapCocone (c : Cocone F) : Cocone (F ⋙ H) 
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] (H : C ⥤ D) {F : J ⥤ C} (c : CategoryTheory.Limits.Cocone F) (j : J)
Goal: (H.mapCocone c).ι.app j = H.map (c.ι.app j)
-- CategoryTheory.Functor.functorialityCompPostcompose_inv_app_hom
@[simps!]
def functorialityCompPostcompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cones.functoriality F H ⋙ Cones.postcompose (whiskerLeft F α.hom) ≅ Cones.functoriality F H' 
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} {H H' : C ⥤ D} (α : H ≅ H') (X : CategoryTheory.Limits.Cone F)
Goal: ((CategoryTheory.Functor.functorialityCompPostcompose α).inv.app X).hom = α.inv.app X.pt
-- CategoryTheory.Functor.functorialityCompPostcompose_hom_app_hom
@[simps!]
def functorialityCompPostcompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cones.functoriality F H ⋙ Cones.postcompose (whiskerLeft F α.hom) ≅ Cones.functoriality F H' 
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} {H H' : C ⥤ D} (α : H ≅ H') (X : CategoryTheory.Limits.Cone F)
Goal: ((CategoryTheory.Functor.functorialityCompPostcompose α).hom.app X).hom = α.hom.app X.pt
-- CategoryTheory.Functor.postcomposeWhiskerLeftMapCone_hom_hom
@[simps!]
def postcomposeWhiskerLeftMapCone {H H' : C ⥤ D} (α : H ≅ H') (c : Cone F) :
    (Cones.postcompose (whiskerLeft F α.hom : _)).obj (mapCone H c) ≅ mapCone H' c 
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} {H H' : C ⥤ D} (α : H ≅ H') (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Functor.postcomposeWhiskerLeftMapCone α c).hom.hom = α.hom.app c.pt
-- CategoryTheory.Functor.postcomposeWhiskerLeftMapCone_inv_hom
@[simps!]
def postcomposeWhiskerLeftMapCone {H H' : C ⥤ D} (α : H ≅ H') (c : Cone F) :
    (Cones.postcompose (whiskerLeft F α.hom : _)).obj (mapCone H c) ≅ mapCone H' c 
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} {H H' : C ⥤ D} (α : H ≅ H') (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Functor.postcomposeWhiskerLeftMapCone α c).inv.hom = α.inv.app c.pt
-- CategoryTheory.Functor.mapConePostcompose_hom_hom
@[simps!]
def mapConePostcompose {α : F ⟶ G} {c} :
    mapCone H ((Cones.postcompose α).obj c) ≅
      (Cones.postcompose (whiskerRight α H : _)).obj (mapCone H c) 
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] (H : C ⥤ D) {F G : J ⥤ C} {α : F ⟶ G} {c : CategoryTheory.Limits.Cone F}
Goal: H.mapConePostcompose.hom.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.mapConePostcompose_inv_hom
@[simps!]
def mapConePostcompose {α : F ⟶ G} {c} :
    mapCone H ((Cones.postcompose α).obj c) ≅
      (Cones.postcompose (whiskerRight α H : _)).obj (mapCone H c) 
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] (H : C ⥤ D) {F G : J ⥤ C} {α : F ⟶ G} {c : CategoryTheory.Limits.Cone F}
Goal: H.mapConePostcompose.inv.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.mapConePostcomposeEquivalenceFunctor_hom_hom
@[simps!]
def mapConePostcomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCone H ((Cones.postcomposeEquivalence α).functor.obj c) ≅
      (Cones.postcomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCone H c) 
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] (H : C ⥤ D) {F G : J ⥤ C} {α : F ≅ G} {c : CategoryTheory.Limits.Cone F}
Goal: H.mapConePostcomposeEquivalenceFunctor.hom.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.mapConePostcomposeEquivalenceFunctor_inv_hom
@[simps!]
def mapConePostcomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCone H ((Cones.postcomposeEquivalence α).functor.obj c) ≅
      (Cones.postcomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCone H c) 
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] (H : C ⥤ D) {F G : J ⥤ C} {α : F ≅ G} {c : CategoryTheory.Limits.Cone F}
Goal: H.mapConePostcomposeEquivalenceFunctor.inv.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.functorialityCompPrecompose_hom_app_hom
@[simps!]
def functorialityCompPrecompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cocones.functoriality F H ⋙ Cocones.precompose (whiskerLeft F α.inv) ≅
      Cocones.functoriality F H' 
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} {H H' : C ⥤ D} (α : H ≅ H') (X : CategoryTheory.Limits.Cocone F)
Goal: ((CategoryTheory.Functor.functorialityCompPrecompose α).hom.app X).hom = α.hom.app X.pt
-- CategoryTheory.Functor.functorialityCompPrecompose_inv_app_hom
@[simps!]
def functorialityCompPrecompose {H H' : C ⥤ D} (α : H ≅ H') :
    Cocones.functoriality F H ⋙ Cocones.precompose (whiskerLeft F α.inv) ≅
      Cocones.functoriality F H' 
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} {H H' : C ⥤ D} (α : H ≅ H') (X : CategoryTheory.Limits.Cocone F)
Goal: ((CategoryTheory.Functor.functorialityCompPrecompose α).inv.app X).hom = α.inv.app X.pt
-- CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_inv_hom
@[simps!]
def precomposeWhiskerLeftMapCocone {H H' : C ⥤ D} (α : H ≅ H') (c : Cocone F) :
    (Cocones.precompose (whiskerLeft F α.inv : _)).obj (mapCocone H c) ≅ mapCocone H' c 
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} {H H' : C ⥤ D} (α : H ≅ H') (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Functor.precomposeWhiskerLeftMapCocone α c).inv.hom = α.inv.app c.pt
-- CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_hom_hom
@[simps!]
def precomposeWhiskerLeftMapCocone {H H' : C ⥤ D} (α : H ≅ H') (c : Cocone F) :
    (Cocones.precompose (whiskerLeft F α.inv : _)).obj (mapCocone H c) ≅ mapCocone H' c 
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} {H H' : C ⥤ D} (α : H ≅ H') (c : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Functor.precomposeWhiskerLeftMapCocone α c).hom.hom = α.hom.app c.pt
-- CategoryTheory.Functor.mapCoconePrecompose_inv_hom
@[simps!]
def mapCoconePrecompose {α : F ⟶ G} {c} :
    mapCocone H ((Cocones.precompose α).obj c) ≅
      (Cocones.precompose (whiskerRight α H : _)).obj (mapCocone H c) 
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] (H : C ⥤ D) {F G : J ⥤ C} {α : F ⟶ G} {c : CategoryTheory.Limits.Cocone G}
Goal: H.mapCoconePrecompose.inv.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.mapCoconePrecompose_hom_hom
@[simps!]
def mapCoconePrecompose {α : F ⟶ G} {c} :
    mapCocone H ((Cocones.precompose α).obj c) ≅
      (Cocones.precompose (whiskerRight α H : _)).obj (mapCocone H c) 
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] (H : C ⥤ D) {F G : J ⥤ C} {α : F ⟶ G} {c : CategoryTheory.Limits.Cocone G}
Goal: H.mapCoconePrecompose.hom.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.mapCoconePrecomposeEquivalenceFunctor_inv_hom
@[simps!]
def mapCoconePrecomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCocone H ((Cocones.precomposeEquivalence α).functor.obj c) ≅
      (Cocones.precomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCocone H c) 
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] (H : C ⥤ D) {F G : J ⥤ C} {α : F ≅ G} {c : CategoryTheory.Limits.Cocone G}
Goal: H.mapCoconePrecomposeEquivalenceFunctor.inv.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.mapCoconePrecomposeEquivalenceFunctor_hom_hom
@[simps!]
def mapCoconePrecomposeEquivalenceFunctor {α : F ≅ G} {c} :
    mapCocone H ((Cocones.precomposeEquivalence α).functor.obj c) ≅
      (Cocones.precomposeEquivalence (isoWhiskerRight α H : _)).functor.obj (mapCocone H c) 
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] (H : C ⥤ D) {F G : J ⥤ C} {α : F ≅ G} {c : CategoryTheory.Limits.Cocone G}
Goal: H.mapCoconePrecomposeEquivalenceFunctor.hom.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.mapConeWhisker_inv_hom
@[simps!]
def mapConeWhisker {E : K ⥤ J} {c : Cone F} : mapCone H (c.whisker E) ≅ (mapCone H c).whisker E 
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] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (H : C ⥤ D) {F : J ⥤ C} {E : K ⥤ J} {c : CategoryTheory.Limits.Cone F}
Goal: H.mapConeWhisker.inv.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.mapConeWhisker_hom_hom
@[simps!]
def mapConeWhisker {E : K ⥤ J} {c : Cone F} : mapCone H (c.whisker E) ≅ (mapCone H c).whisker E 
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] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (H : C ⥤ D) {F : J ⥤ C} {E : K ⥤ J} {c : CategoryTheory.Limits.Cone F}
Goal: H.mapConeWhisker.hom.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.mapCoconeWhisker_hom_hom
@[simps!]
def mapCoconeWhisker {E : K ⥤ J} {c : Cocone F} :
    mapCocone H (c.whisker E) ≅ (mapCocone H c).whisker E 
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] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (H : C ⥤ D) {F : J ⥤ C} {E : K ⥤ J} {c : CategoryTheory.Limits.Cocone F}
Goal: H.mapCoconeWhisker.hom.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Functor.mapCoconeWhisker_inv_hom
@[simps!]
def mapCoconeWhisker {E : K ⥤ J} {c : Cocone F} :
    mapCocone H (c.whisker E) ≅ (mapCocone H c).whisker E 
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] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (H : C ⥤ D) {F : J ⥤ C} {E : K ⥤ J} {c : CategoryTheory.Limits.Cocone F}
Goal: H.mapCoconeWhisker.inv.hom = 𝟙 (H.obj c.pt)
-- CategoryTheory.Limits.Cocone.op_pt
@[simps]
def Cocone.op (c : Cocone F) : Cone F.op 
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: c.op.pt = Opposite.op c.pt
-- CategoryTheory.Limits.Cocone.op_π
@[simps]
def Cocone.op (c : Cocone F) : Cone F.op 
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: c.op.π = CategoryTheory.NatTrans.op c.ι
-- CategoryTheory.Limits.Cone.op_ι
@[simps]
def Cone.op (c : Cone F) : Cocone F.op 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (c : CategoryTheory.Limits.Cone F)
Goal: c.op.ι = CategoryTheory.NatTrans.op c.π
-- CategoryTheory.Limits.Cone.op_pt
@[simps]
def Cone.op (c : Cone F) : Cocone F.op 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (c : CategoryTheory.Limits.Cone F)
Goal: c.op.pt = Opposite.op c.pt
-- CategoryTheory.Limits.Cocone.unop_π
@[simps]
def Cocone.unop (c : Cocone F.op) : Cone F 
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.op)
Goal: c.unop.π = CategoryTheory.NatTrans.removeOp c.ι
-- CategoryTheory.Limits.Cocone.unop_pt
@[simps]
def Cocone.unop (c : Cocone F.op) : Cone F 
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.op)
Goal: c.unop.pt = Opposite.unop c.pt
-- CategoryTheory.Limits.Cone.unop_pt
@[simps]
def Cone.unop (c : Cone F.op) : Cocone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (c : CategoryTheory.Limits.Cone F.op)
Goal: c.unop.pt = Opposite.unop c.pt
-- CategoryTheory.Limits.Cone.unop_ι
@[simps]
def Cone.unop (c : Cone F.op) : Cocone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (c : CategoryTheory.Limits.Cone F.op)
Goal: c.unop.ι = CategoryTheory.NatTrans.removeOp c.π
-- CategoryTheory.Limits.coneOfCoconeLeftOp_pt
@[simps!]
def coneOfCoconeLeftOp (c : Cocone F.leftOp) : Cone F 
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.leftOp)
Goal: (CategoryTheory.Limits.coneOfCoconeLeftOp c).pt = Opposite.op c.pt
-- CategoryTheory.Limits.coneOfCoconeLeftOp_π_app
@[simps!]
def coneOfCoconeLeftOp (c : Cocone F.leftOp) : Cone F 
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.leftOp) (X : J)
Goal: (CategoryTheory.Limits.coneOfCoconeLeftOp c).π.app X = (c.ι.app (Opposite.op X)).op
-- CategoryTheory.Limits.coconeLeftOpOfCone_ι_app
@[simps!]
def coconeLeftOpOfCone (c : Cone F) : Cocone F.leftOp 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cone F) (X : Jᵒᵖ)
Goal: (CategoryTheory.Limits.coconeLeftOpOfCone c).ι.app X = (c.π.app (Opposite.unop X)).unop
-- CategoryTheory.Limits.coconeLeftOpOfCone_pt
@[simps!]
def coconeLeftOpOfCone (c : Cone F) : Cocone F.leftOp 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.coconeLeftOpOfCone c).pt = Opposite.unop c.pt
-- CategoryTheory.Limits.coconeOfConeLeftOp_pt
@[simps pt]
def coconeOfConeLeftOp (c : Cone F.leftOp) : Cocone F 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ Cᵒᵖ} (c : CategoryTheory.Limits.Cone F.leftOp)
Goal: (CategoryTheory.Limits.coconeOfConeLeftOp c).pt = Opposite.op c.pt