File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

full_name: CategoryTheory.Limits.MonoFactorisation.m_mono
code: /-- A factorisation of a morphism `f = e ≫ m`, with `m` monic. -/
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
goal: CategoryTheory.Mono self.m

full_name: CategoryTheory.Limits.MonoFactorisation.e
code: /-- A factorisation of a morphism `f = e ≫ m`, with `m` monic. -/
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
goal: X ⟶ self.I

full_name: CategoryTheory.Limits.MonoFactorisation
code: /-- A factorisation of a morphism `f = e ≫ m`, with `m` monic. -/
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
goal: Type (max u v)

full_name: CategoryTheory.Limits.MonoFactorisation.m
code: /-- A factorisation of a morphism `f = e ≫ m`, with `m` monic. -/
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
goal: self.I ⟶ Y

full_name: CategoryTheory.Limits.MonoFactorisation.I
code: /-- A factorisation of a morphism `f = e ≫ m`, with `m` monic. -/
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
goal: C

full_name: CategoryTheory.Limits.MonoFactorisation.fac
code: /-- A factorisation of a morphism `f = e ≫ m`, with `m` monic. -/
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
goal: self.e ≫ self.m = f

full_name: CategoryTheory.Limits.MonoFactorisation.self
code: /-- The obvious factorisation of a monomorphism through itself. -/
def self [Mono f] : MonoFactorisation f 
goal: CategoryTheory.Limits.MonoFactorisation f

full_name: CategoryTheory.Limits.MonoFactorisation.instInhabitedOfMono
code: instance [Mono f] : Inhabited (MonoFactorisation f) 
goal: Inhabited (CategoryTheory.Limits.MonoFactorisation f)

full_name: CategoryTheory.Limits.MonoFactorisation.ext
code: /-- The morphism `m` in a factorisation `f = e ≫ m` through a monomorphism is uniquely
determined. -/
@[ext]
theorem ext {F F' : MonoFactorisation f} (hI : F.I = F'.I)
    (hm : F.m = eqToHom hI ≫ F'.m) : F = F' 
goal: F = F'

full_name: CategoryTheory.Limits.MonoFactorisation.compMono
code: /-- Any mono factorisation of `f` gives a mono factorisation of `f ≫ g` when `g` is a mono. -/
@[simps]
def compMono (F : MonoFactorisation f) {Y' : C} (g : Y ⟶ Y') [Mono g] :
    MonoFactorisation (f ≫ g) 
goal: CategoryTheory.Limits.MonoFactorisation (f ≫ g)

full_name: CategoryTheory.Limits.MonoFactorisation.compMono_I
code: /-- Any mono factorisation of `f` gives a mono factorisation of `f ≫ g` when `g` is a mono. -/
@[simps]
def compMono (F : MonoFactorisation f) {Y' : C} (g : Y ⟶ Y') [Mono g] :
    MonoFactorisation (f ≫ g) 
goal: (F.compMono g).I = F.I

full_name: CategoryTheory.Limits.MonoFactorisation.compMono_e
code: /-- Any mono factorisation of `f` gives a mono factorisation of `f ≫ g` when `g` is a mono. -/
@[simps]
def compMono (F : MonoFactorisation f) {Y' : C} (g : Y ⟶ Y') [Mono g] :
    MonoFactorisation (f ≫ g) 
goal: (F.compMono g).e = F.e

full_name: CategoryTheory.Limits.MonoFactorisation.compMono_m
code: /-- Any mono factorisation of `f` gives a mono factorisation of `f ≫ g` when `g` is a mono. -/
@[simps]
def compMono (F : MonoFactorisation f) {Y' : C} (g : Y ⟶ Y') [Mono g] :
    MonoFactorisation (f ≫ g) 
goal: (F.compMono g).m = F.m ≫ g

full_name: CategoryTheory.Limits.MonoFactorisation.ofCompIso
code: /-- A mono factorisation of `f ≫ g`, where `g` is an isomorphism,
gives a mono factorisation of `f`. -/
@[simps]
def ofCompIso {Y' : C} {g : Y ⟶ Y'} [IsIso g] (F : MonoFactorisation (f ≫ g)) :
    MonoFactorisation f 
goal: CategoryTheory.Limits.MonoFactorisation f

full_name: CategoryTheory.Limits.MonoFactorisation.ofCompIso_e
code: /-- A mono factorisation of `f ≫ g`, where `g` is an isomorphism,
gives a mono factorisation of `f`. -/
@[simps]
def ofCompIso {Y' : C} {g : Y ⟶ Y'} [IsIso g] (F : MonoFactorisation (f ≫ g)) :
    MonoFactorisation f 
goal: F.ofCompIso.e = F.e

full_name: CategoryTheory.Limits.MonoFactorisation.ofCompIso_m
code: /-- A mono factorisation of `f ≫ g`, where `g` is an isomorphism,
gives a mono factorisation of `f`. -/
@[simps]
def ofCompIso {Y' : C} {g : Y ⟶ Y'} [IsIso g] (F : MonoFactorisation (f ≫ g)) :
    MonoFactorisation f 
goal: F.ofCompIso.m = F.m ≫ CategoryTheory.inv g

full_name: CategoryTheory.Limits.MonoFactorisation.ofCompIso_I
code: /-- A mono factorisation of `f ≫ g`, where `g` is an isomorphism,
gives a mono factorisation of `f`. -/
@[simps]
def ofCompIso {Y' : C} {g : Y ⟶ Y'} [IsIso g] (F : MonoFactorisation (f ≫ g)) :
    MonoFactorisation f 
goal: F.ofCompIso.I = F.I

full_name: CategoryTheory.Limits.MonoFactorisation.isoComp_e
code: /-- Any mono factorisation of `f` gives a mono factorisation of `g ≫ f`. -/
@[simps]
def isoComp (F : MonoFactorisation f) {X' : C} (g : X' ⟶ X) : MonoFactorisation (g ≫ f) 
goal: (F.isoComp g).e = g ≫ F.e

full_name: CategoryTheory.Limits.MonoFactorisation.isoComp_I
code: /-- Any mono factorisation of `f` gives a mono factorisation of `g ≫ f`. -/
@[simps]
def isoComp (F : MonoFactorisation f) {X' : C} (g : X' ⟶ X) : MonoFactorisation (g ≫ f) 
goal: (F.isoComp g).I = F.I

full_name: CategoryTheory.Limits.MonoFactorisation.isoComp_m
code: /-- Any mono factorisation of `f` gives a mono factorisation of `g ≫ f`. -/
@[simps]
def isoComp (F : MonoFactorisation f) {X' : C} (g : X' ⟶ X) : MonoFactorisation (g ≫ f) 
goal: (F.isoComp g).m = F.m

full_name: CategoryTheory.Limits.MonoFactorisation.isoComp
code: /-- Any mono factorisation of `f` gives a mono factorisation of `g ≫ f`. -/
@[simps]
def isoComp (F : MonoFactorisation f) {X' : C} (g : X' ⟶ X) : MonoFactorisation (g ≫ f) 
goal: CategoryTheory.Limits.MonoFactorisation (g ≫ f)

full_name: CategoryTheory.Limits.MonoFactorisation.ofIsoComp_e
code: /-- A mono factorisation of `g ≫ f`, where `g` is an isomorphism,
gives a mono factorisation of `f`. -/
@[simps]
def ofIsoComp {X' : C} (g : X' ⟶ X) [IsIso g] (F : MonoFactorisation (g ≫ f)) :
    MonoFactorisation f 
goal: (CategoryTheory.Limits.MonoFactorisation.ofIsoComp g F).e = CategoryTheory.inv g ≫ F.e

full_name: CategoryTheory.Limits.MonoFactorisation.ofIsoComp_I
code: /-- A mono factorisation of `g ≫ f`, where `g` is an isomorphism,
gives a mono factorisation of `f`. -/
@[simps]
def ofIsoComp {X' : C} (g : X' ⟶ X) [IsIso g] (F : MonoFactorisation (g ≫ f)) :
    MonoFactorisation f 
goal: (CategoryTheory.Limits.MonoFactorisation.ofIsoComp g F).I = F.I

full_name: CategoryTheory.Limits.MonoFactorisation.ofIsoComp_m
code: /-- A mono factorisation of `g ≫ f`, where `g` is an isomorphism,
gives a mono factorisation of `f`. -/
@[simps]
def ofIsoComp {X' : C} (g : X' ⟶ X) [IsIso g] (F : MonoFactorisation (g ≫ f)) :
    MonoFactorisation f 
goal: (CategoryTheory.Limits.MonoFactorisation.ofIsoComp g F).m = F.m

full_name: CategoryTheory.Limits.MonoFactorisation.ofIsoComp
code: /-- A mono factorisation of `g ≫ f`, where `g` is an isomorphism,
gives a mono factorisation of `f`. -/
@[simps]
def ofIsoComp {X' : C} (g : X' ⟶ X) [IsIso g] (F : MonoFactorisation (g ≫ f)) :
    MonoFactorisation f 
goal: CategoryTheory.Limits.MonoFactorisation f

full_name: CategoryTheory.Limits.MonoFactorisation.ofArrowIso_e
code: /-- If `f` and `g` are isomorphic arrows, then a mono factorisation of `f`
gives a mono factorisation of `g` -/
@[simps]
def ofArrowIso {f g : Arrow C} (F : MonoFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    MonoFactorisation g.hom 
goal: (F.ofArrowIso sq).e = CategoryTheory.inv sq.left ≫ F.e

full_name: CategoryTheory.Limits.MonoFactorisation.ofArrowIso_m
code: /-- If `f` and `g` are isomorphic arrows, then a mono factorisation of `f`
gives a mono factorisation of `g` -/
@[simps]
def ofArrowIso {f g : Arrow C} (F : MonoFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    MonoFactorisation g.hom 
goal: (F.ofArrowIso sq).m = F.m ≫ sq.right

full_name: CategoryTheory.Limits.MonoFactorisation.ofArrowIso
code: /-- If `f` and `g` are isomorphic arrows, then a mono factorisation of `f`
gives a mono factorisation of `g` -/
@[simps]
def ofArrowIso {f g : Arrow C} (F : MonoFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    MonoFactorisation g.hom 
goal: CategoryTheory.Limits.MonoFactorisation g.hom

full_name: CategoryTheory.Limits.MonoFactorisation.ofArrowIso_I
code: /-- If `f` and `g` are isomorphic arrows, then a mono factorisation of `f`
gives a mono factorisation of `g` -/
@[simps]
def ofArrowIso {f g : Arrow C} (F : MonoFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    MonoFactorisation g.hom 
goal: (F.ofArrowIso sq).I = F.I

full_name: CategoryTheory.Limits.IsImage
code: /-- Data exhibiting that a given factorisation through a mono is initial. -/
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
goal: Type (max u v)

full_name: CategoryTheory.Limits.IsImage.lift
code: /-- Data exhibiting that a given factorisation through a mono is initial. -/
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
goal: F.I ⟶ F'.I

full_name: CategoryTheory.Limits.IsImage.lift_fac
code: /-- Data exhibiting that a given factorisation through a mono is initial. -/
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
goal: self.lift F' ≫ F'.m = F.m

full_name: CategoryTheory.Limits.IsImage.fac_lift
code: @[reassoc (attr := simp)]
theorem fac_lift {F : MonoFactorisation f} (hF : IsImage F) (F' : MonoFactorisation f) :
    F.e ≫ hF.lift F' = F'.e 
goal: F.e ≫ hF.lift F' = F'.e

full_name: CategoryTheory.Limits.IsImage.self
code: /-- The trivial factorisation of a monomorphism satisfies the universal property. -/
@[simps]
def self [Mono f] : IsImage (MonoFactorisation.self f) 
goal: CategoryTheory.Limits.IsImage (CategoryTheory.Limits.MonoFactorisation.self f)

full_name: CategoryTheory.Limits.IsImage.self_lift
code: /-- The trivial factorisation of a monomorphism satisfies the universal property. -/
@[simps]
def self [Mono f] : IsImage (MonoFactorisation.self f) 
goal: (CategoryTheory.Limits.IsImage.self f).lift F' = F'.e

full_name: CategoryTheory.Limits.IsImage.instInhabitedSelf
code: instance [Mono f] : Inhabited (IsImage (MonoFactorisation.self f)) 
goal: Inhabited (CategoryTheory.Limits.IsImage (CategoryTheory.Limits.MonoFactorisation.self f))

full_name: CategoryTheory.Limits.IsImage.isoExt
code: /-- Two factorisations through monomorphisms satisfying the universal property
must factor through isomorphic objects. -/
@[simps]
def isoExt {F F' : MonoFactorisation f} (hF : IsImage F) (hF' : IsImage F') :
    F.I ≅ F'.I 
goal: F.I ≅ F'.I

full_name: CategoryTheory.Limits.IsImage.isoExt_inv
code: /-- Two factorisations through monomorphisms satisfying the universal property
must factor through isomorphic objects. -/
@[simps]
def isoExt {F F' : MonoFactorisation f} (hF : IsImage F) (hF' : IsImage F') :
    F.I ≅ F'.I 
goal: (hF.isoExt hF').inv = hF'.lift F

full_name: CategoryTheory.Limits.IsImage.isoExt_hom
code: /-- Two factorisations through monomorphisms satisfying the universal property
must factor through isomorphic objects. -/
@[simps]
def isoExt {F F' : MonoFactorisation f} (hF : IsImage F) (hF' : IsImage F') :
    F.I ≅ F'.I 
goal: (hF.isoExt hF').hom = hF.lift F'

full_name: CategoryTheory.Limits.IsImage.isoExt_hom_m
code: theorem isoExt_hom_m : (isoExt hF hF').hom ≫ F'.m = F.m 
goal: (hF.isoExt hF').hom ≫ F'.m = F.m

full_name: CategoryTheory.Limits.IsImage.isoExt_inv_m
code: theorem isoExt_inv_m : (isoExt hF hF').inv ≫ F.m = F'.m 
goal: (hF.isoExt hF').inv ≫ F.m = F'.m

full_name: CategoryTheory.Limits.IsImage.e_isoExt_hom
code: theorem e_isoExt_hom : F.e ≫ (isoExt hF hF').hom = F'.e 
goal: F.e ≫ (hF.isoExt hF').hom = F'.e

full_name: CategoryTheory.Limits.IsImage.e_isoExt_inv
code: theorem e_isoExt_inv : F'.e ≫ (isoExt hF hF').inv = F.e 
goal: F'.e ≫ (hF.isoExt hF').inv = F.e

full_name: CategoryTheory.Limits.IsImage.ofArrowIso
code: /-- If `f` and `g` are isomorphic arrows, then a mono factorisation of `f` that is an image
gives a mono factorisation of `g` that is an image -/
@[simps]
def ofArrowIso {f g : Arrow C} {F : MonoFactorisation f.hom} (hF : IsImage F) (sq : f ⟶ g)
    [IsIso sq] : IsImage (F.ofArrowIso sq) 
goal: CategoryTheory.Limits.IsImage (F.ofArrowIso sq)

full_name: CategoryTheory.Limits.IsImage.ofArrowIso_lift
code: /-- If `f` and `g` are isomorphic arrows, then a mono factorisation of `f` that is an image
gives a mono factorisation of `g` that is an image -/
@[simps]
def ofArrowIso {f g : Arrow C} {F : MonoFactorisation f.hom} (hF : IsImage F) (sq : f ⟶ g)
    [IsIso sq] : IsImage (F.ofArrowIso sq) 
goal: (hF.ofArrowIso sq).lift F' = hF.lift (F'.ofArrowIso (CategoryTheory.inv sq))

full_name: CategoryTheory.Limits.ImageFactorisation.isImage
code: /-- Data exhibiting that a morphism `f` has an image. -/
structure ImageFactorisation (f : X ⟶ Y) where
  F : MonoFactorisation f -- Porting note: another violation of the naming convention
  isImage : IsImage F
goal: CategoryTheory.Limits.IsImage self.F

full_name: CategoryTheory.Limits.ImageFactorisation
code: /-- Data exhibiting that a morphism `f` has an image. -/
structure ImageFactorisation (f : X ⟶ Y) where
  F : MonoFactorisation f -- Porting note: another violation of the naming convention
  isImage : IsImage F
goal: Type (max u v)

full_name: CategoryTheory.Limits.ImageFactorisation.F
code: /-- Data exhibiting that a morphism `f` has an image. -/
structure ImageFactorisation (f : X ⟶ Y) where
  F : MonoFactorisation f -- Porting note: another violation of the naming convention
  isImage : IsImage F
goal: CategoryTheory.Limits.MonoFactorisation f

full_name: CategoryTheory.Limits.ImageFactorisation.instInhabitedOfMono
code: instance [Mono f] : Inhabited (ImageFactorisation f) 
goal: Inhabited (CategoryTheory.Limits.ImageFactorisation f)

full_name: CategoryTheory.Limits.ImageFactorisation.ofArrowIso_F
code: /-- If `f` and `g` are isomorphic arrows, then an image factorisation of `f`
gives an image factorisation of `g` -/
@[simps]
def ofArrowIso {f g : Arrow C} (F : ImageFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    ImageFactorisation g.hom 
goal: (F.ofArrowIso sq).F = F.F.ofArrowIso sq

full_name: CategoryTheory.Limits.ImageFactorisation.ofArrowIso
code: /-- If `f` and `g` are isomorphic arrows, then an image factorisation of `f`
gives an image factorisation of `g` -/
@[simps]
def ofArrowIso {f g : Arrow C} (F : ImageFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    ImageFactorisation g.hom 
goal: CategoryTheory.Limits.ImageFactorisation g.hom

full_name: CategoryTheory.Limits.ImageFactorisation.ofArrowIso_isImage
code: /-- If `f` and `g` are isomorphic arrows, then an image factorisation of `f`
gives an image factorisation of `g` -/
@[simps]
def ofArrowIso {f g : Arrow C} (F : ImageFactorisation f.hom) (sq : f ⟶ g) [IsIso sq] :
    ImageFactorisation g.hom 
goal: (F.ofArrowIso sq).isImage = F.isImage.ofArrowIso sq

full_name: CategoryTheory.Limits.HasImage
code: /-- `has_image f` means that there exists an image factorisation of `f`. -/
class HasImage (f : X ⟶ Y) : Prop where mk' ::
  exists_image : Nonempty (ImageFactorisation f)
goal: Prop

full_name: CategoryTheory.Limits.HasImage.exists_image
code: /-- `has_image f` means that there exists an image factorisation of `f`. -/
class HasImage (f : X ⟶ Y) : Prop where mk' ::
  exists_image : Nonempty (ImageFactorisation f)
goal: Nonempty (CategoryTheory.Limits.ImageFactorisation f)

full_name: CategoryTheory.Limits.HasImage.mk'
code: /-- `has_image f` means that there exists an image factorisation of `f`. -/
class HasImage (f : X ⟶ Y) : Prop where mk' ::
  exists_image : Nonempty (ImageFactorisation f)
goal: CategoryTheory.Limits.HasImage f

full_name: CategoryTheory.Limits.HasImage.mk
code: theorem HasImage.mk {f : X ⟶ Y} (F : ImageFactorisation f) : HasImage f 
goal: CategoryTheory.Limits.HasImage f

full_name: CategoryTheory.Limits.HasImage.of_arrow_iso
code: theorem HasImage.of_arrow_iso {f g : Arrow C} [h : HasImage f.hom] (sq : f ⟶ g) [IsIso sq] :
    HasImage g.hom 
goal: CategoryTheory.Limits.HasImage g.hom

full_name: CategoryTheory.Limits.mono_hasImage
code: instance (priority := 100) mono_hasImage (f : X ⟶ Y) [Mono f] : HasImage f 
goal: CategoryTheory.Limits.HasImage f

full_name: CategoryTheory.Limits.Image.monoFactorisation
code: /-- Some factorisation of `f` through a monomorphism (selected with choice). -/
def Image.monoFactorisation : MonoFactorisation f 
goal: CategoryTheory.Limits.MonoFactorisation f

full_name: CategoryTheory.Limits.Image.isImage
code: /-- The witness of the universal property for the chosen factorisation of `f` through
a monomorphism. -/
def Image.isImage : IsImage (Image.monoFactorisation f) 
goal: CategoryTheory.Limits.IsImage (CategoryTheory.Limits.Image.monoFactorisation f)

full_name: CategoryTheory.Limits.image
code: /-- The categorical image of a morphism. -/
def image : C 
goal: C

full_name: CategoryTheory.Limits.image.ι
code: /-- The inclusion of the image of a morphism into the target. -/
def image.ι : image f ⟶ Y 
goal: CategoryTheory.Limits.image f ⟶ Y

full_name: CategoryTheory.Limits.image.as_ι
code: @[simp]
theorem image.as_ι : (Image.monoFactorisation f).m = image.ι f 
goal: (CategoryTheory.Limits.Image.monoFactorisation f).m = CategoryTheory.Limits.image.ι f

full_name: CategoryTheory.Limits.instMonoι
code: instance : Mono (image.ι f) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.image.ι f)

full_name: CategoryTheory.Limits.factorThruImage
code: /-- The map from the source to the image of a morphism. -/
def factorThruImage : X ⟶ image f 
goal: X ⟶ CategoryTheory.Limits.image f

full_name: CategoryTheory.Limits.as_factorThruImage
code: /-- Rewrite in terms of the `factorThruImage` interface. -/
@[simp]
theorem as_factorThruImage : (Image.monoFactorisation f).e = factorThruImage f 
goal: (CategoryTheory.Limits.Image.monoFactorisation f).e = CategoryTheory.Limits.factorThruImage f

full_name: CategoryTheory.Limits.image.fac
code: @[reassoc (attr := simp)]
theorem image.fac : factorThruImage f ≫ image.ι f = f 
goal: CategoryTheory.Limits.factorThruImage f ≫ CategoryTheory.Limits.image.ι f = f

full_name: CategoryTheory.Limits.image.lift
code: /-- Any other factorisation of the morphism `f` through a monomorphism receives a map from the
image. -/
def image.lift (F' : MonoFactorisation f) : image f ⟶ F'.I 
goal: CategoryTheory.Limits.image f ⟶ F'.I

full_name: CategoryTheory.Limits.image.lift_fac
code: @[reassoc (attr := simp)]
theorem image.lift_fac (F' : MonoFactorisation f) : image.lift F' ≫ F'.m = image.ι f 
goal: CategoryTheory.Limits.image.lift F' ≫ F'.m = CategoryTheory.Limits.image.ι f

full_name: CategoryTheory.Limits.image.fac_lift
code: @[reassoc (attr := simp)]
theorem image.fac_lift (F' : MonoFactorisation f) : factorThruImage f ≫ image.lift F' = F'.e 
goal: CategoryTheory.Limits.factorThruImage f ≫ CategoryTheory.Limits.image.lift F' = F'.e

full_name: CategoryTheory.Limits.image.isImage_lift
code: @[simp]
theorem image.isImage_lift (F : MonoFactorisation f) : (Image.isImage f).lift F = image.lift F 
goal: (CategoryTheory.Limits.Image.isImage f).lift F = CategoryTheory.Limits.image.lift F

full_name: CategoryTheory.Limits.IsImage.lift_ι
code: @[reassoc (attr := simp)]
theorem IsImage.lift_ι {F : MonoFactorisation f} (hF : IsImage F) :
    hF.lift (Image.monoFactorisation f) ≫ image.ι f = F.m 
goal: hF.lift (CategoryTheory.Limits.Image.monoFactorisation f) ≫ CategoryTheory.Limits.image.ι f = F.m

full_name: CategoryTheory.Limits.image.lift_mono
code: instance image.lift_mono (F' : MonoFactorisation f) : Mono (image.lift F') 
goal: CategoryTheory.Mono (CategoryTheory.Limits.image.lift F')

full_name: CategoryTheory.Limits.HasImage.uniq
code: theorem HasImage.uniq (F' : MonoFactorisation f) (l : image f ⟶ F'.I) (w : l ≫ F'.m = image.ι f) :
    l = image.lift F' 
goal: l = CategoryTheory.Limits.image.lift F'

full_name: CategoryTheory.Limits.instHasImageCompOfIsIso
code: /-- If `has_image g`, then `has_image (f ≫ g)` when `f` is an isomorphism. -/
instance {X Y Z : C} (f : X ⟶ Y) [IsIso f] (g : Y ⟶ Z) [HasImage g] : HasImage (f ≫ g) 
goal: CategoryTheory.Limits.HasImage (f ≫ g)

full_name: CategoryTheory.Limits.HasImages.has_image
code: /-- `HasImages` asserts that every morphism has an image. -/
class HasImages : Prop where
  has_image : ∀ {X Y : C} (f : X ⟶ Y), HasImage f
goal: CategoryTheory.Limits.HasImage f

full_name: CategoryTheory.Limits.HasImages
code: /-- `HasImages` asserts that every morphism has an image. -/
class HasImages : Prop where
  has_image : ∀ {X Y : C} (f : X ⟶ Y), HasImage f
goal: Prop

full_name: CategoryTheory.Limits.imageMonoIsoSource
code: /-- The image of a monomorphism is isomorphic to the source. -/
def imageMonoIsoSource [Mono f] : image f ≅ X 
goal: CategoryTheory.Limits.image f ≅ X

full_name: CategoryTheory.Limits.imageMonoIsoSource_inv_ι
code: @[reassoc (attr := simp)]
theorem imageMonoIsoSource_inv_ι [Mono f] : (imageMonoIsoSource f).inv ≫ image.ι f = f 
goal: (CategoryTheory.Limits.imageMonoIsoSource f).inv ≫ CategoryTheory.Limits.image.ι f = f

full_name: CategoryTheory.Limits.imageMonoIsoSource_hom_self
code: @[reassoc (attr := simp)]
theorem imageMonoIsoSource_hom_self [Mono f] : (imageMonoIsoSource f).hom ≫ f = image.ι f 
goal: (CategoryTheory.Limits.imageMonoIsoSource f).hom ≫ f = CategoryTheory.Limits.image.ι f

full_name: CategoryTheory.Limits.image.ext
code: @[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 
goal: g = h

full_name: CategoryTheory.Limits.instEpiFactorThruImageOfHasLimitWalkingParallelPairParallelPair
code: instance [HasImage f] [∀ {Z : C} (g h : image f ⟶ Z), HasLimit (parallelPair g h)] :
    Epi (factorThruImage f) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.factorThruImage f)

full_name: CategoryTheory.Limits.epi_image_of_epi
code: theorem epi_image_of_epi {X Y : C} (f : X ⟶ Y) [HasImage f] [E : Epi f] : Epi (image.ι f) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.image.ι f)

full_name: CategoryTheory.Limits.epi_of_epi_image
code: theorem epi_of_epi_image {X Y : C} (f : X ⟶ Y) [HasImage f] [Epi (image.ι f)]
    [Epi (factorThruImage f)] : Epi f 
goal: CategoryTheory.Epi f

full_name: CategoryTheory.Limits.image.eqToHom
code: /-- An equation between morphisms gives a comparison map between the images
(which momentarily we prove is an iso).
-/
def image.eqToHom (h : f = f') : image f ⟶ image f' 
goal: CategoryTheory.Limits.image f ⟶ CategoryTheory.Limits.image f'

full_name: CategoryTheory.Limits.instIsIsoEqToHom
code: instance (h : f = f') : IsIso (image.eqToHom h) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.image.eqToHom h)

full_name: CategoryTheory.Limits.image.eqToIso
code: /-- An equation between morphisms gives an isomorphism between the images. -/
def image.eqToIso (h : f = f') : image f ≅ image f' 
goal: CategoryTheory.Limits.image f ≅ CategoryTheory.Limits.image f'

full_name: CategoryTheory.Limits.image.eq_fac
code: /-- As long as the category has equalizers,
the image inclusion maps commute with `image.eqToIso`.
-/
theorem image.eq_fac [HasEqualizers C] (h : f = f') :
    image.ι f = (image.eqToIso h).hom ≫ image.ι f' 
goal: CategoryTheory.Limits.image.ι f = (CategoryTheory.Limits.image.eqToIso h).hom ≫ CategoryTheory.Limits.image.ι f'

full_name: CategoryTheory.Limits.image.preComp
code: /-- The comparison map `image (f ≫ g) ⟶ image g`. -/
def image.preComp [HasImage g] [HasImage (f ≫ g)] : image (f ≫ g) ⟶ image g 
goal: CategoryTheory.Limits.image (f ≫ g) ⟶ CategoryTheory.Limits.image g

full_name: CategoryTheory.Limits.image.preComp_ι
code: @[reassoc (attr := simp)]
theorem image.preComp_ι [HasImage g] [HasImage (f ≫ g)] :
    image.preComp f g ≫ image.ι g = image.ι (f ≫ g) 
goal: CategoryTheory.Limits.image.preComp f g ≫ CategoryTheory.Limits.image.ι g = CategoryTheory.Limits.image.ι (f ≫ g)

full_name: CategoryTheory.Limits.image.factorThruImage_preComp
code: @[reassoc (attr := simp)]
theorem image.factorThruImage_preComp [HasImage g] [HasImage (f ≫ g)] :
    factorThruImage (f ≫ g) ≫ image.preComp f g = f ≫ factorThruImage g 
goal: CategoryTheory.Limits.factorThruImage (f ≫ g) ≫ CategoryTheory.Limits.image.preComp f g =
  f ≫ CategoryTheory.Limits.factorThruImage g

full_name: CategoryTheory.Limits.image.preComp_mono
code: /-- `image.preComp f g` is a monomorphism.
-/
instance image.preComp_mono [HasImage g] [HasImage (f ≫ g)] : Mono (image.preComp f g) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.image.preComp f g)

full_name: CategoryTheory.Limits.image.preComp_comp
code: /-- The two step comparison map
  `image (f ≫ (g ≫ h)) ⟶ image (g ≫ h) ⟶ image h`
agrees with the one step comparison map
  `image (f ≫ (g ≫ h)) ≅ image ((f ≫ g) ≫ h) ⟶ image h`.
 -/
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 
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

full_name: CategoryTheory.Limits.image.preComp_epi_of_epi
code: /-- `image.preComp f g` is an epimorphism when `f` is an epimorphism
(we need `C` to have equalizers to prove this).
-/
instance image.preComp_epi_of_epi [HasImage g] [HasImage (f ≫ g)] [Epi f] :
    Epi (image.preComp f g) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.image.preComp f g)

full_name: CategoryTheory.Limits.hasImage_iso_comp
code: instance hasImage_iso_comp [IsIso f] [HasImage g] : HasImage (f ≫ g) 
goal: CategoryTheory.Limits.HasImage (f ≫ g)

full_name: CategoryTheory.Limits.image.isIso_precomp_iso
code: /-- `image.preComp f g` is an isomorphism when `f` is an isomorphism
(we need `C` to have equalizers to prove this).
-/
instance image.isIso_precomp_iso (f : X ⟶ Y) [IsIso f] [HasImage g] : IsIso (image.preComp f g) 
goal: CategoryTheory.IsIso (CategoryTheory.Limits.image.preComp f g)

full_name: CategoryTheory.Limits.hasImage_comp_iso
code: instance hasImage_comp_iso [HasImage f] [IsIso g] : HasImage (f ≫ g) 
goal: CategoryTheory.Limits.HasImage (f ≫ g)

full_name: CategoryTheory.Limits.image.compIso
code: /-- Postcomposing by an isomorphism induces an isomorphism on the image. -/
def image.compIso [HasImage f] [IsIso g] : image f ≅ image (f ≫ g) 
goal: CategoryTheory.Limits.image f ≅ CategoryTheory.Limits.image (f ≫ g)

full_name: CategoryTheory.Limits.image.compIso_hom_comp_image_ι
code: @[reassoc (attr := simp)]
theorem image.compIso_hom_comp_image_ι [HasImage f] [IsIso g] :
    (image.compIso f g).hom ≫ image.ι (f ≫ g) = image.ι f ≫ g 
goal: (CategoryTheory.Limits.image.compIso f g).hom ≫ CategoryTheory.Limits.image.ι (f ≫ g) =
  CategoryTheory.Limits.image.ι f ≫ g

full_name: CategoryTheory.Limits.image.compIso_inv_comp_image_ι
code: @[reassoc (attr := simp)]
theorem image.compIso_inv_comp_image_ι [HasImage f] [IsIso g] :
    (image.compIso f g).inv ≫ image.ι f = image.ι (f ≫ g) ≫ inv g 
goal: (CategoryTheory.Limits.image.compIso f g).inv ≫ CategoryTheory.Limits.image.ι f =
  CategoryTheory.Limits.image.ι (f ≫ g) ≫ CategoryTheory.inv g

full_name: CategoryTheory.Limits.instHasImageHomMk
code: instance {X Y : C} (f : X ⟶ Y) [HasImage f] : HasImage (Arrow.mk f).hom 
goal: CategoryTheory.Limits.HasImage (CategoryTheory.Arrow.mk f).hom

full_name: CategoryTheory.Limits.ImageMap.map
code: /-- An image map is a morphism `image f → image g` fitting into a commutative square and satisfying
    the obvious commutativity conditions. -/
structure ImageMap {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g) where
  map : image f.hom ⟶ image g.hom
  map_ι : map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right := by aesop
goal: CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom

full_name: CategoryTheory.Limits.ImageMap
code: /-- An image map is a morphism `image f → image g` fitting into a commutative square and satisfying
    the obvious commutativity conditions. -/
structure ImageMap {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g) where
  map : image f.hom ⟶ image g.hom
  map_ι : map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right := by aesop
goal: Type v

full_name: CategoryTheory.Limits.ImageMap.map_ι
code: /-- An image map is a morphism `image f → image g` fitting into a commutative square and satisfying
    the obvious commutativity conditions. -/
structure ImageMap {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g) where
  map : image f.hom ⟶ image g.hom
  map_ι : map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right := by aesop
goal: self.map ≫ CategoryTheory.Limits.image.ι g.hom = CategoryTheory.Limits.image.ι f.hom ≫ sq.right

full_name: CategoryTheory.Limits.inhabitedImageMap
code: instance inhabitedImageMap {f : Arrow C} [HasImage f.hom] : Inhabited (ImageMap (𝟙 f)) 
goal: Inhabited (CategoryTheory.Limits.ImageMap (𝟙 f))

full_name: CategoryTheory.Limits.ImageMap.factor_map
code: @[reassoc (attr := simp)]
theorem ImageMap.factor_map {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g)
    (m : ImageMap sq) : factorThruImage f.hom ≫ m.map = sq.left ≫ factorThruImage g.hom 
goal: CategoryTheory.Limits.factorThruImage f.hom ≫ m.map = sq.left ≫ CategoryTheory.Limits.factorThruImage g.hom

full_name: CategoryTheory.Limits.ImageMap.transport
code: /-- To give an image map for a commutative square with `f` at the top and `g` at the bottom, it
    suffices to give a map between any mono factorisation of `f` and any image factorisation of
    `g`. -/
def ImageMap.transport {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g)
    (F : MonoFactorisation f.hom) {F' : MonoFactorisation g.hom} (hF' : IsImage F')
    {map : F.I ⟶ F'.I} (map_ι : map ≫ F'.m = F.m ≫ sq.right) : ImageMap sq 
goal: CategoryTheory.Limits.ImageMap sq

full_name: CategoryTheory.Limits.HasImageMap.mk'
code: /-- `HasImageMap sq` means that there is an `ImageMap` for the square `sq`. -/
class HasImageMap {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g) : Prop where
mk' ::
  has_image_map : Nonempty (ImageMap sq)
goal: CategoryTheory.Limits.HasImageMap sq

full_name: CategoryTheory.Limits.HasImageMap
code: /-- `HasImageMap sq` means that there is an `ImageMap` for the square `sq`. -/
class HasImageMap {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g) : Prop where
mk' ::
  has_image_map : Nonempty (ImageMap sq)
goal: Prop

full_name: CategoryTheory.Limits.HasImageMap.has_image_map
code: /-- `HasImageMap sq` means that there is an `ImageMap` for the square `sq`. -/
class HasImageMap {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g) : Prop where
mk' ::
  has_image_map : Nonempty (ImageMap sq)
goal: Nonempty (CategoryTheory.Limits.ImageMap sq)

full_name: CategoryTheory.Limits.HasImageMap.mk
code: theorem HasImageMap.mk {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] {sq : f ⟶ g}
    (m : ImageMap sq) : HasImageMap sq 
goal: CategoryTheory.Limits.HasImageMap sq

full_name: CategoryTheory.Limits.HasImageMap.transport
code: theorem HasImageMap.transport {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g)
    (F : MonoFactorisation f.hom) {F' : MonoFactorisation g.hom} (hF' : IsImage F')
    (map : F.I ⟶ F'.I) (map_ι : map ≫ F'.m = F.m ≫ sq.right) : HasImageMap sq 
goal: CategoryTheory.Limits.HasImageMap sq

full_name: CategoryTheory.Limits.HasImageMap.imageMap
code: /-- Obtain an `ImageMap` from a `HasImageMap` instance. -/
def HasImageMap.imageMap {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] (sq : f ⟶ g)
    [HasImageMap sq] : ImageMap sq 
goal: CategoryTheory.Limits.ImageMap sq

full_name: CategoryTheory.Limits.hasImageMapOfIsIso
code: instance (priority := 100) hasImageMapOfIsIso {f g : Arrow C} [HasImage f.hom] [HasImage g.hom]
    (sq : f ⟶ g) [IsIso sq] : HasImageMap sq 
goal: CategoryTheory.Limits.HasImageMap sq

full_name: CategoryTheory.Limits.HasImageMap.comp
code: instance HasImageMap.comp {f g h : Arrow C} [HasImage f.hom] [HasImage g.hom] [HasImage h.hom]
    (sq1 : f ⟶ g) (sq2 : g ⟶ h) [HasImageMap sq1] [HasImageMap sq2] : HasImageMap (sq1 ≫ sq2) 
goal: CategoryTheory.Limits.HasImageMap (sq1 ≫ sq2)

full_name: CategoryTheory.Limits.ImageMap.map_uniq_aux
code: theorem ImageMap.map_uniq_aux {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] {sq : f ⟶ g}
    (map : image f.hom ⟶ image g.hom)
    (map_ι : map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right := by aesop_cat)
    (map' : image f.hom ⟶ image g.hom)
    (map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) : (map = map') 
goal: map = map'

full_name: CategoryTheory.Limits.ImageMap.map_uniq
code: theorem ImageMap.map_uniq {f g : Arrow C} [HasImage f.hom] [HasImage g.hom]
    {sq : f ⟶ g} (F G : ImageMap sq) : F.map = G.map 
goal: F.map = G.map

full_name: CategoryTheory.Limits.ImageMap.mk.injEq'
code: @[simp]
theorem ImageMap.mk.injEq' {f g : Arrow C} [HasImage f.hom] [HasImage g.hom] {sq : f ⟶ g}
    (map : image f.hom ⟶ image g.hom)
    (map_ι : map ≫ image.ι g.hom = image.ι f.hom ≫ sq.right := by aesop_cat)
    (map' : image f.hom ⟶ image g.hom)
    (map_ι' : map' ≫ image.ι g.hom = image.ι f.hom ≫ sq.right) : (map = map') = True 
goal: (map = map') = True

full_name: CategoryTheory.Limits.instSubsingletonImageMap
code: instance : Subsingleton (ImageMap sq) 
goal: Subsingleton (CategoryTheory.Limits.ImageMap sq)

full_name: CategoryTheory.Limits.image.map
code: /-- The map on images induced by a commutative square. -/
abbrev image.map : image f.hom ⟶ image g.hom 
goal: CategoryTheory.Limits.image f.hom ⟶ CategoryTheory.Limits.image g.hom

full_name: CategoryTheory.Limits.image.factor_map
code: theorem image.factor_map :
    factorThruImage f.hom ≫ image.map sq = sq.left ≫ factorThruImage g.hom 
goal: CategoryTheory.Limits.factorThruImage f.hom ≫ CategoryTheory.Limits.image.map sq =
  sq.left ≫ CategoryTheory.Limits.factorThruImage g.hom

full_name: CategoryTheory.Limits.image.map_ι
code: theorem image.map_ι : image.map sq ≫ image.ι g.hom = image.ι f.hom ≫ sq.right 
goal: CategoryTheory.Limits.image.map sq ≫ CategoryTheory.Limits.image.ι g.hom =
  CategoryTheory.Limits.image.ι f.hom ≫ sq.right

full_name: CategoryTheory.Limits.image.map_homMk'_ι
code: theorem image.map_homMk'_ι {X Y P Q : C} {k : X ⟶ Y} [HasImage k] {l : P ⟶ Q} [HasImage l]
    {m : X ⟶ P} {n : Y ⟶ Q} (w : m ≫ l = k ≫ n) [HasImageMap (Arrow.homMk' w)] :
    image.map (Arrow.homMk' w) ≫ image.ι l = image.ι k ≫ n 
goal: CategoryTheory.Limits.image.map (CategoryTheory.Arrow.homMk' w) ≫ CategoryTheory.Limits.image.ι l =
  CategoryTheory.Limits.image.ι k ≫ n

full_name: CategoryTheory.Limits.imageMapComp
code: /-- Image maps for composable commutative squares induce an image map in the composite square. -/
def imageMapComp : ImageMap (sq ≫ sq') 
goal: CategoryTheory.Limits.ImageMap (sq ≫ sq')

full_name: CategoryTheory.Limits.image.map_comp
code: @[simp]
theorem image.map_comp [HasImageMap (sq ≫ sq')] :
    image.map (sq ≫ sq') = image.map sq ≫ image.map sq' 
goal: CategoryTheory.Limits.image.map (sq ≫ sq') = CategoryTheory.Limits.image.map sq ≫ CategoryTheory.Limits.image.map sq'

full_name: CategoryTheory.Limits.imageMapId
code: /-- The identity `image f ⟶ image f` fits into the commutative square represented by the identity
    morphism `𝟙 f` in the arrow category. -/
def imageMapId : ImageMap (𝟙 f) 
goal: CategoryTheory.Limits.ImageMap (𝟙 f)

full_name: CategoryTheory.Limits.image.map_id
code: @[simp]
theorem image.map_id [HasImageMap (𝟙 f)] : image.map (𝟙 f) = 𝟙 (image f.hom) 
goal: CategoryTheory.Limits.image.map (𝟙 f) = 𝟙 (CategoryTheory.Limits.image f.hom)

full_name: CategoryTheory.Limits.HasImageMaps.has_image_map
code: /-- If a category `has_image_maps`, then all commutative squares induce morphisms on images. -/
class HasImageMaps : Prop where
  has_image_map : ∀ {f g : Arrow C} (st : f ⟶ g), HasImageMap st
goal: CategoryTheory.Limits.HasImageMap st

full_name: CategoryTheory.Limits.HasImageMaps
code: /-- If a category `has_image_maps`, then all commutative squares induce morphisms on images. -/
class HasImageMaps : Prop where
  has_image_map : ∀ {f g : Arrow C} (st : f ⟶ g), HasImageMap st
goal: Prop

full_name: CategoryTheory.Limits.im
code: /-- The functor from the arrow category of `C` to `C` itself that maps a morphism to its image
    and a commutative square to the induced morphism on images. -/
@[simps]
def im : Arrow C ⥤ C 
goal: CategoryTheory.Arrow C ⥤ C

full_name: CategoryTheory.Limits.im_map
code: /-- The functor from the arrow category of `C` to `C` itself that maps a morphism to its image
    and a commutative square to the induced morphism on images. -/
@[simps]
def im : Arrow C ⥤ C 
goal: ∀ {X Y : CategoryTheory.Arrow C} (st : X ⟶ Y), CategoryTheory.Limits.im.map st = CategoryTheory.Limits.image.map st

full_name: CategoryTheory.Limits.im_obj
code: /-- The functor from the arrow category of `C` to `C` itself that maps a morphism to its image
    and a commutative square to the induced morphism on images. -/
@[simps]
def im : Arrow C ⥤ C 
goal: CategoryTheory.Limits.im.obj f = CategoryTheory.Limits.image f.hom

full_name: CategoryTheory.Limits.StrongEpiMonoFactorisation.e_strong_epi
code: /-- A strong epi-mono factorisation is a decomposition `f = e ≫ m` with `e` a strong epimorphism
    and `m` a monomorphism. -/
structure StrongEpiMonoFactorisation {X Y : C} (f : X ⟶ Y) extends MonoFactorisation f where
  [e_strong_epi : StrongEpi e]
goal: CategoryTheory.StrongEpi self.e

full_name: CategoryTheory.Limits.StrongEpiMonoFactorisation
code: /-- A strong epi-mono factorisation is a decomposition `f = e ≫ m` with `e` a strong epimorphism
    and `m` a monomorphism. -/
structure StrongEpiMonoFactorisation {X Y : C} (f : X ⟶ Y) extends MonoFactorisation f where
  [e_strong_epi : StrongEpi e]
goal: Type (max u v)

full_name: CategoryTheory.Limits.strongEpiMonoFactorisationInhabited
code: /-- Satisfying the inhabited linter -/
instance strongEpiMonoFactorisationInhabited {X Y : C} (f : X ⟶ Y) [StrongEpi f] :
    Inhabited (StrongEpiMonoFactorisation f) 
goal: Inhabited (CategoryTheory.Limits.StrongEpiMonoFactorisation f)

full_name: CategoryTheory.Limits.StrongEpiMonoFactorisation.toMonoIsImage
code: /-- A mono factorisation coming from a strong epi-mono factorisation always has the universal
    property of the image. -/
def StrongEpiMonoFactorisation.toMonoIsImage {X Y : C} {f : X ⟶ Y}
    (F : StrongEpiMonoFactorisation f) : IsImage F.toMonoFactorisation 
goal: CategoryTheory.Limits.IsImage F.toMonoFactorisation

full_name: CategoryTheory.Limits.HasStrongEpiMonoFactorisations.mk'
code: /-- A category has strong epi-mono factorisations if every morphism admits a strong epi-mono
    factorisation. -/
class HasStrongEpiMonoFactorisations : Prop where mk' ::
  has_fac : ∀ {X Y : C} (f : X ⟶ Y), Nonempty (StrongEpiMonoFactorisation f)
goal: CategoryTheory.Limits.HasStrongEpiMonoFactorisations C

full_name: CategoryTheory.Limits.HasStrongEpiMonoFactorisations
code: /-- A category has strong epi-mono factorisations if every morphism admits a strong epi-mono
    factorisation. -/
class HasStrongEpiMonoFactorisations : Prop where mk' ::
  has_fac : ∀ {X Y : C} (f : X ⟶ Y), Nonempty (StrongEpiMonoFactorisation f)
goal: Prop

full_name: CategoryTheory.Limits.HasStrongEpiMonoFactorisations.has_fac
code: /-- A category has strong epi-mono factorisations if every morphism admits a strong epi-mono
    factorisation. -/
class HasStrongEpiMonoFactorisations : Prop where mk' ::
  has_fac : ∀ {X Y : C} (f : X ⟶ Y), Nonempty (StrongEpiMonoFactorisation f)
goal: Nonempty (CategoryTheory.Limits.StrongEpiMonoFactorisation f)

full_name: CategoryTheory.Limits.HasStrongEpiMonoFactorisations.mk
code: theorem HasStrongEpiMonoFactorisations.mk
    (d : ∀ {X Y : C} (f : X ⟶ Y), StrongEpiMonoFactorisation f) :
    HasStrongEpiMonoFactorisations C 
goal: CategoryTheory.Limits.HasStrongEpiMonoFactorisations C

full_name: CategoryTheory.Limits.hasImages_of_hasStrongEpiMonoFactorisations
code: instance (priority := 100) hasImages_of_hasStrongEpiMonoFactorisations
    [HasStrongEpiMonoFactorisations C] : HasImages C 
goal: CategoryTheory.Limits.HasImages C

full_name: CategoryTheory.Limits.HasStrongEpiImages.strong_factorThruImage
code: /-- A category has strong epi images if it has all images and `factorThruImage f` is a strong
    epimorphism for all `f`. -/
class HasStrongEpiImages : Prop where
  strong_factorThruImage : ∀ {X Y : C} (f : X ⟶ Y), StrongEpi (factorThruImage f)
goal: CategoryTheory.StrongEpi (CategoryTheory.Limits.factorThruImage f)

full_name: CategoryTheory.Limits.HasStrongEpiImages
code: /-- A category has strong epi images if it has all images and `factorThruImage f` is a strong
    epimorphism for all `f`. -/
class HasStrongEpiImages : Prop where
  strong_factorThruImage : ∀ {X Y : C} (f : X ⟶ Y), StrongEpi (factorThruImage f)
goal: Prop

full_name: CategoryTheory.Limits.strongEpi_of_strongEpiMonoFactorisation
code: /-- If there is a single strong epi-mono factorisation of `f`, then every image factorisation is a
    strong epi-mono factorisation. -/
theorem strongEpi_of_strongEpiMonoFactorisation {X Y : C} {f : X ⟶ Y}
    (F : StrongEpiMonoFactorisation f) {F' : MonoFactorisation f} (hF' : IsImage F') :
    StrongEpi F'.e 
goal: CategoryTheory.StrongEpi F'.e

full_name: CategoryTheory.Limits.strongEpi_factorThruImage_of_strongEpiMonoFactorisation
code: theorem strongEpi_factorThruImage_of_strongEpiMonoFactorisation {X Y : C} {f : X ⟶ Y} [HasImage f]
    (F : StrongEpiMonoFactorisation f) : StrongEpi (factorThruImage f) 
goal: CategoryTheory.StrongEpi (CategoryTheory.Limits.factorThruImage f)

full_name: CategoryTheory.Limits.hasStrongEpiImages_of_hasStrongEpiMonoFactorisations
code: /-- If we constructed our images from strong epi-mono factorisations, then these images are
    strong epi images. -/
instance (priority := 100) hasStrongEpiImages_of_hasStrongEpiMonoFactorisations
    [HasStrongEpiMonoFactorisations C] : HasStrongEpiImages C 
goal: CategoryTheory.Limits.HasStrongEpiImages C

full_name: CategoryTheory.Limits.hasImageMapsOfHasStrongEpiImages
code: /-- A category with strong epi images has image maps. -/
instance (priority := 100) hasImageMapsOfHasStrongEpiImages [HasStrongEpiImages C] :
    HasImageMaps C 
goal: CategoryTheory.Limits.HasImageMaps C

full_name: CategoryTheory.Limits.hasStrongEpiImages_of_hasPullbacks_of_hasEqualizers
code: /-- If a category has images, equalizers and pullbacks, then images are automatically strong epi
    images. -/
instance (priority := 100) hasStrongEpiImages_of_hasPullbacks_of_hasEqualizers [HasPullbacks C]
    [HasEqualizers C] : HasStrongEpiImages C 
goal: CategoryTheory.Limits.HasStrongEpiImages C

full_name: CategoryTheory.Limits.image.isoStrongEpiMono
code: /--
If `C` has strong epi mono factorisations, then the image is unique up to isomorphism, in that if
`f` factors as a strong epi followed by a mono, this factorisation is essentially the image
factorisation.
-/
def image.isoStrongEpiMono {I' : C} (e : X ⟶ I') (m : I' ⟶ Y) (comm : e ≫ m = f) [StrongEpi e]
    [Mono m] : I' ≅ image f 
goal: I' ≅ CategoryTheory.Limits.image f

full_name: CategoryTheory.Limits.image.isoStrongEpiMono_hom_comp_ι
code: @[simp]
theorem image.isoStrongEpiMono_hom_comp_ι {I' : C} (e : X ⟶ I') (m : I' ⟶ Y) (comm : e ≫ m = f)
    [StrongEpi e] [Mono m] : (image.isoStrongEpiMono e m comm).hom ≫ image.ι f = m 
goal: (CategoryTheory.Limits.image.isoStrongEpiMono e m comm).hom ≫ CategoryTheory.Limits.image.ι f = m

full_name: CategoryTheory.Limits.image.isoStrongEpiMono_inv_comp_mono
code: @[simp]
theorem image.isoStrongEpiMono_inv_comp_mono {I' : C} (e : X ⟶ I') (m : I' ⟶ Y) (comm : e ≫ m = f)
    [StrongEpi e] [Mono m] : (image.isoStrongEpiMono e m comm).inv ≫ m = image.ι f 
goal: (CategoryTheory.Limits.image.isoStrongEpiMono e m comm).inv ≫ m = CategoryTheory.Limits.image.ι f

full_name: CategoryTheory.Limits.functorialEpiMonoFactorizationData
code: /-- A category with strong epi mono factorisations admits functorial epi/mono factorizations. -/
noncomputable def functorialEpiMonoFactorizationData :
    FunctorialFactorizationData (epimorphisms C) (monomorphisms C) 
goal: (CategoryTheory.MorphismProperty.epimorphisms C).FunctorialFactorizationData
  (CategoryTheory.MorphismProperty.monomorphisms C)

full_name: CategoryTheory.Functor.hasStrongEpiMonoFactorisations_imp_of_isEquivalence
code: theorem hasStrongEpiMonoFactorisations_imp_of_isEquivalence (F : C ⥤ D) [IsEquivalence F]
    [h : HasStrongEpiMonoFactorisations C] : HasStrongEpiMonoFactorisations D 
goal: CategoryTheory.Limits.HasStrongEpiMonoFactorisations D