ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_inv
@[reassoc (attr := simp)]
theorem comp_coconePointUniqueUpToIso_inv {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t)
    (j : J) : t.ι.app j ≫ (coconePointUniqueUpToIso P Q).inv = 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.Cocone F} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t) (j : J)
Goal: t.ι.app j ≫ (P.coconePointUniqueUpToIso Q).inv = s.ι.app j
-- CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_hom_desc
@[reassoc (attr := simp)]
theorem coconePointUniqueUpToIso_hom_desc {r s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) :
    (coconePointUniqueUpToIso P Q).hom ≫ Q.desc r = P.desc 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.Cocone F} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t)
Goal: (P.coconePointUniqueUpToIso Q).hom ≫ Q.desc r = P.desc r
-- CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_inv_desc
@[reassoc (attr := simp)]
theorem coconePointUniqueUpToIso_inv_desc {r s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) :
    (coconePointUniqueUpToIso P Q).inv ≫ P.desc r = Q.desc 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.Cocone F} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t)
Goal: (P.coconePointUniqueUpToIso Q).inv ≫ P.desc r = Q.desc r
-- CategoryTheory.Limits.IsColimit.ofIsoColimit_desc
@[simp]
theorem ofIsoColimit_desc {r t : Cocone F} (P : IsColimit r) (i : r ≅ t) (s) :
    (P.ofIsoColimit i).desc s = i.inv.hom ≫ P.desc s 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F : J ⥤ C} {r t : CategoryTheory.Limits.Cocone F} (P : CategoryTheory.Limits.IsColimit r) (i : r ≅ t) (s : CategoryTheory.Limits.Cocone F)
Goal: (P.ofIsoColimit i).desc s = i.inv.hom ≫ P.desc s
-- CategoryTheory.Limits.IsColimit.equivIsoColimit_apply
@[simp]
theorem equivIsoColimit_apply {r t : Cocone F} (i : r ≅ t) (P : IsColimit r) :
    equivIsoColimit i P = P.ofIsoColimit 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.Cocone F} (i : r ≅ t) (P : CategoryTheory.Limits.IsColimit r)
Goal: (CategoryTheory.Limits.IsColimit.equivIsoColimit i) P = P.ofIsoColimit i
-- CategoryTheory.Limits.IsColimit.equivIsoColimit_symm_apply
@[simp]
theorem equivIsoColimit_symm_apply {r t : Cocone F} (i : r ≅ t) (P : IsColimit t) :
    (equivIsoColimit i).symm P = P.ofIsoColimit 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.Cocone F} (i : r ≅ t) (P : CategoryTheory.Limits.IsColimit t)
Goal: (CategoryTheory.Limits.IsColimit.equivIsoColimit i).symm P = P.ofIsoColimit i.symm
-- CategoryTheory.Limits.IsColimit.hom_desc
theorem hom_desc (h : IsColimit t) {W : C} (m : t.pt ⟶ W) :
    m =
      h.desc
        { pt := W
          ι :=
            { app := fun b => t.ι.app b ≫ m
              naturality := by intros; erw [← assoc, t.ι.naturality, comp_id, comp_id] } } 
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) {W : C} (m : t.pt ⟶ W)
Goal: m = h.desc { pt := W, ι := { app := fun b => t.ι.app b ≫ m, naturality := ⋯ } }
-- CategoryTheory.Limits.IsColimit.hom_ext
theorem hom_ext (h : IsColimit t) {W : C} {f f' : t.pt ⟶ W}
    (w : ∀ j, t.ι.app j ≫ f = t.ι.app j ≫ f') : 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.Cocone F} (h : CategoryTheory.Limits.IsColimit t) {W : C} {f f' : t.pt ⟶ W} (w : ∀ (j : J), t.ι.app j ≫ f = t.ι.app j ≫ f')
Goal: f = f'
-- CategoryTheory.Limits.IsColimit.ofCoconeEquiv_apply_desc
@[simp]
theorem ofCoconeEquiv_apply_desc {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D}
    (h : Cocone G ≌ Cocone F) {c : Cocone G} (P : IsColimit (h.functor.obj c)) (s) :
    (ofCoconeEquiv h P).desc s =
      (h.unit.app c).hom ≫
        (h.inverse.map (P.descCoconeMorphism (h.functor.obj s))).hom ≫ (h.unitInv.app 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.Cocone G ≌ CategoryTheory.Limits.Cocone F) {c : CategoryTheory.Limits.Cocone G} (P : CategoryTheory.Limits.IsColimit (h.functor.obj c)) (s : CategoryTheory.Limits.Cocone G)
Goal: ((CategoryTheory.Limits.IsColimit.ofCoconeEquiv h) P).desc s =
  (h.unit.app c).hom ≫ (h.inverse.map (P.descCoconeMorphism (h.functor.obj s))).hom ≫ (h.unitInv.app s).hom
-- CategoryTheory.Limits.IsColimit.ofCoconeEquiv_symm_apply_desc
@[simp]
theorem ofCoconeEquiv_symm_apply_desc {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D}
    (h : Cocone G ≌ Cocone F) {c : Cocone G} (P : IsColimit c) (s) :
    ((ofCoconeEquiv h).symm P).desc s =
      (h.functor.map (P.descCoconeMorphism (h.inverse.obj s))).hom ≫ (h.counit.app 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.Cocone G ≌ CategoryTheory.Limits.Cocone F) {c : CategoryTheory.Limits.Cocone G} (P : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cocone F)
Goal: ((CategoryTheory.Limits.IsColimit.ofCoconeEquiv h).symm P).desc s =
  (h.functor.map (P.descCoconeMorphism (h.inverse.obj s))).hom ≫ (h.counit.app s).hom
-- CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_hom
@[simps]
def coconePointsIsoOfNatIso {F G : J ⥤ C} {s : Cocone F} {t : Cocone G} (P : IsColimit s)
    (Q : IsColimit 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.Cocone F} {t : CategoryTheory.Limits.Cocone G} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t) (w : F ≅ G)
Goal: (P.coconePointsIsoOfNatIso Q w).hom = P.map t w.hom
-- CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_inv
@[simps]
def coconePointsIsoOfNatIso {F G : J ⥤ C} {s : Cocone F} {t : Cocone G} (P : IsColimit s)
    (Q : IsColimit 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.Cocone F} {t : CategoryTheory.Limits.Cocone G} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t) (w : F ≅ G)
Goal: (P.coconePointsIsoOfNatIso Q w).inv = Q.map s w.inv
-- CategoryTheory.Limits.IsColimit.comp_coconePointsIsoOfNatIso_hom
@[reassoc]
theorem comp_coconePointsIsoOfNatIso_hom {F G : J ⥤ C} {s : Cocone F} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (w : F ≅ G) (j : J) :
    s.ι.app j ≫ (coconePointsIsoOfNatIso P Q w).hom = w.hom.app j ≫ t.ι.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.Cocone F} {t : CategoryTheory.Limits.Cocone G} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t) (w : F ≅ G) (j : J)
Goal: s.ι.app j ≫ (P.coconePointsIsoOfNatIso Q w).hom = w.hom.app j ≫ t.ι.app j
-- CategoryTheory.Limits.IsColimit.comp_coconePointsIsoOfNatIso_inv
@[reassoc]
theorem comp_coconePointsIsoOfNatIso_inv {F G : J ⥤ C} {s : Cocone F} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (w : F ≅ G) (j : J) :
    t.ι.app j ≫ (coconePointsIsoOfNatIso P Q w).inv = w.inv.app j ≫ s.ι.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.Cocone F} {t : CategoryTheory.Limits.Cocone G} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t) (w : F ≅ G) (j : J)
Goal: t.ι.app j ≫ (P.coconePointsIsoOfNatIso Q w).inv = w.inv.app j ≫ s.ι.app j
-- CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_hom_desc
@[reassoc]
theorem coconePointsIsoOfNatIso_hom_desc {F G : J ⥤ C} {s : Cocone F} {r t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (w : F ≅ G) :
    (coconePointsIsoOfNatIso P Q w).hom ≫ Q.desc r = P.map _ w.hom 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} {s : CategoryTheory.Limits.Cocone F} {r t : CategoryTheory.Limits.Cocone G} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t) (w : F ≅ G)
Goal: (P.coconePointsIsoOfNatIso Q w).hom ≫ Q.desc r = P.map r w.hom
-- CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_inv_desc
@[reassoc]
theorem coconePointsIsoOfNatIso_inv_desc {F G : J ⥤ C} {s : Cocone G} {r t : Cocone F}
    (P : IsColimit t) (Q : IsColimit s) (w : F ≅ G) :
    (coconePointsIsoOfNatIso P Q w).inv ≫ P.desc r = Q.map _ w.inv 
Arguments: {J : Type u₁} [CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [CategoryTheory.Category.{v₃, u₃} C] {F G : J ⥤ C} {s : CategoryTheory.Limits.Cocone G} {r t : CategoryTheory.Limits.Cocone F} (P : CategoryTheory.Limits.IsColimit t) (Q : CategoryTheory.Limits.IsColimit s) (w : F ≅ G)
Goal: (P.coconePointsIsoOfNatIso Q w).inv ≫ P.desc r = Q.map r w.inv
-- CategoryTheory.Limits.IsColimit.coconePointsIsoOfEquivalence_inv
@[simps]
def coconePointsIsoOfEquivalence {F : J ⥤ C} {s : Cocone F} {G : K ⥤ C} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit 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.Cocone F} {G : K ⥤ C} {t : CategoryTheory.Limits.Cocone G} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F)
Goal: (P.coconePointsIsoOfEquivalence Q e w).inv =
  Q.desc
    ((CategoryTheory.Limits.Cocones.equivalenceOfReindexing e.symm
            ((CategoryTheory.isoWhiskerLeft e.inverse w).symm ≪≫ e.invFunIdAssoc G)).functor.obj
      s)
-- CategoryTheory.Limits.IsColimit.coconePointsIsoOfEquivalence_hom
@[simps]
def coconePointsIsoOfEquivalence {F : J ⥤ C} {s : Cocone F} {G : K ⥤ C} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit 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.Cocone F} {G : K ⥤ C} {t : CategoryTheory.Limits.Cocone G} (P : CategoryTheory.Limits.IsColimit s) (Q : CategoryTheory.Limits.IsColimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F)
Goal: (P.coconePointsIsoOfEquivalence Q e w).hom =
  P.desc ((CategoryTheory.Limits.Cocones.equivalenceOfReindexing e w).functor.obj t)
-- CategoryTheory.Limits.IsColimit.homEquiv_apply
@[simp]
lemma homEquiv_apply (h : IsColimit t) {W : C} (f : t.pt ⟶ W) :
    h.homEquiv W f = (t.extend f).ι 
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) {W : C} (f : t.pt ⟶ W)
Goal: (h.homEquiv W) f = (t.extend f).ι
-- CategoryTheory.Limits.IsColimit.homIso_hom
@[simp]
theorem homIso_hom (h : IsColimit t) {W : C} (f : ULift (t.pt ⟶ W)) :
    (IsColimit.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.Cocone F} (h : CategoryTheory.Limits.IsColimit t) {W : C} (f : ULift.{u₁, v₃} (t.pt ⟶ W))
Goal: (h.homIso W).hom f = (t.extend f.down).ι
-- CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom_homOfCocone
@[simp]
theorem coconeOfHom_homOfCocone (s : Cocone F) : coconeOfHom h (homOfCocone 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.coyoneda.obj (Opposite.op X) ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cocones) (s : CategoryTheory.Limits.Cocone F)
Goal: CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom h (CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone h s) = s
-- CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone_cooneOfHom
@[simp]
theorem homOfCocone_cooneOfHom {Y : C} (f : X ⟶ Y) : homOfCocone h (coconeOfHom 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.coyoneda.obj (Opposite.op X) ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cocones) {Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone h (CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom h f) = f
-- CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom_fac
theorem coconeOfHom_fac {Y : C} (f : X ⟶ Y) : coconeOfHom h f = (colimitCocone 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.coyoneda.obj (Opposite.op X) ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cocones) {Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom h f =
  (CategoryTheory.Limits.IsColimit.OfNatIso.colimitCocone h).extend f
-- CategoryTheory.Limits.IsColimit.OfNatIso.cocone_fac
theorem cocone_fac (s : Cocone F) : (colimitCocone h).extend (homOfCocone 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.coyoneda.obj (Opposite.op X) ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cocones) (s : CategoryTheory.Limits.Cocone F)
Goal: (CategoryTheory.Limits.IsColimit.OfNatIso.colimitCocone h).extend
    (CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone h s) =
  s
-- CategoryTheory.Limits.PreservesProduct.iso_hom
@[simp]
theorem PreservesProduct.iso_hom : (PreservesProduct.iso G f).hom = piComparison G f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {J : Type w} (f : J → C) [CategoryTheory.Limits.HasProduct f] [CategoryTheory.Limits.HasProduct fun j => G.obj (f j)] [CategoryTheory.Limits.PreservesLimit (CategoryTheory.Discrete.functor f) G]
Goal: (CategoryTheory.Limits.PreservesProduct.iso G f).hom = CategoryTheory.Limits.piComparison G f
-- CategoryTheory.Limits.PreservesCoproduct.inv_hom
@[simp]
theorem PreservesCoproduct.inv_hom : (PreservesCoproduct.iso G f).inv = sigmaComparison G f 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : C ⥤ D) {J : Type w} (f : J → C) [CategoryTheory.Limits.HasCoproduct f] [CategoryTheory.Limits.HasCoproduct fun j => G.obj (f j)] [CategoryTheory.Limits.PreservesColimit (CategoryTheory.Discrete.functor f) G]
Goal: (CategoryTheory.Limits.PreservesCoproduct.iso G f).inv = CategoryTheory.Limits.sigmaComparison G f
-- CategoryTheory.NormalMonoCategory.epi_of_zero_cokernel
theorem epi_of_zero_cokernel {X Y : C} (f : X ⟶ Y) (Z : C)
    (l : IsColimit (CokernelCofork.ofπ (0 : Y ⟶ Z) (show f ≫ 0 = 0 by simp))) : Epi f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.NormalMonoCategory C] {X Y : C} (f : X ⟶ Y) (Z : C) (l : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ 0 ⋯))
Goal: CategoryTheory.Epi f
-- CategoryTheory.NormalMonoCategory.epi_of_zero_cancel
theorem epi_of_zero_cancel {X Y : C} (f : X ⟶ Y)
    (hf : ∀ (Z : C) (g : Y ⟶ Z) (_ : f ≫ g = 0), g = 0) : Epi f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasFiniteProducts C] [CategoryTheory.Limits.HasKernels C] [CategoryTheory.NormalMonoCategory C] [CategoryTheory.Limits.HasZeroObject C] {X Y : C} (f : X ⟶ Y) (hf : ∀ (Z : C) (g : Y ⟶ Z), f ≫ g = 0 → g = 0)
Goal: CategoryTheory.Epi f
-- CategoryTheory.NormalEpiCategory.mono_of_zero_kernel
theorem mono_of_zero_kernel {X Y : C} (f : X ⟶ Y) (Z : C)
    (l : IsLimit (KernelFork.ofι (0 : Z ⟶ X) (show 0 ≫ f = 0 by simp))) : Mono f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasFiniteCoproducts C] [CategoryTheory.Limits.HasCokernels C] [CategoryTheory.NormalEpiCategory C] {X Y : C} (f : X ⟶ Y) (Z : C) (l : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι 0 ⋯))
Goal: CategoryTheory.Mono f
-- CategoryTheory.NormalEpiCategory.mono_of_cancel_zero
theorem mono_of_cancel_zero {X Y : C} (f : X ⟶ Y)
    (hf : ∀ (Z : C) (g : Z ⟶ X) (_ : g ≫ f = 0), g = 0) : Mono f 
Arguments: {C : Type u_1} [CategoryTheory.Category.{u_2, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasFiniteCoproducts C] [CategoryTheory.Limits.HasCokernels C] [CategoryTheory.NormalEpiCategory C] [CategoryTheory.Limits.HasZeroObject C] {X Y : C} (f : X ⟶ Y) (hf : ∀ (Z : C) (g : Z ⟶ X), g ≫ f = 0 → g = 0)
Goal: CategoryTheory.Mono f
-- CategoryTheory.PreservesImage.iso_hom
@[simps!]
def iso {X Y : A} (f : X ⟶ Y) : image (L.map f) ≅ L.obj (image f) 
Arguments: {A : Type u₁} {B : Type u₂} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Limits.HasEqualizers A] [CategoryTheory.Limits.HasImages A] [CategoryTheory.StrongEpiCategory B] [CategoryTheory.Limits.HasImages B] (L : CategoryTheory.Functor A B) [{X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) L] [{X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) L] {X Y : A} (f : X ⟶ Y)
Goal: (CategoryTheory.PreservesImage.iso L f).hom =
  CategoryTheory.Limits.image.lift
    (CategoryTheory.Limits.MonoFactorisation.mk (L.obj (CategoryTheory.Limits.image f))
      (L.map (CategoryTheory.Limits.image.ι f)) (L.map (CategoryTheory.Limits.factorThruImage f)) ⋯)
-- CategoryTheory.PreservesImage.iso_inv
@[simps!]
def iso {X Y : A} (f : X ⟶ Y) : image (L.map f) ≅ L.obj (image f) 
Arguments: {A : Type u₁} {B : Type u₂} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Limits.HasEqualizers A] [CategoryTheory.Limits.HasImages A] [CategoryTheory.StrongEpiCategory B] [CategoryTheory.Limits.HasImages B] (L : CategoryTheory.Functor A B) [{X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) L] [{X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) L] {X Y : A} (f : X ⟶ Y)
Goal: (CategoryTheory.PreservesImage.iso L f).inv =
  (CategoryTheory.Limits.StrongEpiMonoFactorisation.mk
          (CategoryTheory.Limits.MonoFactorisation.mk (L.obj (CategoryTheory.Limits.image f))
            (L.map (CategoryTheory.Limits.image.ι f)) (L.map (CategoryTheory.Limits.factorThruImage f))
            ⋯)).toMonoIsImage.lift
    (CategoryTheory.Limits.Image.monoFactorisation (L.map f))
-- CategoryTheory.PreservesImage.factorThruImage_comp_hom
@[reassoc]
theorem factorThruImage_comp_hom {X Y : A} (f : X ⟶ Y) :
    factorThruImage (L.map f) ≫ (iso L f).hom = L.map (factorThruImage f) 
Arguments: {A : Type u₁} {B : Type u₂} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Limits.HasEqualizers A] [CategoryTheory.Limits.HasImages A] [CategoryTheory.StrongEpiCategory B] [CategoryTheory.Limits.HasImages B] (L : CategoryTheory.Functor A B) [{X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) L] [{X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) L] {X Y : A} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage (L.map f))
    (CategoryTheory.PreservesImage.iso L f).hom =
  L.map (CategoryTheory.Limits.factorThruImage f)
-- CategoryTheory.PreservesImage.hom_comp_map_image_ι
@[reassoc]
theorem hom_comp_map_image_ι {X Y : A} (f : X ⟶ Y) :
    (iso L f).hom ≫ L.map (image.ι f) = image.ι (L.map f) 
Arguments: {A : Type u₁} {B : Type u₂} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Limits.HasEqualizers A] [CategoryTheory.Limits.HasImages A] [CategoryTheory.StrongEpiCategory B] [CategoryTheory.Limits.HasImages B] (L : CategoryTheory.Functor A B) [{X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) L] [{X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) L] {X Y : A} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.PreservesImage.iso L f).hom
    (L.map (CategoryTheory.Limits.image.ι f)) =
  CategoryTheory.Limits.image.ι (L.map f)
-- CategoryTheory.PreservesImage.inv_comp_image_ι_map
@[reassoc]
theorem inv_comp_image_ι_map {X Y : A} (f : X ⟶ Y) :
    (iso L f).inv ≫ image.ι (L.map f) = L.map (image.ι f) 
Arguments: {A : Type u₁} {B : Type u₂} [CategoryTheory.Category.{v₁, u₁} A] [CategoryTheory.Category.{v₂, u₂} B] [CategoryTheory.Limits.HasEqualizers A] [CategoryTheory.Limits.HasImages A] [CategoryTheory.StrongEpiCategory B] [CategoryTheory.Limits.HasImages B] (L : CategoryTheory.Functor A B) [{X Y Z : A} → (f : X ⟶ Z) → (g : Y ⟶ Z) → CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) L] [{X Y Z : A} → (f : X ⟶ Y) → (g : X ⟶ Z) → CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.span f g) L] {X Y : A} (f : X ⟶ Y)
Goal: CategoryTheory.CategoryStruct.comp (CategoryTheory.PreservesImage.iso L f).inv
    (CategoryTheory.Limits.image.ι (L.map f)) =
  L.map (CategoryTheory.Limits.image.ι f)
-- CategoryTheory.Functor.PreservesZeroMorphisms.map_zero
class PreservesZeroMorphisms (F : C ⥤ D) : Prop where
    map_zero : ∀ X Y : C, F.map (0 : X ⟶ Y) = 0 := by aesop
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroMorphisms D] {F : C ⥤ D} [self : F.PreservesZeroMorphisms] (X Y : C)
Goal: F.map 0 = 0
-- CategoryTheory.Functor.map_zero
@[simp]
protected theorem map_zero (F : C ⥤ D) [PreservesZeroMorphisms F] (X Y : C) :
    F.map (0 : X ⟶ Y) = 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroMorphisms D] (F : C ⥤ D) [F.PreservesZeroMorphisms] (X Y : C)
Goal: F.map 0 = 0
-- CategoryTheory.Functor.map_isZero
lemma map_isZero (F : C ⥤ D) [PreservesZeroMorphisms F] {X : C} (hX : IsZero X) :
    IsZero (F.obj X) 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroMorphisms D] (F : C ⥤ D) [F.PreservesZeroMorphisms] {X : C} (hX : CategoryTheory.Limits.IsZero X)
Goal: CategoryTheory.Limits.IsZero (F.obj X)