ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.LiftAdjoint.constructLeftAdjointEquiv_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 : CategoryTheory.LiftAdjoint.constructLeftAdjointObj R F' adj₁ adj₂ X ⟶ Y),
  (CategoryTheory.LiftAdjoint.constructLeftAdjointEquiv R F' adj₁ adj₂ Y X) a =
    (CategoryTheory.Limits.Cofork.IsColimit.homIso (CategoryTheory.LiftAdjoint.counitCoequalises adj₁ X) (R.obj Y)).symm
      ⟨CategoryTheory.CategoryStruct.comp
          (F.map
            ((adj₂.homEquiv (U.obj X) Y)
              ↑((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)
                  a)))
          (adj₁.counit.app (R.obj Y)),
        ⋯⟩
-- CategoryTheory.adjointTriangleLift
lemma adjointTriangleLift {U : B ⥤ C} {F : C ⥤ B} (R : A ⥤ B) (adj₁ : F ⊣ U)
    [∀ X : B, RegularEpi (adj₁.counit.app X)] [HasReflexiveCoequalizers A]
    [(R ⋙ U).IsRightAdjoint ] : R.IsRightAdjoint 
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) (adj₁ : F ⊣ U) [(X : B) → CategoryTheory.RegularEpi (adj₁.counit.app X)] [CategoryTheory.Limits.HasReflexiveCoequalizers A] [(R.comp U).IsRightAdjoint]
Goal: R.IsRightAdjoint
-- CategoryTheory.monadicAdjointTriangleLift
lemma monadicAdjointTriangleLift (U : B ⥤ C) [MonadicRightAdjoint U] {R : A ⥤ B}
    [HasReflexiveCoequalizers A] [(R ⋙ U).IsRightAdjoint] : R.IsRightAdjoint 
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) [CategoryTheory.MonadicRightAdjoint U] {R : CategoryTheory.Functor A B} [CategoryTheory.Limits.HasReflexiveCoequalizers A] [(R.comp U).IsRightAdjoint]
Goal: R.IsRightAdjoint
-- CategoryTheory.adjointSquareLift
lemma adjointSquareLift (Q : A ⥤ B) (V : B ⥤ D) (U : A ⥤ C) (R : C ⥤ D)
    (comm : U ⋙ R ≅ Q ⋙ V) [U.IsRightAdjoint] [V.IsRightAdjoint] [R.IsRightAdjoint]
    [∀ X, RegularEpi ((Adjunction.ofIsRightAdjoint V).counit.app X)] [HasReflexiveCoequalizers A] :
    Q.IsRightAdjoint 
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] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (Q : CategoryTheory.Functor A B) (V : CategoryTheory.Functor B D) (U : CategoryTheory.Functor A C) (R : CategoryTheory.Functor C D) (comm : U.comp R ≅ Q.comp V) [U.IsRightAdjoint] [V.IsRightAdjoint] [R.IsRightAdjoint] [(X : B) → CategoryTheory.RegularEpi ((CategoryTheory.Adjunction.ofIsRightAdjoint V).counit.app X)] [CategoryTheory.Limits.HasReflexiveCoequalizers A]
Goal: Q.IsRightAdjoint
-- CategoryTheory.monadicAdjointSquareLift
lemma monadicAdjointSquareLift (Q : A ⥤ B) (V : B ⥤ D) (U : A ⥤ C) (R : C ⥤ D)
    (comm : U ⋙ R ≅ Q ⋙ V) [U.IsRightAdjoint] [MonadicRightAdjoint V] [R.IsRightAdjoint]
    [HasReflexiveCoequalizers A] : Q.IsRightAdjoint 
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] {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] (Q : CategoryTheory.Functor A B) (V : CategoryTheory.Functor B D) (U : CategoryTheory.Functor A C) (R : CategoryTheory.Functor C D) (comm : U.comp R ≅ Q.comp V) [U.IsRightAdjoint] [CategoryTheory.MonadicRightAdjoint V] [R.IsRightAdjoint] [CategoryTheory.Limits.HasReflexiveCoequalizers A]
Goal: Q.IsRightAdjoint
-- CategoryTheory.Limits.comp_lim_obj_ext
@[ext] lemma comp_lim_obj_ext {j : J} {G : J ⥤ K ⥤ Type v} (x y : (G ⋙ lim).obj j)
    (w : ∀ (k : K), limit.π (G.obj j) k x = limit.π (G.obj j) k y) : x = y 
Arguments: {J : Type u₁} {K : Type u₂} [CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.Category.{v₂, u₂} K] [Small.{v, u₂} K] {j : J} {G : J ⥤ K ⥤ Type v} (x y : (G ⋙ CategoryTheory.Limits.lim).obj j) (w : ∀ (k : K), CategoryTheory.Limits.limit.π (G.obj j) k x = CategoryTheory.Limits.limit.π (G.obj j) k y)
Goal: x = y
-- CategoryTheory.Limits.colimitLimitToLimitColimit_injective
theorem colimitLimitToLimitColimit_injective :
    Function.Injective (colimitLimitToLimitColimit F) 
Arguments: {J : Type u₁} {K : Type u₂} [CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.Category.{v₂, u₂} K] [Small.{v, u₂} K] (F : J × K ⥤ Type v) [CategoryTheory.IsFiltered K] [Finite J]
Goal: Function.Injective (CategoryTheory.Limits.colimitLimitToLimitColimit F)
-- CategoryTheory.Limits.colimitLimitToLimitColimit_surjective
theorem colimitLimitToLimitColimit_surjective :
    Function.Surjective (colimitLimitToLimitColimit F) 
Arguments: {J : Type u₁} {K : Type u₂} [CategoryTheory.SmallCategory J] [CategoryTheory.Category.{v₂, u₂} K] [Small.{v, u₂} K] [CategoryTheory.FinCategory J] (F : J × K ⥤ Type v) [CategoryTheory.IsFiltered K]
Goal: Function.Surjective (CategoryTheory.Limits.colimitLimitToLimitColimit F)
-- CategoryTheory.Limits.ι_colimitLimitIso_limit_π
@[reassoc (attr := simp)]
theorem ι_colimitLimitIso_limit_π (F : J ⥤ K ⥤ C) (a) (b) :
    colimit.ι (limit F) a ≫ (colimitLimitIso F).hom ≫ limit.π (colimit F.flip) b =
      (limit.π F b).app a ≫ (colimit.ι F.flip a).app b 
Arguments: {J : Type u₁} {K : Type u₂} [CategoryTheory.SmallCategory J] [CategoryTheory.Category.{v₂, u₂} K] [Small.{v, u₂} K] [CategoryTheory.FinCategory J] [CategoryTheory.IsFiltered K] {C : Type u} [CategoryTheory.Category.{v, u} C] [CategoryTheory.ConcreteCategory C] [CategoryTheory.Limits.HasLimitsOfShape J C] [CategoryTheory.Limits.HasColimitsOfShape K C] [CategoryTheory.Limits.ReflectsLimitsOfShape J (CategoryTheory.forget C)] [CategoryTheory.Limits.PreservesColimitsOfShape K (CategoryTheory.forget C)] [CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.forget C)] (F : J ⥤ K ⥤ C) (a : K) (b : J)
Goal: CategoryTheory.Limits.colimit.ι (CategoryTheory.Limits.limit F) a ≫
    (CategoryTheory.Limits.colimitLimitIso F).hom ≫
      CategoryTheory.Limits.limit.π (CategoryTheory.Limits.colimit F.flip) b =
  (CategoryTheory.Limits.limit.π F b).app a ≫ (CategoryTheory.Limits.colimit.ι F.flip a).app b
-- CategoryTheory.Functor.cones_map_app
@[simps!]
def cones : Cᵒᵖ ⥤ Type max u₁ v₃ 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : J ⥤ C)
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (a : (CategoryTheory.yoneda.obj F).obj ((CategoryTheory.Functor.const J).op.obj X)) (X_1 : J),
  (F.cones.map f a).app X_1 = f.unop ≫ a.app X_1
-- CategoryTheory.Functor.cones_obj
@[simps!]
def cones : Cᵒᵖ ⥤ Type max u₁ v₃ 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : J ⥤ C) (X : Cᵒᵖ)
Goal: F.cones.obj X = ((CategoryTheory.Functor.const J).obj (Opposite.unop X) ⟶ F)
-- CategoryTheory.Functor.cocones_map_app
@[simps!]
def cocones : C ⥤ Type max u₁ v₃ 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : J ⥤ C)
Goal: ∀ {X Y : C} (f : X ⟶ Y) (a : (CategoryTheory.coyoneda.obj (Opposite.op F)).obj ((CategoryTheory.Functor.const J).obj X))
  (X_1 : J), (F.cocones.map f a).app X_1 = a.app X_1 ≫ f
-- CategoryTheory.Functor.cocones_obj
@[simps!]
def cocones : C ⥤ Type max u₁ v₃ 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : J ⥤ C) (X : C)
Goal: F.cocones.obj X = (F ⟶ (CategoryTheory.Functor.const J).obj X)
-- CategoryTheory.cones_map_app_app
@[simps!]
def cones : (J ⥤ C) ⥤ Cᵒᵖ ⥤ Type max u₁ v₃ 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C]
Goal: ∀ {X Y : J ⥤ C} (f : X ⟶ Y) (X_1 : Cᵒᵖ)
  (a : (CategoryTheory.yoneda.obj X).obj ((CategoryTheory.Functor.const J).op.obj X_1)) (X_2 : J),
  (((CategoryTheory.cones J C).map f).app X_1 a).app X_2 = a.app X_2 ≫ f.app X_2
-- CategoryTheory.cones_obj_map_app
@[simps!]
def cones : (J ⥤ C) ⥤ Cᵒᵖ ⥤ Type max u₁ v₃ 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (F : J ⥤ C)
Goal: ∀ {X Y : Cᵒᵖ} (f : X ⟶ Y) (a : (CategoryTheory.yoneda.obj F).obj ((CategoryTheory.Functor.const J).op.obj X)) (X_1 : J),
  (((CategoryTheory.cones J C).obj F).map f a).app X_1 = f.unop ≫ a.app X_1
-- CategoryTheory.cones_obj_obj
@[simps!]
def cones : (J ⥤ C) ⥤ Cᵒᵖ ⥤ Type max u₁ v₃ 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (F : J ⥤ C) (X : Cᵒᵖ)
Goal: ((CategoryTheory.cones J C).obj F).obj X = ((CategoryTheory.Functor.const J).obj (Opposite.unop X) ⟶ F)
-- CategoryTheory.cocones_map_app_app
@[simps!]
def cocones : (J ⥤ C)ᵒᵖ ⥤ C ⥤ Type max u₁ v₃ 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C]
Goal: ∀ {X Y : (J ⥤ C)ᵒᵖ} (f : X ⟶ Y) (X_1 : C)
  (a : (CategoryTheory.coyoneda.obj X).obj ((CategoryTheory.Functor.const J).obj X_1)) (X_2 : J),
  (((CategoryTheory.cocones J C).map f).app X_1 a).app X_2 = f.unop.app X_2 ≫ a.app X_2
-- CategoryTheory.cocones_obj_map_app
@[simps!]
def cocones : (J ⥤ C)ᵒᵖ ⥤ C ⥤ Type max u₁ v₃ 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (F : (J ⥤ C)ᵒᵖ)
Goal: ∀ {X Y : C} (f : X ⟶ Y)
  (a : (CategoryTheory.coyoneda.obj (Opposite.op (Opposite.unop F))).obj ((CategoryTheory.Functor.const J).obj X))
  (X_1 : J), (((CategoryTheory.cocones J C).obj F).map f a).app X_1 = a.app X_1 ≫ f
-- CategoryTheory.cocones_obj_obj
@[simps!]
def cocones : (J ⥤ C)ᵒᵖ ⥤ C ⥤ Type max u₁ v₃ 
Arguments: (J : Type u₁) [CategoryTheory.Category.{v₁, u₁} J] (C : Type u₃) [CategoryTheory.Category.{v₃, u₃} C] (F : (J ⥤ C)ᵒᵖ) (X : C)
Goal: ((CategoryTheory.cocones J C).obj F).obj X = (Opposite.unop F ⟶ (CategoryTheory.Functor.const J).obj X)
-- CategoryTheory.Limits.Cone.w
@[reassoc (attr := simp)]
theorem Cone.w {F : J ⥤ C} (c : Cone F) {j j' : J} (f : j ⟶ j') :
    c.π.app j ≫ F.map f = c.π.app j' 
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) {j j' : J} (f : j ⟶ j')
Goal: c.π.app j ≫ F.map f = c.π.app j'
-- CategoryTheory.Limits.Cocone.w
@[reassoc] -- @[simp] -- Porting note (#10618): simp can prove this
theorem Cocone.w {F : J ⥤ C} (c : Cocone F) {j j' : J} (f : j ⟶ j') :
    F.map f ≫ c.ι.app j' = c.ι.app j 
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) {j j' : J} (f : j ⟶ j')
Goal: F.map f ≫ c.ι.app j' = c.ι.app j
-- CategoryTheory.Limits.Cone.equiv_hom_snd
@[simps!]
def equiv (F : J ⥤ C) : Cone F ≅ ΣX, F.cones.obj X 
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.Cone.equiv F).hom c).snd = c.π
-- CategoryTheory.Limits.Cone.equiv_inv_π
@[simps!]
def equiv (F : J ⥤ C) : Cone F ≅ ΣX, F.cones.obj X 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : J ⥤ C) (c : (X : Cᵒᵖ) × F.cones.obj X)
Goal: ((CategoryTheory.Limits.Cone.equiv F).inv c).π = c.snd
-- CategoryTheory.Limits.Cone.equiv_inv_pt
@[simps!]
def equiv (F : J ⥤ C) : Cone F ≅ ΣX, F.cones.obj X 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] (F : J ⥤ C) (c : (X : Cᵒᵖ) × F.cones.obj X)
Goal: ((CategoryTheory.Limits.Cone.equiv F).inv c).pt = Opposite.unop c.fst
-- CategoryTheory.Limits.Cone.equiv_hom_fst
@[simps!]
def equiv (F : J ⥤ C) : Cone F ≅ ΣX, F.cones.obj X 
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.Cone.equiv F).hom c).fst = Opposite.op c.pt
-- CategoryTheory.Limits.Cone.extensions_app
@[simps]
def extensions (c : Cone F) : yoneda.obj c.pt ⋙ uliftFunctor.{u₁} ⟶ F.cones 
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 : Cᵒᵖ) (f : (CategoryTheory.yoneda.obj c.pt ⋙ CategoryTheory.uliftFunctor.{u₁, v₃}).obj X)
Goal: c.extensions.app X f = (CategoryTheory.Functor.const J).map f.down ≫ c.π
-- CategoryTheory.Limits.Cone.extend_π
@[simps]
def extend (c : Cone F) {X : C} (f : X ⟶ c.pt) : 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.Cone F) {X : C} (f : X ⟶ c.pt)
Goal: (c.extend f).π = c.extensions.app (Opposite.op X) { down := f }
-- CategoryTheory.Limits.Cone.extend_pt
@[simps]
def extend (c : Cone F) {X : C} (f : X ⟶ c.pt) : 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.Cone F) {X : C} (f : X ⟶ c.pt)
Goal: (c.extend f).pt = X
-- CategoryTheory.Limits.Cone.whisker_π
@[simps]
def whisker (E : K ⥤ J) (c : 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.Cone.whisker E c).π = CategoryTheory.whiskerLeft E c.π
-- CategoryTheory.Limits.Cone.whisker_pt
@[simps]
def whisker (E : K ⥤ J) (c : 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.Cone.whisker E c).pt = c.pt
-- CategoryTheory.Limits.Cocone.extensions_app
@[simps]
def extensions (c : Cocone F) : coyoneda.obj (op c.pt) ⋙ uliftFunctor.{u₁} ⟶ F.cocones 
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) (X : C) (f : (CategoryTheory.coyoneda.obj (Opposite.op c.pt) ⋙ CategoryTheory.uliftFunctor.{u₁, v₃}).obj X)
Goal: c.extensions.app X f = c.ι ≫ (CategoryTheory.Functor.const J).map f.down
-- CategoryTheory.Limits.Cocone.extend_ι
@[simps]
def extend (c : Cocone F) {Y : C} (f : c.pt ⟶ Y) : 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.Cocone F) {Y : C} (f : c.pt ⟶ Y)
Goal: (c.extend f).ι = c.extensions.app Y { down := f }
-- CategoryTheory.Limits.Cocone.extend_pt
@[simps]
def extend (c : Cocone F) {Y : C} (f : c.pt ⟶ Y) : 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.Cocone F) {Y : C} (f : c.pt ⟶ Y)
Goal: (c.extend f).pt = Y
-- CategoryTheory.Limits.Cocone.whisker_ι
@[simps]
def whisker (E : K ⥤ J) (c : 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.Cocone.whisker E c).ι = CategoryTheory.whiskerLeft E c.ι
-- CategoryTheory.Limits.Cocone.whisker_pt
@[simps]
def whisker (E : K ⥤ J) (c : 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.Cocone.whisker E c).pt = c.pt
-- CategoryTheory.Limits.ConeMorphism.w
structure ConeMorphism (A B : Cone F) where
    hom : A.pt ⟶ B.pt
    w : ∀ j : J, hom ≫ B.π.app j = A.π.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.Cone F} (self : CategoryTheory.Limits.ConeMorphism A B) (j : J)
Goal: self.hom ≫ B.π.app j = A.π.app j
-- CategoryTheory.Limits.Cone.category_id_hom
@[simps]
instance Cone.category : Category (Cone F) 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (B : CategoryTheory.Limits.Cone F)
Goal: (𝟙 B).hom = 𝟙 B.pt
-- CategoryTheory.Limits.Cone.category_comp_hom
@[simps]
instance Cone.category : Category (Cone 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.Cone F} (f : X ⟶ Y) (g : Y ⟶ Z), (f ≫ g).hom = f.hom ≫ g.hom
-- CategoryTheory.Limits.ConeMorphism.ext
@[ext]
theorem ConeMorphism.ext {c c' : Cone 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.Cone F} (f g : c ⟶ c') (w : f.hom = g.hom)
Goal: f = g
-- CategoryTheory.Limits.Cones.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' : Cone 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.Cone F} (φ : c.pt ≅ c'.pt) (w : ∀ (j : J), c.π.app j = φ.hom ≫ c'.π.app j := by aesop_cat)
Goal: (CategoryTheory.Limits.Cones.ext φ w).hom.hom = φ.hom
-- CategoryTheory.Limits.Cones.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' : Cone 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.Cone F} (φ : c.pt ≅ c'.pt) (w : ∀ (j : J), c.π.app j = φ.hom ≫ c'.π.app j := by aesop_cat)
Goal: (CategoryTheory.Limits.Cones.ext φ w).inv.hom = φ.inv
-- CategoryTheory.Limits.Cones.eta_inv_hom
@[simps!]
def eta (c : Cone 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.Cone F)
Goal: (CategoryTheory.Limits.Cones.eta c).inv.hom = 𝟙 c.pt
-- CategoryTheory.Limits.Cones.eta_hom_hom
@[simps!]
def eta (c : Cone 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.Cone F)
Goal: (CategoryTheory.Limits.Cones.eta c).hom.hom = 𝟙 c.pt
-- CategoryTheory.Limits.Cones.cone_iso_of_hom_iso
theorem cone_iso_of_hom_iso {K : J ⥤ C} {c d : Cone 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.Cone K} (f : c ⟶ d) [i : CategoryTheory.IsIso f.hom]
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Limits.Cones.extend_hom
@[simps]
def extend (s : Cone F) {X : C} (f : X ⟶ s.pt) : s.extend f ⟶ s 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cone F) {X : C} (f : X ⟶ s.pt)
Goal: (CategoryTheory.Limits.Cones.extend s f).hom = f
-- CategoryTheory.Limits.Cones.extendId_hom_hom
@[simps!]
def extendId (s : Cone F) : s.extend (𝟙 s.pt) ≅ s 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.Cones.extendId s).hom.hom = 𝟙 s.pt
-- CategoryTheory.Limits.Cones.extendId_inv_hom
@[simps!]
def extendId (s : Cone F) : s.extend (𝟙 s.pt) ≅ s 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.Cones.extendId s).inv.hom = 𝟙 s.pt
-- CategoryTheory.Limits.Cones.extendComp_inv_hom
@[simps!]
def extendComp (s : Cone F) {X Y : C} (f : X ⟶ Y) (g : Y ⟶ s.pt) :
    s.extend (f ≫ g) ≅ (s.extend g).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.Cone F) {X Y : C} (f : X ⟶ Y) (g : Y ⟶ s.pt)
Goal: (CategoryTheory.Limits.Cones.extendComp s f g).inv.hom = 𝟙 X
-- CategoryTheory.Limits.Cones.extendComp_hom_hom
@[simps!]
def extendComp (s : Cone F) {X Y : C} (f : X ⟶ Y) (g : Y ⟶ s.pt) :
    s.extend (f ≫ g) ≅ (s.extend g).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.Cone F) {X Y : C} (f : X ⟶ Y) (g : Y ⟶ s.pt)
Goal: (CategoryTheory.Limits.Cones.extendComp s f g).hom.hom = 𝟙 X
-- CategoryTheory.Limits.Cones.extendIso_hom_hom
@[simps]
def extendIso (s : Cone F) {X : C} (f : X ≅ s.pt) : s.extend f.hom ≅ s 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cone F) {X : C} (f : X ≅ s.pt)
Goal: (CategoryTheory.Limits.Cones.extendIso s f).hom.hom = f.hom
-- CategoryTheory.Limits.Cones.extendIso_inv_hom
@[simps]
def extendIso (s : Cone F) {X : C} (f : X ≅ s.pt) : s.extend f.hom ≅ s 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} (s : CategoryTheory.Limits.Cone F) {X : C} (f : X ≅ s.pt)
Goal: (CategoryTheory.Limits.Cones.extendIso s f).inv.hom = f.inv
-- CategoryTheory.Limits.Cones.postcompose_obj_pt
@[simps]
def postcompose {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) (c : CategoryTheory.Limits.Cone F)
Goal: ((CategoryTheory.Limits.Cones.postcompose α).obj c).pt = c.pt
-- CategoryTheory.Limits.Cones.postcompose_obj_π
@[simps]
def postcompose {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) (c : CategoryTheory.Limits.Cone F)
Goal: ((CategoryTheory.Limits.Cones.postcompose α).obj c).π = c.π ≫ α
-- CategoryTheory.Limits.Cones.postcompose_map_hom
@[simps]
def postcompose {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: ∀ {X Y : CategoryTheory.Limits.Cone F} (f : X ⟶ Y), ((CategoryTheory.Limits.Cones.postcompose α).map f).hom = f.hom