File: Mathlib/CategoryTheory/Abelian/Basic.lean

full_name: CategoryTheory.Abelian.has_kernels
code: /-- A (preadditive) category `C` is called abelian if it has all finite products,
all kernels and cokernels, and if every monomorphism is the kernel of some morphism
and every epimorphism is the cokernel of some morphism.

(This definition implies the existence of zero objects:
finite products give a terminal object, and in a preadditive category
any terminal object is a zero object.)
-/
class Abelian extends Preadditive C, NormalMonoCategory C, NormalEpiCategory C where
  [has_finite_products : HasFiniteProducts C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
goal: CategoryTheory.Limits.HasKernels C

full_name: CategoryTheory.Abelian.has_cokernels
code: /-- A (preadditive) category `C` is called abelian if it has all finite products,
all kernels and cokernels, and if every monomorphism is the kernel of some morphism
and every epimorphism is the cokernel of some morphism.

(This definition implies the existence of zero objects:
finite products give a terminal object, and in a preadditive category
any terminal object is a zero object.)
-/
class Abelian extends Preadditive C, NormalMonoCategory C, NormalEpiCategory C where
  [has_finite_products : HasFiniteProducts C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
goal: CategoryTheory.Limits.HasCokernels C

full_name: CategoryTheory.Abelian.has_finite_products
code: /-- A (preadditive) category `C` is called abelian if it has all finite products,
all kernels and cokernels, and if every monomorphism is the kernel of some morphism
and every epimorphism is the cokernel of some morphism.

(This definition implies the existence of zero objects:
finite products give a terminal object, and in a preadditive category
any terminal object is a zero object.)
-/
class Abelian extends Preadditive C, NormalMonoCategory C, NormalEpiCategory C where
  [has_finite_products : HasFiniteProducts C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
goal: CategoryTheory.Limits.HasFiniteProducts C

full_name: CategoryTheory.Abelian
code: /-- A (preadditive) category `C` is called abelian if it has all finite products,
all kernels and cokernels, and if every monomorphism is the kernel of some morphism
and every epimorphism is the cokernel of some morphism.

(This definition implies the existence of zero objects:
finite products give a terminal object, and in a preadditive category
any terminal object is a zero object.)
-/
class Abelian extends Preadditive C, NormalMonoCategory C, NormalEpiCategory C where
  [has_finite_products : HasFiniteProducts C]
  [has_kernels : HasKernels C]
  [has_cokernels : HasCokernels C]
goal: Type (max u v)

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation_e
code: /-- The factorisation of a morphism through its abelian image. -/
@[simps]
def imageMonoFactorisation {X Y : C} (f : X ⟶ Y) : MonoFactorisation f 
goal: (CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation f).e =
  CategoryTheory.Limits.kernel.lift (CategoryTheory.Limits.cokernel.π f) f ⋯

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation_m
code: /-- The factorisation of a morphism through its abelian image. -/
@[simps]
def imageMonoFactorisation {X Y : C} (f : X ⟶ Y) : MonoFactorisation f 
goal: (CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation f).m =
  CategoryTheory.Limits.kernel.ι (CategoryTheory.Limits.cokernel.π f)

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation_I
code: /-- The factorisation of a morphism through its abelian image. -/
@[simps]
def imageMonoFactorisation {X Y : C} (f : X ⟶ Y) : MonoFactorisation f 
goal: (CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation f).I = CategoryTheory.Abelian.image f

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation
code: /-- The factorisation of a morphism through its abelian image. -/
@[simps]
def imageMonoFactorisation {X Y : C} (f : X ⟶ Y) : MonoFactorisation f 
goal: CategoryTheory.Limits.MonoFactorisation f

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation_e'
code: theorem imageMonoFactorisation_e' {X Y : C} (f : X ⟶ Y) :
    (imageMonoFactorisation f).e = cokernel.π _ ≫ Abelian.coimageImageComparison f 
goal: (CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation f).e =
  CategoryTheory.Limits.cokernel.π (CategoryTheory.Limits.kernel.ι f) ≫ CategoryTheory.Abelian.coimageImageComparison f

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageFactorisation
code: /-- If the coimage-image comparison morphism for a morphism `f` is an isomorphism,
we obtain an image factorisation of `f`. -/
def imageFactorisation {X Y : C} (f : X ⟶ Y) [IsIso (Abelian.coimageImageComparison f)] :
    ImageFactorisation f 
goal: CategoryTheory.Limits.ImageFactorisation f

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.instIsIsoEImageMonoFactorisationOfHasZeroObjectOfMonoOfCoimageImageComparison
code: instance [HasZeroObject C] {X Y : C} (f : X ⟶ Y) [Mono f]
    [IsIso (Abelian.coimageImageComparison f)] : IsIso (imageMonoFactorisation f).e 
goal: CategoryTheory.IsIso (CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation f).e

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.instIsIsoMImageMonoFactorisationOfHasZeroObjectOfEpi
code: instance [HasZeroObject C] {X Y : C} (f : X ⟶ Y) [Epi f] : IsIso (imageMonoFactorisation f).m 
goal: CategoryTheory.IsIso (CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.imageMonoFactorisation f).m

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.hasImages
code: /-- A category in which coimage-image comparisons are all isomorphisms has images. -/
theorem hasImages : HasImages C 
goal: CategoryTheory.Limits.HasImages C

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.normalMonoCategory
code: /-- A category with finite products in which coimage-image comparisons are all isomorphisms
is a normal mono category.
-/
def normalMonoCategory : NormalMonoCategory C 
goal: CategoryTheory.NormalMonoCategory C

full_name: CategoryTheory.Abelian.OfCoimageImageComparisonIsIso.normalEpiCategory
code: /-- A category with finite products in which coimage-image comparisons are all isomorphisms
is a normal epi category.
-/
def normalEpiCategory : NormalEpiCategory C 
goal: CategoryTheory.NormalEpiCategory C

full_name: CategoryTheory.Abelian.ofCoimageImageComparisonIsIso
code: /-- A preadditive category with kernels, cokernels, and finite products,
in which the coimage-image comparison morphism is always an isomorphism,
is an abelian category.

The Stacks project uses this characterisation at the definition of an abelian category.
See <https://stacks.math.columbia.edu/tag/0109>.
-/
def ofCoimageImageComparisonIsIso : Abelian C 
goal: CategoryTheory.Abelian C

full_name: CategoryTheory.Abelian.hasFiniteBiproducts
code: /-- An abelian category has finite biproducts. -/
theorem hasFiniteBiproducts : HasFiniteBiproducts C 
goal: CategoryTheory.Limits.HasFiniteBiproducts C

full_name: CategoryTheory.Abelian.hasBinaryBiproducts
code: instance (priority := 100) hasBinaryBiproducts : HasBinaryBiproducts C 
goal: CategoryTheory.Limits.HasBinaryBiproducts C

full_name: CategoryTheory.Abelian.hasZeroObject
code: instance (priority := 100) hasZeroObject : HasZeroObject C 
goal: CategoryTheory.Limits.HasZeroObject C

full_name: CategoryTheory.Abelian.nonPreadditiveAbelian
code: /-- Every abelian category is, in particular, `NonPreadditiveAbelian`. -/
def nonPreadditiveAbelian : NonPreadditiveAbelian C 
goal: CategoryTheory.NonPreadditiveAbelian C

full_name: CategoryTheory.Abelian.instEpiFactorThruImage
code: /-- The map `p : P ⟶ image f` is an epimorphism -/
instance : Epi (Abelian.factorThruImage f) 
goal: CategoryTheory.Epi (CategoryTheory.Abelian.factorThruImage f)

full_name: CategoryTheory.Abelian.isIso_factorThruImage
code: instance isIso_factorThruImage [Mono f] : IsIso (Abelian.factorThruImage f) 
goal: CategoryTheory.IsIso (CategoryTheory.Abelian.factorThruImage f)

full_name: CategoryTheory.Abelian.instMonoFactorThruCoimage
code: /-- The canonical morphism `i : coimage f ⟶ Q` is a monomorphism -/
instance : Mono (Abelian.factorThruCoimage f) 
goal: CategoryTheory.Mono (CategoryTheory.Abelian.factorThruCoimage f)

full_name: CategoryTheory.Abelian.isIso_factorThruCoimage
code: instance isIso_factorThruCoimage [Epi f] : IsIso (Abelian.factorThruCoimage f) 
goal: CategoryTheory.IsIso (CategoryTheory.Abelian.factorThruCoimage f)

full_name: CategoryTheory.Abelian.mono_of_kernel_ι_eq_zero
code: theorem mono_of_kernel_ι_eq_zero (h : kernel.ι f = 0) : Mono f 
goal: CategoryTheory.Mono f

full_name: CategoryTheory.Abelian.epi_of_cokernel_π_eq_zero
code: theorem epi_of_cokernel_π_eq_zero (h : cokernel.π f = 0) : Epi f 
goal: CategoryTheory.Epi f

full_name: CategoryTheory.Abelian.image_ι_comp_eq_zero
code: theorem image_ι_comp_eq_zero {R : C} {g : Q ⟶ R} (h : f ≫ g = 0) : Abelian.image.ι f ≫ g = 0 
goal: CategoryTheory.Abelian.image.ι f ≫ g = 0

full_name: CategoryTheory.Abelian.comp_coimage_π_eq_zero
code: theorem comp_coimage_π_eq_zero {R : C} {g : Q ⟶ R} (h : f ≫ g = 0) : f ≫ Abelian.coimage.π g = 0 
goal: f ≫ CategoryTheory.Abelian.coimage.π g = 0

full_name: CategoryTheory.Abelian.imageStrongEpiMonoFactorisation_I
code: /-- Factoring through the image is a strong epi-mono factorisation. -/
@[simps]
def imageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
goal: (CategoryTheory.Abelian.imageStrongEpiMonoFactorisation f).I = CategoryTheory.Abelian.image f

full_name: CategoryTheory.Abelian.imageStrongEpiMonoFactorisation_e
code: /-- Factoring through the image is a strong epi-mono factorisation. -/
@[simps]
def imageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
goal: (CategoryTheory.Abelian.imageStrongEpiMonoFactorisation f).e = CategoryTheory.Abelian.factorThruImage f

full_name: CategoryTheory.Abelian.imageStrongEpiMonoFactorisation
code: /-- Factoring through the image is a strong epi-mono factorisation. -/
@[simps]
def imageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
goal: CategoryTheory.Limits.StrongEpiMonoFactorisation f

full_name: CategoryTheory.Abelian.imageStrongEpiMonoFactorisation_m
code: /-- Factoring through the image is a strong epi-mono factorisation. -/
@[simps]
def imageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
goal: (CategoryTheory.Abelian.imageStrongEpiMonoFactorisation f).m = CategoryTheory.Abelian.image.ι f

full_name: CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation_m
code: /-- Factoring through the coimage is a strong epi-mono factorisation. -/
@[simps]
def coimageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
goal: (CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation f).m = CategoryTheory.Abelian.factorThruCoimage f

full_name: CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation
code: /-- Factoring through the coimage is a strong epi-mono factorisation. -/
@[simps]
def coimageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
goal: CategoryTheory.Limits.StrongEpiMonoFactorisation f

full_name: CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation_I
code: /-- Factoring through the coimage is a strong epi-mono factorisation. -/
@[simps]
def coimageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
goal: (CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation f).I = CategoryTheory.Abelian.coimage f

full_name: CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation_e
code: /-- Factoring through the coimage is a strong epi-mono factorisation. -/
@[simps]
def coimageStrongEpiMonoFactorisation : StrongEpiMonoFactorisation f 
goal: (CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation f).e = CategoryTheory.Abelian.coimage.π f

full_name: CategoryTheory.Abelian.instHasStrongEpiMonoFactorisations
code: /-- An abelian category has strong epi-mono factorisations. -/
instance (priority := 100) : HasStrongEpiMonoFactorisations C 
goal: CategoryTheory.Limits.HasStrongEpiMonoFactorisations C

full_name: CategoryTheory.Abelian.instIsIsoCoimageImageComparison
code: /-- The coimage-image comparison morphism is always an isomorphism in an abelian category.
See `CategoryTheory.Abelian.ofCoimageImageComparisonIsIso` for the converse.
-/
instance : IsIso (coimageImageComparison f) 
goal: CategoryTheory.IsIso (CategoryTheory.Abelian.coimageImageComparison f)

full_name: CategoryTheory.Abelian.coimageIsoImage
code: /-- There is a canonical isomorphism between the abelian coimage and the abelian image of a
    morphism. -/
abbrev coimageIsoImage : Abelian.coimage f ≅ Abelian.image f 
goal: CategoryTheory.Abelian.coimage f ≅ CategoryTheory.Abelian.image f

full_name: CategoryTheory.Abelian.coimageIsoImage'
code: /-- There is a canonical isomorphism between the abelian coimage and the categorical image of a
    morphism. -/
abbrev coimageIsoImage' : Abelian.coimage f ≅ image f 
goal: CategoryTheory.Abelian.coimage f ≅ CategoryTheory.Limits.image f

full_name: CategoryTheory.Abelian.coimageIsoImage'_hom
code: theorem coimageIsoImage'_hom :
    (coimageIsoImage' f).hom =
      cokernel.desc _ (factorThruImage f) (by simp [← cancel_mono (Limits.image.ι f)]) 
goal: (CategoryTheory.Abelian.coimageIsoImage' f).hom =
  CategoryTheory.Limits.cokernel.desc (CategoryTheory.Limits.kernel.ι f) (CategoryTheory.Limits.factorThruImage f) ⋯

full_name: CategoryTheory.Abelian.factorThruImage_comp_coimageIsoImage'_inv
code: theorem factorThruImage_comp_coimageIsoImage'_inv :
    factorThruImage f ≫ (coimageIsoImage' f).inv = cokernel.π _ 
goal: CategoryTheory.Limits.factorThruImage f ≫ (CategoryTheory.Abelian.coimageIsoImage' f).inv =
  CategoryTheory.Limits.cokernel.π (CategoryTheory.Limits.kernel.ι f)

full_name: CategoryTheory.Abelian.imageIsoImage
code: /-- There is a canonical isomorphism between the abelian image and the categorical image of a
    morphism. -/
abbrev imageIsoImage : Abelian.image f ≅ image f 
goal: CategoryTheory.Abelian.image f ≅ CategoryTheory.Limits.image f

full_name: CategoryTheory.Abelian.imageIsoImage_hom_comp_image_ι
code: theorem imageIsoImage_hom_comp_image_ι : (imageIsoImage f).hom ≫ Limits.image.ι _ = kernel.ι _ 
goal: (CategoryTheory.Abelian.imageIsoImage f).hom ≫ CategoryTheory.Limits.image.ι f =
  CategoryTheory.Limits.kernel.ι (CategoryTheory.Limits.cokernel.π f)

full_name: CategoryTheory.Abelian.imageIsoImage_inv
code: theorem imageIsoImage_inv :
    (imageIsoImage f).inv =
      kernel.lift _ (Limits.image.ι f) (by simp [← cancel_epi (factorThruImage f)]) 
goal: (CategoryTheory.Abelian.imageIsoImage f).inv =
  CategoryTheory.Limits.kernel.lift (CategoryTheory.Limits.cokernel.π f) (CategoryTheory.Limits.image.ι f) ⋯

full_name: CategoryTheory.Abelian.epiIsCokernelOfKernel
code: /-- In an abelian category, an epi is the cokernel of its kernel. More precisely:
    If `f` is an epimorphism and `s` is some limit kernel cone on `f`, then `f` is a cokernel
    of `fork.ι s`. -/
def epiIsCokernelOfKernel [Epi f] (s : Fork f 0) (h : IsLimit s) :
    IsColimit (CokernelCofork.ofπ f (KernelFork.condition s)) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ f ⋯)

full_name: CategoryTheory.Abelian.monoIsKernelOfCokernel
code: /-- In an abelian category, a mono is the kernel of its cokernel. More precisely:
    If `f` is a monomorphism and `s` is some colimit cokernel cocone on `f`, then `f` is a kernel
    of `cofork.π s`. -/
def monoIsKernelOfCokernel [Mono f] (s : Cofork f 0) (h : IsColimit s) :
    IsLimit (KernelFork.ofι f (CokernelCofork.condition s)) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι f ⋯)

full_name: CategoryTheory.Abelian.epiDesc
code: /-- In an abelian category, any morphism that turns to zero when precomposed with the kernel of an
    epimorphism factors through that epimorphism. -/
def epiDesc [Epi f] {T : C} (g : X ⟶ T) (hg : kernel.ι f ≫ g = 0) : Y ⟶ T 
goal: Y ⟶ T

full_name: CategoryTheory.Abelian.comp_epiDesc
code: @[reassoc (attr := simp)]
theorem comp_epiDesc [Epi f] {T : C} (g : X ⟶ T) (hg : kernel.ι f ≫ g = 0) :
    f ≫ epiDesc f g hg = g 
goal: f ≫ CategoryTheory.Abelian.epiDesc f g hg = g

full_name: CategoryTheory.Abelian.monoLift
code: /-- In an abelian category, any morphism that turns to zero when postcomposed with the cokernel of a
    monomorphism factors through that monomorphism. -/
def monoLift [Mono f] {T : C} (g : T ⟶ Y) (hg : g ≫ cokernel.π f = 0) : T ⟶ X 
goal: T ⟶ X

full_name: CategoryTheory.Abelian.monoLift_comp
code: @[reassoc (attr := simp)]
theorem monoLift_comp [Mono f] {T : C} (g : T ⟶ Y) (hg : g ≫ cokernel.π f = 0) :
    monoLift f g hg ≫ f = g 
goal: CategoryTheory.Abelian.monoLift f g hg ≫ f = g

full_name: CategoryTheory.Abelian.isLimitMapConeOfKernelForkOfι
code: /-- If `F : D ⥤ C` is a functor to an abelian category, `i : X ⟶ Y` is a morphism
admitting a cokernel such that `F` preserves this cokernel and `F.map i` is a mono,
then `F.map X` identifies to the kernel of `F.map (cokernel.π i)`. -/
noncomputable def isLimitMapConeOfKernelForkOfι
    {X Y : D} (i : X ⟶ Y) [HasCokernel i] (F : D ⥤ C)
    [F.PreservesZeroMorphisms] [Mono (F.map i)]
    [PreservesColimit (parallelPair i 0) F] :
    IsLimit (F.mapCone (KernelFork.ofι i (cokernel.condition i))) 
goal: CategoryTheory.Limits.IsLimit (F.mapCone (CategoryTheory.Limits.KernelFork.ofι i ⋯))

full_name: CategoryTheory.Abelian.isColimitMapCoconeOfCokernelCoforkOfπ
code: /-- If `F : D ⥤ C` is a functor to an abelian category, `p : X ⟶ Y` is a morphisms
admitting a kernel such that `F` preserves this kernel and `F.map p` is an epi,
then `F.map Y` identifies to the cokernel of `F.map (kernel.ι p)`. -/
noncomputable def isColimitMapCoconeOfCokernelCoforkOfπ
    {X Y : D} (p : X ⟶ Y) [HasKernel p] (F : D ⥤ C)
    [F.PreservesZeroMorphisms] [Epi (F.map p)]
    [PreservesLimit (parallelPair p 0) F] :
    IsColimit (F.mapCocone (CokernelCofork.ofπ p (kernel.condition p))) 
goal: CategoryTheory.Limits.IsColimit (F.mapCocone (CategoryTheory.Limits.CokernelCofork.ofπ p ⋯))

full_name: CategoryTheory.Abelian.hasEqualizers
code: instance (priority := 100) hasEqualizers : HasEqualizers C 
goal: CategoryTheory.Limits.HasEqualizers C

full_name: CategoryTheory.Abelian.hasPullbacks
code: /-- Any abelian category has pullbacks -/
instance (priority := 100) hasPullbacks : HasPullbacks C 
goal: CategoryTheory.Limits.HasPullbacks C

full_name: CategoryTheory.Abelian.hasCoequalizers
code: instance (priority := 100) hasCoequalizers : HasCoequalizers C 
goal: CategoryTheory.Limits.HasCoequalizers C

full_name: CategoryTheory.Abelian.hasPushouts
code: /-- Any abelian category has pushouts -/
instance (priority := 100) hasPushouts : HasPushouts C 
goal: CategoryTheory.Limits.HasPushouts C

full_name: CategoryTheory.Abelian.hasFiniteLimits
code: instance (priority := 100) hasFiniteLimits : HasFiniteLimits C 
goal: CategoryTheory.Limits.HasFiniteLimits C

full_name: CategoryTheory.Abelian.hasFiniteColimits
code: instance (priority := 100) hasFiniteColimits : HasFiniteColimits C 
goal: CategoryTheory.Limits.HasFiniteColimits C

full_name: CategoryTheory.Abelian.PullbackToBiproductIsKernel.pullbackToBiproduct
code: /-- The canonical map `pullback f g ⟶ X ⊞ Y` -/
abbrev pullbackToBiproduct : pullback f g ⟶ X ⊞ Y 
goal: CategoryTheory.Limits.pullback f g ⟶ X ⊞ Y

full_name: CategoryTheory.Abelian.PullbackToBiproductIsKernel.pullbackToBiproductFork
code: /-- The canonical map `pullback f g ⟶ X ⊞ Y` induces a kernel cone on the map
    `biproduct X Y ⟶ Z` induced by `f` and `g`. A slightly more intuitive way to think of
    this may be that it induces an equalizer fork on the maps induced by `(f, 0)` and
    `(0, g)`. -/
abbrev pullbackToBiproductFork : KernelFork (biprod.desc f (-g)) 
goal: CategoryTheory.Limits.KernelFork (CategoryTheory.Limits.biprod.desc f (-g))

full_name: CategoryTheory.Abelian.PullbackToBiproductIsKernel.isLimitPullbackToBiproduct
code: /-- The canonical map `pullback f g ⟶ X ⊞ Y` is a kernel of the map induced by
    `(f, -g)`. -/
def isLimitPullbackToBiproduct : IsLimit (pullbackToBiproductFork f g) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Abelian.PullbackToBiproductIsKernel.pullbackToBiproductFork f g)

full_name: CategoryTheory.Abelian.BiproductToPushoutIsCokernel.biproductToPushout
code: /-- The canonical map `Y ⊞ Z ⟶ pushout f g` -/
abbrev biproductToPushout : Y ⊞ Z ⟶ pushout f g 
goal: Y ⊞ Z ⟶ CategoryTheory.Limits.pushout f g

full_name: CategoryTheory.Abelian.BiproductToPushoutIsCokernel.biproductToPushoutCofork
code: /-- The canonical map `Y ⊞ Z ⟶ pushout f g` induces a cokernel cofork on the map
    `X ⟶ Y ⊞ Z` induced by `f` and `-g`. -/
abbrev biproductToPushoutCofork : CokernelCofork (biprod.lift f (-g)) 
goal: CategoryTheory.Limits.CokernelCofork (CategoryTheory.Limits.biprod.lift f (-g))

full_name: CategoryTheory.Abelian.BiproductToPushoutIsCokernel.isColimitBiproductToPushout
code: /-- The cofork induced by the canonical map `Y ⊞ Z ⟶ pushout f g` is in fact a colimit cokernel
    cofork. -/
def isColimitBiproductToPushout : IsColimit (biproductToPushoutCofork f g) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Abelian.BiproductToPushoutIsCokernel.biproductToPushoutCofork f g)

full_name: CategoryTheory.Abelian.epi_pullback_of_epi_f
code: /-- In an abelian category, the pullback of an epimorphism is an epimorphism.
    Proof from [aluffi2016, IX.2.3], cf. [borceux-vol2, 1.7.6] -/
instance epi_pullback_of_epi_f [Epi f] : Epi (pullback.snd f g) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.pullback.snd f g)

full_name: CategoryTheory.Abelian.epi_pullback_of_epi_g
code: /-- In an abelian category, the pullback of an epimorphism is an epimorphism. -/
instance epi_pullback_of_epi_g [Epi g] : Epi (pullback.fst f g) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.pullback.fst f g)

full_name: CategoryTheory.Abelian.epi_snd_of_isLimit
code: theorem epi_snd_of_isLimit [Epi f] {s : PullbackCone f g} (hs : IsLimit s) : Epi s.snd 
goal: CategoryTheory.Epi s.snd

full_name: CategoryTheory.Abelian.epi_fst_of_isLimit
code: theorem epi_fst_of_isLimit [Epi g] {s : PullbackCone f g} (hs : IsLimit s) : Epi s.fst 
goal: CategoryTheory.Epi s.fst

full_name: CategoryTheory.Abelian.epi_fst_of_factor_thru_epi_mono_factorization
code: /-- Suppose `f` and `g` are two morphisms with a common codomain and suppose we have written `g` as
    an epimorphism followed by a monomorphism. If `f` factors through the mono part of this
    factorization, then any pullback of `g` along `f` is an epimorphism. -/
theorem epi_fst_of_factor_thru_epi_mono_factorization (g₁ : Y ⟶ W) [Epi g₁] (g₂ : W ⟶ Z) [Mono g₂]
    (hg : g₁ ≫ g₂ = g) (f' : X ⟶ W) (hf : f' ≫ g₂ = f) (t : PullbackCone f g) (ht : IsLimit t) :
    Epi t.fst 
goal: CategoryTheory.Epi t.fst

full_name: CategoryTheory.Abelian.mono_pushout_of_mono_f
code: instance mono_pushout_of_mono_f [Mono f] : Mono (pushout.inr _ _ : Z ⟶ pushout f g) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.pushout.inr f g)

full_name: CategoryTheory.Abelian.mono_pushout_of_mono_g
code: instance mono_pushout_of_mono_g [Mono g] : Mono (pushout.inl f g) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.pushout.inl f g)

full_name: CategoryTheory.Abelian.mono_inr_of_isColimit
code: theorem mono_inr_of_isColimit [Mono f] {s : PushoutCocone f g} (hs : IsColimit s) : Mono s.inr 
goal: CategoryTheory.Mono s.inr

full_name: CategoryTheory.Abelian.mono_inl_of_isColimit
code: theorem mono_inl_of_isColimit [Mono g] {s : PushoutCocone f g} (hs : IsColimit s) : Mono s.inl 
goal: CategoryTheory.Mono s.inl

full_name: CategoryTheory.Abelian.mono_inl_of_factor_thru_epi_mono_factorization
code: /-- Suppose `f` and `g` are two morphisms with a common domain and suppose we have written `g` as
    an epimorphism followed by a monomorphism. If `f` factors through the epi part of this
    factorization, then any pushout of `g` along `f` is a monomorphism. -/
theorem mono_inl_of_factor_thru_epi_mono_factorization (f : X ⟶ Y) (g : X ⟶ Z) (g₁ : X ⟶ W) [Epi g₁]
    (g₂ : W ⟶ Z) [Mono g₂] (hg : g₁ ≫ g₂ = g) (f' : W ⟶ Y) (hf : g₁ ≫ f' = f)
    (t : PushoutCocone f g) (ht : IsColimit t) : Mono t.inl 
goal: CategoryTheory.Mono t.inl

full_name: CategoryTheory.NonPreadditiveAbelian.abelian
code: /-- Every NonPreadditiveAbelian category can be promoted to an abelian category. -/
def abelian : Abelian C 
goal: CategoryTheory.Abelian C