ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CategoryTheory.Functor.zero_of_map_zero
theorem zero_of_map_zero (F : C ⥤ D) [PreservesZeroMorphisms F] [Faithful F] {X Y : C} (f : X ⟶ Y)
    (h : F.map f = 0) : f = 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] [F.Faithful] {X Y : C} (f : X ⟶ Y) (h : F.map f = 0)
Goal: f = 0
-- CategoryTheory.Functor.map_eq_zero_iff
theorem map_eq_zero_iff (F : C ⥤ D) [PreservesZeroMorphisms F] [Faithful F] {X Y : C} {f : X ⟶ Y} :
    F.map f = 0 ↔ f = 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] [F.Faithful] {X Y : C} {f : X ⟶ Y}
Goal: F.map f = 0 ↔ f = 0
-- CategoryTheory.Functor.preservesZeroMorphisms_of_iso
lemma preservesZeroMorphisms_of_iso {F₁ F₂ : C ⥤ D} [F₁.PreservesZeroMorphisms] (e : F₁ ≅ F₂) :
    F₂.PreservesZeroMorphisms 
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₁ F₂ : C ⥤ D} [F₁.PreservesZeroMorphisms] (e : F₁ ≅ F₂)
Goal: F₂.PreservesZeroMorphisms
-- CategoryTheory.Functor.mapZeroObject_hom
@[simps]
def mapZeroObject [PreservesZeroMorphisms F] : F.obj 0 ≅ 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroMorphisms D] (F : C ⥤ D) [F.PreservesZeroMorphisms]
Goal: F.mapZeroObject.hom = 0
-- CategoryTheory.Functor.mapZeroObject_inv
@[simps]
def mapZeroObject [PreservesZeroMorphisms F] : F.obj 0 ≅ 0 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroMorphisms D] (F : C ⥤ D) [F.PreservesZeroMorphisms]
Goal: F.mapZeroObject.inv = 0
-- CategoryTheory.Functor.preservesZeroMorphisms_of_map_zero_object
theorem preservesZeroMorphisms_of_map_zero_object (i : F.obj 0 ≅ 0) : PreservesZeroMorphisms F 
Arguments: {C : Type u₁} [CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] [CategoryTheory.Limits.HasZeroObject C] [CategoryTheory.Limits.HasZeroObject D] [CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasZeroMorphisms D] {F : C ⥤ D} (i : F.obj 0 ≅ 0)
Goal: F.PreservesZeroMorphisms
-- CategoryTheory.Limits.MonoFactorisation.m_mono
structure MonoFactorisation (f : X ⟶ Y) where
  I : C -- Porting note: violates naming conventions but can't think a better replacement
  m : I ⟶ Y
  [m_mono : Mono m]
  e : X ⟶ I
  fac : e ≫ m = f := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (self : CategoryTheory.Limits.MonoFactorisation f)
Goal: CategoryTheory.Mono self.m
-- CategoryTheory.Limits.MonoFactorisation.fac
structure MonoFactorisation (f : X ⟶ Y) where
  I : C -- Porting note: violates naming conventions but can't think a better replacement
  m : I ⟶ Y
  [m_mono : Mono m]
  e : X ⟶ I
  fac : e ≫ m = f := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (self : CategoryTheory.Limits.MonoFactorisation f)
Goal: self.e ≫ self.m = f
-- CategoryTheory.Limits.MonoFactorisation.ext
@[ext]
theorem ext {F F' : MonoFactorisation f} (hI : F.I = F'.I)
    (hm : F.m = eqToHom hI ≫ F'.m) : F = F' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {F F' : CategoryTheory.Limits.MonoFactorisation f} (hI : F.I = F'.I) (hm : F.m = CategoryTheory.eqToHom hI ≫ F'.m)
Goal: F = F'
-- CategoryTheory.Limits.MonoFactorisation.compMono_I
@[simps]
def compMono (F : MonoFactorisation f) {Y' : C} (g : Y ⟶ Y') [Mono g] :
    MonoFactorisation (f ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (F : CategoryTheory.Limits.MonoFactorisation f) {Y' : C} (g : Y ⟶ Y') [CategoryTheory.Mono g]
Goal: (F.compMono g).I = F.I
-- CategoryTheory.Limits.MonoFactorisation.compMono_e
@[simps]
def compMono (F : MonoFactorisation f) {Y' : C} (g : Y ⟶ Y') [Mono g] :
    MonoFactorisation (f ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (F : CategoryTheory.Limits.MonoFactorisation f) {Y' : C} (g : Y ⟶ Y') [CategoryTheory.Mono g]
Goal: (F.compMono g).e = F.e
-- CategoryTheory.Limits.MonoFactorisation.compMono_m
@[simps]
def compMono (F : MonoFactorisation f) {Y' : C} (g : Y ⟶ Y') [Mono g] :
    MonoFactorisation (f ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (F : CategoryTheory.Limits.MonoFactorisation f) {Y' : C} (g : Y ⟶ Y') [CategoryTheory.Mono g]
Goal: (F.compMono g).m = F.m ≫ g
-- CategoryTheory.Limits.MonoFactorisation.ofCompIso_e
@[simps]
def ofCompIso {Y' : C} {g : Y ⟶ Y'} [IsIso g] (F : MonoFactorisation (f ≫ g)) :
    MonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {Y' : C} {g : Y ⟶ Y'} [CategoryTheory.IsIso g] (F : CategoryTheory.Limits.MonoFactorisation (f ≫ g))
Goal: F.ofCompIso.e = F.e
-- CategoryTheory.Limits.MonoFactorisation.ofCompIso_m
@[simps]
def ofCompIso {Y' : C} {g : Y ⟶ Y'} [IsIso g] (F : MonoFactorisation (f ≫ g)) :
    MonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {Y' : C} {g : Y ⟶ Y'} [CategoryTheory.IsIso g] (F : CategoryTheory.Limits.MonoFactorisation (f ≫ g))
Goal: F.ofCompIso.m = F.m ≫ CategoryTheory.inv g
-- CategoryTheory.Limits.MonoFactorisation.ofCompIso_I
@[simps]
def ofCompIso {Y' : C} {g : Y ⟶ Y'} [IsIso g] (F : MonoFactorisation (f ≫ g)) :
    MonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {Y' : C} {g : Y ⟶ Y'} [CategoryTheory.IsIso g] (F : CategoryTheory.Limits.MonoFactorisation (f ≫ g))
Goal: F.ofCompIso.I = F.I
-- CategoryTheory.Limits.MonoFactorisation.isoComp_e
@[simps]
def isoComp (F : MonoFactorisation f) {X' : C} (g : X' ⟶ X) : MonoFactorisation (g ≫ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (F : CategoryTheory.Limits.MonoFactorisation f) {X' : C} (g : X' ⟶ X)
Goal: (F.isoComp g).e = g ≫ F.e
-- CategoryTheory.Limits.MonoFactorisation.isoComp_I
@[simps]
def isoComp (F : MonoFactorisation f) {X' : C} (g : X' ⟶ X) : MonoFactorisation (g ≫ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (F : CategoryTheory.Limits.MonoFactorisation f) {X' : C} (g : X' ⟶ X)
Goal: (F.isoComp g).I = F.I
-- CategoryTheory.Limits.MonoFactorisation.isoComp_m
@[simps]
def isoComp (F : MonoFactorisation f) {X' : C} (g : X' ⟶ X) : MonoFactorisation (g ≫ f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (F : CategoryTheory.Limits.MonoFactorisation f) {X' : C} (g : X' ⟶ X)
Goal: (F.isoComp g).m = F.m
-- CategoryTheory.Limits.MonoFactorisation.ofIsoComp_e
@[simps]
def ofIsoComp {X' : C} (g : X' ⟶ X) [IsIso g] (F : MonoFactorisation (g ≫ f)) :
    MonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {X' : C} (g : X' ⟶ X) [CategoryTheory.IsIso g] (F : CategoryTheory.Limits.MonoFactorisation (g ≫ f))
Goal: (CategoryTheory.Limits.MonoFactorisation.ofIsoComp g F).e = CategoryTheory.inv g ≫ F.e
-- CategoryTheory.Limits.MonoFactorisation.ofIsoComp_I
@[simps]
def ofIsoComp {X' : C} (g : X' ⟶ X) [IsIso g] (F : MonoFactorisation (g ≫ f)) :
    MonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {X' : C} (g : X' ⟶ X) [CategoryTheory.IsIso g] (F : CategoryTheory.Limits.MonoFactorisation (g ≫ f))
Goal: (CategoryTheory.Limits.MonoFactorisation.ofIsoComp g F).I = F.I
-- CategoryTheory.Limits.MonoFactorisation.ofIsoComp_m
@[simps]
def ofIsoComp {X' : C} (g : X' ⟶ X) [IsIso g] (F : MonoFactorisation (g ≫ f)) :
    MonoFactorisation f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {X' : C} (g : X' ⟶ X) [CategoryTheory.IsIso g] (F : CategoryTheory.Limits.MonoFactorisation (g ≫ f))
Goal: (CategoryTheory.Limits.MonoFactorisation.ofIsoComp g F).m = F.m
-- CategoryTheory.Limits.MonoFactorisation.ofArrowIso_e
@[simps]
def ofArrowIso {f g : Arrow C} (F : MonoFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    MonoFactorisation g.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} (F : CategoryTheory.Limits.MonoFactorisation f.hom) (sq : f ⟶ g) [CategoryTheory.IsIso sq]
Goal: (F.ofArrowIso sq).e = CategoryTheory.inv sq.left ≫ F.e
-- CategoryTheory.Limits.MonoFactorisation.ofArrowIso_m
@[simps]
def ofArrowIso {f g : Arrow C} (F : MonoFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    MonoFactorisation g.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} (F : CategoryTheory.Limits.MonoFactorisation f.hom) (sq : f ⟶ g) [CategoryTheory.IsIso sq]
Goal: (F.ofArrowIso sq).m = F.m ≫ sq.right
-- CategoryTheory.Limits.MonoFactorisation.ofArrowIso_I
@[simps]
def ofArrowIso {f g : Arrow C} (F : MonoFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    MonoFactorisation g.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} (F : CategoryTheory.Limits.MonoFactorisation f.hom) (sq : f ⟶ g) [CategoryTheory.IsIso sq]
Goal: (F.ofArrowIso sq).I = F.I
-- CategoryTheory.Limits.IsImage.lift_fac
structure IsImage (F : MonoFactorisation f) where
  lift : ∀ F' : MonoFactorisation f, F.I ⟶ F'.I
  lift_fac : ∀ F' : MonoFactorisation f, lift F' ≫ F'.m = F.m := by aesop_cat
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {F : CategoryTheory.Limits.MonoFactorisation f} (self : CategoryTheory.Limits.IsImage F) (F' : CategoryTheory.Limits.MonoFactorisation f)
Goal: self.lift F' ≫ F'.m = F.m
-- CategoryTheory.Limits.IsImage.fac_lift
@[reassoc (attr := simp)]
theorem fac_lift {F : MonoFactorisation f} (hF : IsImage F) (F' : MonoFactorisation f) :
    F.e ≫ hF.lift F' = F'.e 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {F : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F) (F' : CategoryTheory.Limits.MonoFactorisation f)
Goal: F.e ≫ hF.lift F' = F'.e
-- CategoryTheory.Limits.IsImage.self_lift
@[simps]
def self [Mono f] : IsImage (MonoFactorisation.self f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f] (F' : CategoryTheory.Limits.MonoFactorisation f)
Goal: (CategoryTheory.Limits.IsImage.self f).lift F' = F'.e
-- CategoryTheory.Limits.IsImage.isoExt_inv
@[simps]
def isoExt {F F' : MonoFactorisation f} (hF : IsImage F) (hF' : IsImage F') :
    F.I ≅ F'.I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {F F' : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F) (hF' : CategoryTheory.Limits.IsImage F')
Goal: (hF.isoExt hF').inv = hF'.lift F
-- CategoryTheory.Limits.IsImage.isoExt_hom
@[simps]
def isoExt {F F' : MonoFactorisation f} (hF : IsImage F) (hF' : IsImage F') :
    F.I ≅ F'.I 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {F F' : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F) (hF' : CategoryTheory.Limits.IsImage F')
Goal: (hF.isoExt hF').hom = hF.lift F'
-- CategoryTheory.Limits.IsImage.isoExt_hom_m
theorem isoExt_hom_m : (isoExt hF hF').hom ≫ F'.m = F.m 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {F F' : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F) (hF' : CategoryTheory.Limits.IsImage F')
Goal: (hF.isoExt hF').hom ≫ F'.m = F.m
-- CategoryTheory.Limits.IsImage.isoExt_inv_m
theorem isoExt_inv_m : (isoExt hF hF').inv ≫ F.m = F'.m 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {F F' : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F) (hF' : CategoryTheory.Limits.IsImage F')
Goal: (hF.isoExt hF').inv ≫ F.m = F'.m
-- CategoryTheory.Limits.IsImage.e_isoExt_hom
theorem e_isoExt_hom : F.e ≫ (isoExt hF hF').hom = F'.e 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {F F' : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F) (hF' : CategoryTheory.Limits.IsImage F')
Goal: F.e ≫ (hF.isoExt hF').hom = F'.e
-- CategoryTheory.Limits.IsImage.e_isoExt_inv
theorem e_isoExt_inv : F'.e ≫ (isoExt hF hF').inv = F.e 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {F F' : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F) (hF' : CategoryTheory.Limits.IsImage F')
Goal: F'.e ≫ (hF.isoExt hF').inv = F.e
-- CategoryTheory.Limits.IsImage.ofArrowIso_lift
@[simps]
def ofArrowIso {f g : Arrow C} {F : MonoFactorisation f.hom} (hF : IsImage F) (sq : f ⟶ g)
    [IsIso sq] : IsImage (F.ofArrowIso sq) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} {F : CategoryTheory.Limits.MonoFactorisation f.hom} (hF : CategoryTheory.Limits.IsImage F) (sq : f ⟶ g) [CategoryTheory.IsIso sq] (F' : CategoryTheory.Limits.MonoFactorisation g.hom)
Goal: (hF.ofArrowIso sq).lift F' = hF.lift (F'.ofArrowIso (CategoryTheory.inv sq))
-- CategoryTheory.Limits.ImageFactorisation.ofArrowIso_F
@[simps]
def ofArrowIso {f g : Arrow C} (F : ImageFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    ImageFactorisation g.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} (F : CategoryTheory.Limits.ImageFactorisation f.hom) (sq : f ⟶ g) [CategoryTheory.IsIso sq]
Goal: (F.ofArrowIso sq).F = F.F.ofArrowIso sq
-- CategoryTheory.Limits.ImageFactorisation.ofArrowIso_isImage
@[simps]
def ofArrowIso {f g : Arrow C} (F : ImageFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    ImageFactorisation g.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} (F : CategoryTheory.Limits.ImageFactorisation f.hom) (sq : f ⟶ g) [CategoryTheory.IsIso sq]
Goal: (F.ofArrowIso sq).isImage = F.isImage.ofArrowIso sq
-- CategoryTheory.Limits.HasImage.exists_image
class HasImage (f : X ⟶ Y) : Prop where mk' ::
  exists_image : Nonempty (ImageFactorisation f)
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.Limits.HasImage f]
Goal: Nonempty (CategoryTheory.Limits.ImageFactorisation f)
-- CategoryTheory.Limits.HasImage.mk
theorem HasImage.mk {f : X ⟶ Y} (F : ImageFactorisation f) : HasImage f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (F : CategoryTheory.Limits.ImageFactorisation f)
Goal: CategoryTheory.Limits.HasImage f
-- CategoryTheory.Limits.HasImage.of_arrow_iso
theorem HasImage.of_arrow_iso {f g : Arrow C} [h : HasImage f.hom] (sq : f ⟶ g) [IsIso sq] :
    HasImage g.hom 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C} [h : CategoryTheory.Limits.HasImage f.hom] (sq : f ⟶ g) [CategoryTheory.IsIso sq]
Goal: CategoryTheory.Limits.HasImage g.hom
-- CategoryTheory.Limits.image.as_ι
@[simp]
theorem image.as_ι : (Image.monoFactorisation f).m = image.ι f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f]
Goal: (CategoryTheory.Limits.Image.monoFactorisation f).m = CategoryTheory.Limits.image.ι f
-- CategoryTheory.Limits.as_factorThruImage
@[simp]
theorem as_factorThruImage : (Image.monoFactorisation f).e = factorThruImage f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f]
Goal: (CategoryTheory.Limits.Image.monoFactorisation f).e = CategoryTheory.Limits.factorThruImage f
-- CategoryTheory.Limits.image.fac
@[reassoc (attr := simp)]
theorem image.fac : factorThruImage f ≫ image.ι f = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f]
Goal: CategoryTheory.Limits.factorThruImage f ≫ CategoryTheory.Limits.image.ι f = f
-- CategoryTheory.Limits.image.lift_fac
@[reassoc (attr := simp)]
theorem image.lift_fac (F' : MonoFactorisation f) : image.lift F' ≫ F'.m = image.ι f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasImage f] (F' : CategoryTheory.Limits.MonoFactorisation f)
Goal: CategoryTheory.Limits.image.lift F' ≫ F'.m = CategoryTheory.Limits.image.ι f
-- CategoryTheory.Limits.image.fac_lift
@[reassoc (attr := simp)]
theorem image.fac_lift (F' : MonoFactorisation f) : factorThruImage f ≫ image.lift F' = F'.e 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasImage f] (F' : CategoryTheory.Limits.MonoFactorisation f)
Goal: CategoryTheory.Limits.factorThruImage f ≫ CategoryTheory.Limits.image.lift F' = F'.e
-- CategoryTheory.Limits.image.isImage_lift
@[simp]
theorem image.isImage_lift (F : MonoFactorisation f) : (Image.isImage f).lift F = image.lift F 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasImage f] (F : CategoryTheory.Limits.MonoFactorisation f)
Goal: (CategoryTheory.Limits.Image.isImage f).lift F = CategoryTheory.Limits.image.lift F
-- CategoryTheory.Limits.IsImage.lift_ι
@[reassoc (attr := simp)]
theorem IsImage.lift_ι {F : MonoFactorisation f} (hF : IsImage F) :
    hF.lift (Image.monoFactorisation f) ≫ image.ι f = F.m 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasImage f] {F : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F)
Goal: hF.lift (CategoryTheory.Limits.Image.monoFactorisation f) ≫ CategoryTheory.Limits.image.ι f = F.m
-- CategoryTheory.Limits.HasImage.uniq
theorem HasImage.uniq (F' : MonoFactorisation f) (l : image f ⟶ F'.I) (w : l ≫ F'.m = image.ι f) :
    l = image.lift F' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.Limits.HasImage f] (F' : CategoryTheory.Limits.MonoFactorisation f) (l : CategoryTheory.Limits.image f ⟶ F'.I) (w : l ≫ F'.m = CategoryTheory.Limits.image.ι f)
Goal: l = CategoryTheory.Limits.image.lift F'
-- CategoryTheory.Limits.HasImages.has_image
class HasImages : Prop where
  has_image : ∀ {X Y : C} (f : X ⟶ Y), HasImage f
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] [self : CategoryTheory.Limits.HasImages C] {X Y : C} (f : X ⟶ Y)
Goal: CategoryTheory.Limits.HasImage f
-- CategoryTheory.Limits.imageMonoIsoSource_inv_ι
@[reassoc (attr := simp)]
theorem imageMonoIsoSource_inv_ι [Mono f] : (imageMonoIsoSource f).inv ≫ image.ι f = f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: (CategoryTheory.Limits.imageMonoIsoSource f).inv ≫ CategoryTheory.Limits.image.ι f = f
-- CategoryTheory.Limits.imageMonoIsoSource_hom_self
@[reassoc (attr := simp)]
theorem imageMonoIsoSource_hom_self [Mono f] : (imageMonoIsoSource f).hom ≫ f = image.ι f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Mono f]
Goal: (CategoryTheory.Limits.imageMonoIsoSource f).hom ≫ f = CategoryTheory.Limits.image.ι f
-- CategoryTheory.Limits.image.ext
@[ext]
theorem image.ext [HasImage f] {W : C} {g h : image f ⟶ W} [HasLimit (parallelPair g h)]
    (w : factorThruImage f ≫ g = factorThruImage f ≫ h) : g = h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] {W : C} {g h : CategoryTheory.Limits.image f ⟶ W} [CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.parallelPair g h)] (w : CategoryTheory.Limits.factorThruImage f ≫ g = CategoryTheory.Limits.factorThruImage f ≫ h)
Goal: g = h
-- CategoryTheory.Limits.epi_image_of_epi
theorem epi_image_of_epi {X Y : C} (f : X ⟶ Y) [HasImage f] [E : Epi f] : Epi (image.ι f) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] [E : CategoryTheory.Epi f]
Goal: CategoryTheory.Epi (CategoryTheory.Limits.image.ι f)
-- CategoryTheory.Limits.epi_of_epi_image
theorem epi_of_epi_image {X Y : C} (f : X ⟶ Y) [HasImage f] [Epi (image.ι f)]
    [Epi (factorThruImage f)] : Epi f 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Limits.HasImage f] [CategoryTheory.Epi (CategoryTheory.Limits.image.ι f)] [CategoryTheory.Epi (CategoryTheory.Limits.factorThruImage f)]
Goal: CategoryTheory.Epi f
-- CategoryTheory.Limits.image.eq_fac
theorem image.eq_fac [HasEqualizers C] (h : f = f') :
    image.ι f = (image.eqToIso h).hom ≫ image.ι f' 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} {f f' : X ⟶ Y} [CategoryTheory.Limits.HasImage f] [CategoryTheory.Limits.HasImage f'] [CategoryTheory.Limits.HasEqualizers C] (h : f = f')
Goal: CategoryTheory.Limits.image.ι f = (CategoryTheory.Limits.image.eqToIso h).hom ≫ CategoryTheory.Limits.image.ι f'
-- CategoryTheory.Limits.image.preComp_ι
@[reassoc (attr := simp)]
theorem image.preComp_ι [HasImage g] [HasImage (f ≫ g)] :
    image.preComp f g ≫ image.ι g = image.ι (f ≫ g) 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) {Z : C} (g : Y ⟶ Z) [CategoryTheory.Limits.HasImage g] [CategoryTheory.Limits.HasImage (f ≫ g)]
Goal: CategoryTheory.Limits.image.preComp f g ≫ CategoryTheory.Limits.image.ι g = CategoryTheory.Limits.image.ι (f ≫ g)
-- CategoryTheory.Limits.image.factorThruImage_preComp
@[reassoc (attr := simp)]
theorem image.factorThruImage_preComp [HasImage g] [HasImage (f ≫ g)] :
    factorThruImage (f ≫ g) ≫ image.preComp f g = f ≫ factorThruImage g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) {Z : C} (g : Y ⟶ Z) [CategoryTheory.Limits.HasImage g] [CategoryTheory.Limits.HasImage (f ≫ g)]
Goal: CategoryTheory.Limits.factorThruImage (f ≫ g) ≫ CategoryTheory.Limits.image.preComp f g =
  f ≫ CategoryTheory.Limits.factorThruImage g
-- CategoryTheory.Limits.image.preComp_comp
theorem image.preComp_comp {W : C} (h : Z ⟶ W) [HasImage (g ≫ h)] [HasImage (f ≫ g ≫ h)]
    [HasImage h] [HasImage ((f ≫ g) ≫ h)] :
    image.preComp f (g ≫ h) ≫ image.preComp g h =
      image.eqToHom (Category.assoc f g h).symm ≫ image.preComp (f ≫ g) h 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) {Z : C} (g : Y ⟶ Z) {W : C} (h : Z ⟶ W) [CategoryTheory.Limits.HasImage (g ≫ h)] [CategoryTheory.Limits.HasImage (f ≫ g ≫ h)] [CategoryTheory.Limits.HasImage h] [CategoryTheory.Limits.HasImage ((f ≫ g) ≫ h)]
Goal: CategoryTheory.Limits.image.preComp f (g ≫ h) ≫ CategoryTheory.Limits.image.preComp g h =
  CategoryTheory.Limits.image.eqToHom ⋯ ≫ CategoryTheory.Limits.image.preComp (f ≫ g) h
-- CategoryTheory.Limits.image.compIso_hom_comp_image_ι
@[reassoc (attr := simp)]
theorem image.compIso_hom_comp_image_ι [HasImage f] [IsIso g] :
    (image.compIso f g).hom ≫ image.ι (f ≫ g) = image.ι f ≫ g 
Arguments: {C : Type u} [CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) {Z : C} (g : Y ⟶ Z) [CategoryTheory.Limits.HasEqualizers C] [CategoryTheory.Limits.HasImage f] [CategoryTheory.IsIso g]
Goal: (CategoryTheory.Limits.image.compIso f g).hom ≫ CategoryTheory.Limits.image.ι (f ≫ g) =
  CategoryTheory.Limits.image.ι f ≫ g