ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.IsLimit.map_π
@[reassoc (attr := simp)]
theorem map_π {F G : J ⥤ C} (c : Cone F) {d : Cone G} (hd : IsLimit d) (α : F ⟶ G) (j : J) :
    hd.map c α ≫ d.π.app j = c.π.app j ≫ α.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} (c : CategoryTheory.Limits.Cone F) {d : CategoryTheory.Limits.Cone G} (hd : CategoryTheory.Limits.IsLimit d) (α : F ⟶ G) (j : J)
Goal: CategoryTheory.Limits.IsLimit.map c hd α ≫ d.π.app j = c.π.app j ≫ α.app j
-- CategoryTheory.Limits.IsLimit.lift_self
@[simp]
theorem lift_self {c : Cone F} (t : IsLimit c) : t.lift c = 𝟙 c.pt 
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} (t : CategoryTheory.Limits.IsLimit c)
Goal: t.lift c = 𝟙 c.pt
-- CategoryTheory.Limits.IsLimit.liftConeMorphism_hom
@[simps]
def liftConeMorphism {t : Cone F} (h : IsLimit t) (s : Cone F) : s ⟶ t 
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} (h : CategoryTheory.Limits.IsLimit t) (s : CategoryTheory.Limits.Cone F)
Goal: (h.liftConeMorphism s).hom = h.lift s
-- CategoryTheory.Limits.IsLimit.uniq_cone_morphism
theorem uniq_cone_morphism {s t : Cone F} (h : IsLimit t) {f f' : s ⟶ t} : f = f' 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cone F} (h : CategoryTheory.Limits.IsLimit t) {f f' : s ⟶ t}
Goal: f = f'
-- CategoryTheory.Limits.IsLimit.existsUnique
theorem existsUnique {t : Cone F} (h : IsLimit t) (s : Cone F) :
    ∃! l : s.pt ⟶ t.pt, ∀ j, l ≫ t.π.app j = s.π.app j 
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} (h : CategoryTheory.Limits.IsLimit t) (s : CategoryTheory.Limits.Cone F)
Goal: ∃! l, ∀ (j : J), l ≫ t.π.app j = s.π.app j
-- CategoryTheory.Limits.IsLimit.mkConeMorphism_lift
@[simps]
def mkConeMorphism {t : Cone F} (lift : ∀ s : Cone F, s ⟶ t)
    (uniq : ∀ (s : Cone F) (m : s ⟶ t), m = lift s) : IsLimit t 
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} (lift : (s : CategoryTheory.Limits.Cone F) → s ⟶ t) (uniq : ∀ (s : CategoryTheory.Limits.Cone F) (m : s ⟶ t), m = lift s) (s : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.IsLimit.mkConeMorphism lift uniq).lift s = (lift s).hom
-- CategoryTheory.Limits.IsLimit.uniqueUpToIso_hom
@[simps]
def uniqueUpToIso {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) : s ≅ t 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t)
Goal: (P.uniqueUpToIso Q).hom = Q.liftConeMorphism s
-- CategoryTheory.Limits.IsLimit.uniqueUpToIso_inv
@[simps]
def uniqueUpToIso {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) : s ≅ t 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t)
Goal: (P.uniqueUpToIso Q).inv = P.liftConeMorphism t
-- CategoryTheory.Limits.IsLimit.hom_isIso
theorem hom_isIso {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) (f : s ⟶ t) : IsIso f 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (f : s ⟶ t)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_hom_comp
@[reassoc (attr := simp)]
theorem conePointUniqueUpToIso_hom_comp {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) (j : J) :
    (conePointUniqueUpToIso P Q).hom ≫ t.π.app j = s.π.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (j : J)
Goal: (P.conePointUniqueUpToIso Q).hom ≫ t.π.app j = s.π.app j
-- CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_inv_comp
@[reassoc (attr := simp)]
theorem conePointUniqueUpToIso_inv_comp {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) (j : J) :
    (conePointUniqueUpToIso P Q).inv ≫ s.π.app j = t.π.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (j : J)
Goal: (P.conePointUniqueUpToIso Q).inv ≫ s.π.app j = t.π.app j
-- CategoryTheory.Limits.IsLimit.lift_comp_conePointUniqueUpToIso_hom
@[reassoc (attr := simp)]
theorem lift_comp_conePointUniqueUpToIso_hom {r s t : Cone F} (P : IsLimit s) (Q : IsLimit t) :
    P.lift r ≫ (conePointUniqueUpToIso P Q).hom = Q.lift r 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {r s t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t)
Goal: P.lift r ≫ (P.conePointUniqueUpToIso Q).hom = Q.lift r
-- CategoryTheory.Limits.IsLimit.lift_comp_conePointUniqueUpToIso_inv
@[reassoc (attr := simp)]
theorem lift_comp_conePointUniqueUpToIso_inv {r s t : Cone F} (P : IsLimit s) (Q : IsLimit t) :
    Q.lift r ≫ (conePointUniqueUpToIso P Q).inv = P.lift r 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {r s t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t)
Goal: Q.lift r ≫ (P.conePointUniqueUpToIso Q).inv = P.lift r
-- CategoryTheory.Limits.IsLimit.ofIsoLimit_lift
@[simp]
theorem ofIsoLimit_lift {r t : Cone F} (P : IsLimit r) (i : r ≅ t) (s) :
    (P.ofIsoLimit i).lift s = P.lift s ≫ i.hom.hom 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {r t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit r) (i : r ≅ t) (s : CategoryTheory.Limits.Cone F)
Goal: (P.ofIsoLimit i).lift s = P.lift s ≫ i.hom.hom
-- CategoryTheory.Limits.IsLimit.equivIsoLimit_apply
@[simp]
theorem equivIsoLimit_apply {r t : Cone F} (i : r ≅ t) (P : IsLimit r) :
    equivIsoLimit i P = P.ofIsoLimit i 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {r t : CategoryTheory.Limits.Cone F} (i : r ≅ t) (P : CategoryTheory.Limits.IsLimit r)
Goal: (CategoryTheory.Limits.IsLimit.equivIsoLimit i) P = P.ofIsoLimit i
-- CategoryTheory.Limits.IsLimit.equivIsoLimit_symm_apply
@[simp]
theorem equivIsoLimit_symm_apply {r t : Cone F} (i : r ≅ t) (P : IsLimit t) :
    (equivIsoLimit i).symm P = P.ofIsoLimit i.symm 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {r t : CategoryTheory.Limits.Cone F} (i : r ≅ t) (P : CategoryTheory.Limits.IsLimit t)
Goal: (CategoryTheory.Limits.IsLimit.equivIsoLimit i).symm P = P.ofIsoLimit i.symm
-- CategoryTheory.Limits.IsLimit.hom_lift
theorem hom_lift (h : IsLimit t) {W : C} (m : W ⟶ t.pt) :
    m = h.lift { pt := W, π := { app := fun b => m ≫ t.π.app b } } 
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} (h : CategoryTheory.Limits.IsLimit t) {W : C} (m : W ⟶ t.pt)
Goal: m = h.lift { pt := W, π := { app := fun b => m ≫ t.π.app b, naturality := ⋯ } }
-- CategoryTheory.Limits.IsLimit.hom_ext
theorem hom_ext (h : IsLimit t) {W : C} {f f' : W ⟶ t.pt}
    (w : ∀ j, f ≫ t.π.app j = f' ≫ t.π.app j) :
    f = f' 
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} (h : CategoryTheory.Limits.IsLimit t) {W : C} {f f' : W ⟶ t.pt} (w : ∀ (j : J), f ≫ t.π.app j = f' ≫ t.π.app j)
Goal: f = f'
-- CategoryTheory.Limits.IsLimit.ofConeEquiv_apply_desc
@[simp]
theorem ofConeEquiv_apply_desc {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D} (h : Cone G ≌ Cone F)
    {c : Cone G} (P : IsLimit (h.functor.obj c)) (s) :
    (ofConeEquiv h P).lift s =
      ((h.unitIso.hom.app s).hom ≫ (h.inverse.map (P.liftConeMorphism (h.functor.obj s))).hom) ≫
        (h.unitIso.inv.app c).hom 
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} {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {G : K ⥤ D} (h : CategoryTheory.Limits.Cone G ≌ CategoryTheory.Limits.Cone F) {c : CategoryTheory.Limits.Cone G} (P : CategoryTheory.Limits.IsLimit (h.functor.obj c)) (s : CategoryTheory.Limits.Cone G)
Goal: ((CategoryTheory.Limits.IsLimit.ofConeEquiv h) P).lift s =
  ((h.unitIso.hom.app s).hom ≫ (h.inverse.map (P.liftConeMorphism (h.functor.obj s))).hom) ≫ (h.unitIso.inv.app c).hom
-- CategoryTheory.Limits.IsLimit.ofConeEquiv_symm_apply_desc
@[simp]
theorem ofConeEquiv_symm_apply_desc {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D}
    (h : Cone G ≌ Cone F) {c : Cone G} (P : IsLimit c) (s) :
    ((ofConeEquiv h).symm P).lift s =
      (h.counitIso.inv.app s).hom ≫ (h.functor.map (P.liftConeMorphism (h.inverse.obj s))).hom 
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} {D : Type u₄} [CategoryTheory.Category.{v₄, u₄} D] {G : K ⥤ D} (h : CategoryTheory.Limits.Cone G ≌ CategoryTheory.Limits.Cone F) {c : CategoryTheory.Limits.Cone G} (P : CategoryTheory.Limits.IsLimit c) (s : CategoryTheory.Limits.Cone F)
Goal: ((CategoryTheory.Limits.IsLimit.ofConeEquiv h).symm P).lift s =
  (h.counitIso.inv.app s).hom ≫ (h.functor.map (P.liftConeMorphism (h.inverse.obj s))).hom
-- CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv
@[simps]
def conePointsIsoOfNatIso {F G : J ⥤ C} {s : Cone F} {t : Cone G} (P : IsLimit s) (Q : IsLimit t)
    (w : F ≅ G) : s.pt ≅ t.pt 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} {s : CategoryTheory.Limits.Cone F} {t : CategoryTheory.Limits.Cone G} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (w : F ≅ G)
Goal: (P.conePointsIsoOfNatIso Q w).inv = CategoryTheory.Limits.IsLimit.map t P w.inv
-- CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom
@[simps]
def conePointsIsoOfNatIso {F G : J ⥤ C} {s : Cone F} {t : Cone G} (P : IsLimit s) (Q : IsLimit t)
    (w : F ≅ G) : s.pt ≅ t.pt 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} {s : CategoryTheory.Limits.Cone F} {t : CategoryTheory.Limits.Cone G} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (w : F ≅ G)
Goal: (P.conePointsIsoOfNatIso Q w).hom = CategoryTheory.Limits.IsLimit.map s Q w.hom
-- CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom_comp
@[reassoc]
theorem conePointsIsoOfNatIso_hom_comp {F G : J ⥤ C} {s : Cone F} {t : Cone G} (P : IsLimit s)
    (Q : IsLimit t) (w : F ≅ G) (j : J) :
    (conePointsIsoOfNatIso P Q w).hom ≫ t.π.app j = s.π.app j ≫ w.hom.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} {s : CategoryTheory.Limits.Cone F} {t : CategoryTheory.Limits.Cone G} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (w : F ≅ G) (j : J)
Goal: (P.conePointsIsoOfNatIso Q w).hom ≫ t.π.app j = s.π.app j ≫ w.hom.app j
-- CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv_comp
@[reassoc]
theorem conePointsIsoOfNatIso_inv_comp {F G : J ⥤ C} {s : Cone F} {t : Cone G} (P : IsLimit s)
    (Q : IsLimit t) (w : F ≅ G) (j : J) :
    (conePointsIsoOfNatIso P Q w).inv ≫ s.π.app j = t.π.app j ≫ w.inv.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} {s : CategoryTheory.Limits.Cone F} {t : CategoryTheory.Limits.Cone G} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (w : F ≅ G) (j : J)
Goal: (P.conePointsIsoOfNatIso Q w).inv ≫ s.π.app j = t.π.app j ≫ w.inv.app j
-- CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_hom
@[reassoc]
theorem lift_comp_conePointsIsoOfNatIso_hom {F G : J ⥤ C} {r s : Cone F} {t : Cone G}
    (P : IsLimit s) (Q : IsLimit t) (w : F ≅ G) :
    P.lift r ≫ (conePointsIsoOfNatIso P Q w).hom = Q.map r w.hom 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} {r s : CategoryTheory.Limits.Cone F} {t : CategoryTheory.Limits.Cone G} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (w : F ≅ G)
Goal: P.lift r ≫ (P.conePointsIsoOfNatIso Q w).hom = CategoryTheory.Limits.IsLimit.map r Q w.hom
-- CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_inv
@[reassoc]
theorem lift_comp_conePointsIsoOfNatIso_inv {F G : J ⥤ C} {r s : Cone G} {t : Cone F}
    (P : IsLimit t) (Q : IsLimit s) (w : F ≅ G) :
    Q.lift r ≫ (conePointsIsoOfNatIso P Q w).inv = P.map r w.inv 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} {r s : CategoryTheory.Limits.Cone G} {t : CategoryTheory.Limits.Cone F} (P : CategoryTheory.Limits.IsLimit t) (Q : CategoryTheory.Limits.IsLimit s) (w : F ≅ G)
Goal: Q.lift r ≫ (P.conePointsIsoOfNatIso Q w).inv = CategoryTheory.Limits.IsLimit.map r P w.inv
-- CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence_inv
@[simps]
def conePointsIsoOfEquivalence {F : J ⥤ C} {s : Cone F} {G : K ⥤ C} {t : Cone G} (P : IsLimit s)
    (Q : IsLimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F) : s.pt ≅ t.pt 
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} {s : CategoryTheory.Limits.Cone F} {G : K ⥤ C} {t : CategoryTheory.Limits.Cone G} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F)
Goal: (P.conePointsIsoOfEquivalence Q e w).inv =
  P.lift ((CategoryTheory.Limits.Cones.equivalenceOfReindexing e w).functor.obj t)
-- CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence_hom
@[simps]
def conePointsIsoOfEquivalence {F : J ⥤ C} {s : Cone F} {G : K ⥤ C} {t : Cone G} (P : IsLimit s)
    (Q : IsLimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F) : s.pt ≅ t.pt 
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} {s : CategoryTheory.Limits.Cone F} {G : K ⥤ C} {t : CategoryTheory.Limits.Cone G} (P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F)
Goal: (P.conePointsIsoOfEquivalence Q e w).hom =
  Q.lift
    ((CategoryTheory.Limits.Cones.equivalenceOfReindexing e.symm
            ((CategoryTheory.isoWhiskerLeft e.inverse w).symm ≪≫ e.invFunIdAssoc G)).functor.obj
      s)
-- CategoryTheory.Limits.IsLimit.homIso_hom
@[simp]
theorem homIso_hom (h : IsLimit t) {W : C} (f : ULift.{u₁} (W ⟶ t.pt)) :
    (IsLimit.homIso h W).hom f = (t.extend f.down).π 
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} (h : CategoryTheory.Limits.IsLimit t) {W : C} (f : ULift.{u₁, v₃} (W ⟶ t.pt))
Goal: (h.homIso W).hom f = (t.extend f.down).π
-- CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom_homOfCone
@[simp]
theorem coneOfHom_homOfCone (s : Cone F) : coneOfHom h (homOfCone h s) = s 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {X : C} (h : CategoryTheory.yoneda.obj X ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cones) (s : CategoryTheory.Limits.Cone F)
Goal: CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom h (CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone h s) = s
-- CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone_coneOfHom
@[simp]
theorem homOfCone_coneOfHom {Y : C} (f : Y ⟶ X) : homOfCone h (coneOfHom h f) = f 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {X : C} (h : CategoryTheory.yoneda.obj X ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cones) {Y : C} (f : Y ⟶ X)
Goal: CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone h (CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom h f) = f
-- CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom_fac
theorem coneOfHom_fac {Y : C} (f : Y ⟶ X) : coneOfHom h f = (limitCone h).extend f 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {X : C} (h : CategoryTheory.yoneda.obj X ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cones) {Y : C} (f : Y ⟶ X)
Goal: CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom h f = (CategoryTheory.Limits.IsLimit.OfNatIso.limitCone h).extend f
-- CategoryTheory.Limits.IsLimit.OfNatIso.cone_fac
theorem cone_fac (s : Cone F) : (limitCone h).extend (homOfCone h s) = s 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {X : C} (h : CategoryTheory.yoneda.obj X ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cones) (s : CategoryTheory.Limits.Cone F)
Goal: (CategoryTheory.Limits.IsLimit.OfNatIso.limitCone h).extend (CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone h s) = s
-- CategoryTheory.Limits.IsColimit.uniq
-- Porting note(#5171): removed @[nolint has_nonempty_instance]
structure IsColimit (t : Cocone F) where
    desc : ∀ s : Cocone F, t.pt ⟶ s.pt
    fac : ∀ (s : Cocone F) (j : J), t.ι.app j ≫ desc s = s.ι.app j := by aesop_cat
    uniq :
    ∀ (s : Cocone F) (m : t.pt ⟶ s.pt) (_ : ∀ j : J, t.ι.app j ≫ m = s.ι.app j), m = desc s := by
    aesop_cat
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} (self : CategoryTheory.Limits.IsColimit t) (s : CategoryTheory.Limits.Cocone F) (m : t.pt ⟶ s.pt)
Goal: (∀ (j : J), t.ι.app j ≫ m = s.ι.app j) → m = self.desc s
-- CategoryTheory.Limits.IsColimit.fac
-- Porting note(#5171): removed @[nolint has_nonempty_instance]
structure IsColimit (t : Cocone F) where
    desc : ∀ s : Cocone F, t.pt ⟶ s.pt
    fac : ∀ (s : Cocone F) (j : J), t.ι.app j ≫ desc s = s.ι.app j := by aesop_cat
    uniq :
    ∀ (s : Cocone F) (m : t.pt ⟶ s.pt) (_ : ∀ j : J, t.ι.app j ≫ m = s.ι.app j), m = desc s := by
    aesop_cat
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} (self : CategoryTheory.Limits.IsColimit t) (s : CategoryTheory.Limits.Cocone F) (j : J)
Goal: t.ι.app j ≫ self.desc s = s.ι.app j
-- CategoryTheory.Limits.IsColimit.ι_map
@[reassoc (attr := simp)]
theorem ι_map {F G : J ⥤ C} {c : Cocone F} (hc : IsColimit c) (d : Cocone G) (α : F ⟶ G) (j : J) :
    c.ι.app j ≫ IsColimit.map hc d α = α.app j ≫ d.ι.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c) (d : CategoryTheory.Limits.Cocone G) (α : F ⟶ G) (j : J)
Goal: c.ι.app j ≫ hc.map d α = α.app j ≫ d.ι.app j
-- CategoryTheory.Limits.IsColimit.desc_self
@[simp]
theorem desc_self {t : Cocone F} (h : IsColimit t) : h.desc t = 𝟙 t.pt 
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} (h : CategoryTheory.Limits.IsColimit t)
Goal: h.desc t = 𝟙 t.pt
-- CategoryTheory.Limits.IsColimit.descCoconeMorphism_hom
@[simps]
def descCoconeMorphism {t : Cocone F} (h : IsColimit t) (s : Cocone F) : t ⟶ s 
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} (h : CategoryTheory.Limits.IsColimit t) (s : CategoryTheory.Limits.Cocone F)
Goal: (h.descCoconeMorphism s).hom = h.desc s
-- CategoryTheory.Limits.IsColimit.uniq_cocone_morphism
theorem uniq_cocone_morphism {s t : Cocone F} (h : IsColimit t) {f f' : t ⟶ s} : f = f' 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cocone F} (h : CategoryTheory.Limits.IsColimit t) {f f' : t ⟶ s}
Goal: f = f'
-- CategoryTheory.Limits.IsColimit.existsUnique
theorem existsUnique {t : Cocone F} (h : IsColimit t) (s : Cocone F) :
    ∃! d : t.pt ⟶ s.pt, ∀ j, t.ι.app j ≫ d = s.ι.app j 
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} (h : CategoryTheory.Limits.IsColimit t) (s : CategoryTheory.Limits.Cocone F)
Goal: ∃! d, ∀ (j : J), t.ι.app j ≫ d = s.ι.app j
-- CategoryTheory.Limits.IsColimit.mkCoconeMorphism_desc
@[simps]
def mkCoconeMorphism {t : Cocone F} (desc : ∀ s : Cocone F, t ⟶ s)
    (uniq' : ∀ (s : Cocone F) (m : t ⟶ s), m = desc s) : IsColimit t 
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} (desc : (s : CategoryTheory.Limits.Cocone F) → t ⟶ s) (uniq' : ∀ (s : CategoryTheory.Limits.Cocone F) (m : t ⟶ s), m = desc s) (s : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.IsColimit.mkCoconeMorphism desc uniq').desc s = (desc s).hom
-- CategoryTheory.Limits.IsColimit.uniqueUpToIso_inv
@[simps]
def uniqueUpToIso {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) : s ≅ t 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cocone F} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t)
Goal: (P.uniqueUpToIso Q).inv = Q.descCoconeMorphism s
-- CategoryTheory.Limits.IsColimit.uniqueUpToIso_hom
@[simps]
def uniqueUpToIso {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) : s ≅ t 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cocone F} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t)
Goal: (P.uniqueUpToIso Q).hom = P.descCoconeMorphism t
-- CategoryTheory.Limits.IsColimit.hom_isIso
theorem hom_isIso {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) (f : s ⟶ t) : IsIso f 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cocone F} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t) (f : s ⟶ t)
Goal: CategoryTheory.IsIso f
-- CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_hom
@[reassoc (attr := simp)]
theorem comp_coconePointUniqueUpToIso_hom {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t)
    (j : J) : s.ι.app j ≫ (coconePointUniqueUpToIso P Q).hom = t.ι.app j 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {s t : CategoryTheory.Limits.Cocone F} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t) (j : J)
Goal: s.ι.app j ≫ (P.coconePointUniqueUpToIso Q).hom = t.ι.app j