# Kernels and cokernels #

In a category with zero morphisms, the kernel of a morphism f : X ⟶ Y is the equalizer of f and 0 : X ⟶ Y. (Similarly the cokernel is the coequalizer.)

The basic definitions are

• kernel : (X ⟶ Y) → C

• kernel.ι : kernel f ⟶ X

• kernel.condition : kernel.ι f ≫ f = 0 and

• kernel.lift (k : W ⟶ X) (h : k ≫ f = 0) : W ⟶ kernel f (as well as the dual versions)

## Main statements #

Besides the definition and lifts, we prove

• kernel.ιZeroIsIso: a kernel map of a zero morphism is an isomorphism
• kernel.eq_zero_of_epi_kernel: if kernel.ι f is an epimorphism, then f = 0
• kernel.ofMono: the kernel of a monomorphism is the zero object
• kernel.liftMono: the lift of a monomorphism k : W ⟶ X such that k ≫ f = 0 is still a monomorphism
• kernel.isLimitConeZeroCone: if our category has a zero object, then the map from the zero object is a kernel map of any monomorphism
• kernel.ιOfZero: kernel.ι (0 : X ⟶ Y) is an isomorphism

and the corresponding dual statements.

## Future work #

• TODO: connect this with existing work in the group theory and ring theory libraries.

## Implementation notes #

As with the other special shapes in the limits library, all the definitions here are given as abbreviations of the general statements for limits, so all the simp lemmas and theorems about general limits can be used.

## References #

@[reducible, inline]
abbrev CategoryTheory.Limits.HasKernel {C : Type u} {X : C} {Y : C} (f : X Y) :

A morphism f has a kernel if the functor ParallelPair f 0 has a limit.

Equations
Instances For
@[reducible, inline]
abbrev CategoryTheory.Limits.HasCokernel {C : Type u} {X : C} {Y : C} (f : X Y) :

A morphism f has a cokernel if the functor ParallelPair f 0 has a colimit.

Equations
Instances For
@[reducible, inline]
abbrev CategoryTheory.Limits.KernelFork {C : Type u} {X : C} {Y : C} (f : X Y) :
Type (max u v)

A kernel fork is just a fork where the second morphism is a zero morphism.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.KernelFork.condition_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {Z : C} (h : Y Z) :
@[simp]
theorem CategoryTheory.Limits.KernelFork.condition {C : Type u} {X : C} {Y : C} {f : X Y} :
theorem CategoryTheory.Limits.KernelFork.app_one {C : Type u} {X : C} {Y : C} {f : X Y} :
@[reducible, inline]
abbrev CategoryTheory.Limits.KernelFork.ofι {C : Type u} {X : C} {Y : C} {f : X Y} {Z : C} (ι : Z X) (w : ) :

A morphism ι satisfying ι ≫ f = 0 determines a kernel fork over f.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.KernelFork.ι_ofι {C : Type u} {X : C} {Y : C} {P : C} (f : X Y) (ι : P X) (w : ) :
def CategoryTheory.Limits.isoOfι {C : Type u} {X : C} {Y : C} {f : X Y} (s : ) :

Every kernel fork s is isomorphic (actually, equal) to fork.ofι (fork.ι s) _.

Equations
Instances For
def CategoryTheory.Limits.ofιCongr {C : Type u} {X : C} {Y : C} {f : X Y} {P : C} {ι : P X} {ι' : P X} {w : } (h : ι = ι') :

If ι = ι', then fork.ofι ι _ and fork.ofι ι' _ are isomorphic.

Equations
Instances For
def CategoryTheory.Limits.compNatIso {C : Type u} {X : C} {Y : C} {f : X Y} {D : Type u'} [] (F : ) [F.IsEquivalence] :

If F is an equivalence, then applying F to a diagram indexing a (co)kernel of f yields the diagram indexing the (co)kernel of F.map f.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.KernelFork.IsLimit.lift' {C : Type u} {X : C} {Y : C} {f : X Y} (hs : ) {W : C} (k : W X) (h : ) :
{ l : W s.pt // }

If s is a limit kernel fork and k : W ⟶ X satisfies k ≫ f = 0, then there is some l : W ⟶ s.X such that l ≫ fork.ι s = k.

Equations
• = hs.lift ,
Instances For
def CategoryTheory.Limits.isLimitAux {C : Type u} {X : C} {Y : C} {f : X Y} (lift : (s : ) → s.pt t.pt) (fac : ) (uniq : ∀ (s : ) (m : s.pt t.pt), ) :

This is a slightly more convenient method to verify that a kernel fork is a limit cone. It only asks for a proof of facts that carry any mathematical content

Equations
Instances For
def CategoryTheory.Limits.KernelFork.IsLimit.ofι {C : Type u} {X : C} {Y : C} {f : X Y} {W : C} (g : W X) (eq : ) (lift : {W' : C} → (g' : W' X) → (W' W)) (fac : ∀ {W' : C} (g' : W' X) (eq' : ), CategoryTheory.CategoryStruct.comp (lift g' eq') g = g') (uniq : ∀ {W' : C} (g' : W' X) (eq' : ) (m : W' W), m = lift g' eq') :

This is a more convenient formulation to show that a KernelFork constructed using KernelFork.ofι is a limit cone.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.KernelFork.IsLimit.ofι' {C : Type u} {X : C} {Y : C} {K : C} {f : X Y} (i : K X) (w : ) (h : {A : C} → (k : A X) → { l : A K // }) [hi : ] :

This is a more convenient formulation to show that a KernelFork of the form KernelFork.ofι i _ is a limit cone when we know that i is a monomorphism.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.isKernelCompMono {C : Type u} {X : C} {Y : C} {f : X Y} {Z : C} (g : Y Z) [hg : ] {h : X Z} (hh : ) :

Every kernel of f induces a kernel of f ≫ g if g is mono.

Equations
• One or more equations did not get rendered due to their size.
Instances For
theorem CategoryTheory.Limits.isKernelCompMono_lift {C : Type u} {X : C} {Y : C} {f : X Y} {Z : C} (g : Y Z) [hg : ] {h : X Z} (hh : ) :
.lift s = i.lift
def CategoryTheory.Limits.isKernelOfComp {C : Type u} {X : C} {Y : C} {f : X Y} {W : C} (g : Y W) (h : X W) (hf : ) (hfg : ) :

Every kernel of f ≫ g is also a kernel of f, as long as c.ι ≫ f vanishes.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.KernelFork.IsLimit.ofId {C : Type u} {X : C} {Y : C} (f : X Y) (hf : f = 0) :

X identifies to the kernel of a zero map X ⟶ Y.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.KernelFork.IsLimit.ofMonoOfIsZero {C : Type u} {X : C} {Y : C} {f : X Y} (hf : ) (h : ) :

Any zero object identifies to the kernel of a given monomorphisms.

Equations
Instances For
theorem CategoryTheory.Limits.KernelFork.IsLimit.isIso_ι {C : Type u} {X : C} {Y : C} {f : X Y} (hc : ) (hf : f = 0) :
def CategoryTheory.Limits.KernelFork.mapOfIsLimit {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} (kf : ) {kf' : } (hf' : ) (φ : ) :
kf.pt kf'.pt

The morphism between points of kernel forks induced by a morphism in the category of arrows.

Equations
• kf.mapOfIsLimit hf' φ = hf'.lift
Instances For
@[simp]
theorem CategoryTheory.Limits.KernelFork.mapOfIsLimit_ι_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} (kf : ) {kf' : } (hf' : ) (φ : ) {Z : C} :
CategoryTheory.CategoryStruct.comp (kf.mapOfIsLimit hf' φ) =
@[simp]
theorem CategoryTheory.Limits.KernelFork.mapOfIsLimit_ι {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} (kf : ) {kf' : } (hf' : ) (φ : ) :
CategoryTheory.CategoryStruct.comp (kf.mapOfIsLimit hf' φ) =
@[simp]
theorem CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit_inv {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} {kf : } {kf' : } (hf : ) (hf' : ) (φ : ) :
.inv = kf'.mapOfIsLimit hf φ.inv
@[simp]
theorem CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit_hom {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} {kf : } {kf' : } (hf : ) (hf' : ) (φ : ) :
.hom = kf.mapOfIsLimit hf' φ.hom
def CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} {kf : } {kf' : } (hf : ) (hf' : ) (φ : ) :
kf.pt kf'.pt

The isomorphism between points of limit kernel forks induced by an isomorphism in the category of arrows.

Equations
• = { hom := kf.mapOfIsLimit hf' φ.hom, inv := kf'.mapOfIsLimit hf φ.inv, hom_inv_id := , inv_hom_id := }
Instances For
@[reducible, inline]
abbrev CategoryTheory.Limits.kernel {C : Type u} {X : C} {Y : C} (f : X Y) :
C

The kernel of a morphism, expressed as the equalizer with the 0 morphism.

Equations
Instances For
@[reducible, inline]
abbrev CategoryTheory.Limits.kernel.ι {C : Type u} {X : C} {Y : C} (f : X Y) :

The map from kernel f into the source of f.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.equalizer_as_kernel {C : Type u} {X : C} {Y : C} (f : X Y) :
@[simp]
theorem CategoryTheory.Limits.kernel.condition_assoc {C : Type u} {X : C} {Y : C} (f : X Y) {Z : C} (h : Y Z) :
@[simp]
theorem CategoryTheory.Limits.kernel.condition {C : Type u} {X : C} {Y : C} (f : X Y) :
def CategoryTheory.Limits.kernelIsKernel {C : Type u} {X : C} {Y : C} (f : X Y) :

The kernel built from kernel.ι f is limiting.

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[reducible, inline]
abbrev CategoryTheory.Limits.kernel.lift {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (k : W X) (h : ) :

Given any morphism k : W ⟶ X satisfying k ≫ f = 0, k factors through kernel.ι f via kernel.lift : W ⟶ kernel f.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.kernel.lift_ι_assoc {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (k : W X) (h : ) {Z : C} (h : X Z) :
@[simp]
theorem CategoryTheory.Limits.kernel.lift_ι {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (k : W X) (h : ) :
@[simp]
theorem CategoryTheory.Limits.kernel.lift_zero {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} {h : } :
instance CategoryTheory.Limits.kernel.lift_mono {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (k : W X) (h : ) :
Equations
• =
def CategoryTheory.Limits.kernel.lift' {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (k : W X) (h : ) :

Any morphism k : W ⟶ X satisfying k ≫ f = 0 induces a morphism l : W ⟶ kernel f such that l ≫ kernel.ι f = k.

Equations
• = ⟨,
Instances For
@[reducible, inline]
abbrev CategoryTheory.Limits.kernel.map {C : Type u} {X : C} {Y : C} (f : X Y) {X' : C} {Y' : C} (f' : X' Y') (p : X X') (q : Y Y') :

A commuting square induces a morphism of kernels.

Equations
Instances For
theorem CategoryTheory.Limits.kernel.lift_map {C : Type u} {X : C} {Y : C} {Z : C} {X' : C} {Y' : C} {Z' : C} (f : X Y) (g : Y Z) (w : ) (f' : X' Y') (g' : Y' Z') (w' : ) (p : X X') (q : Y Y') (r : Z Z') :
=

Given a commutative diagram X --f--> Y --g--> Z | | | | | | v v v X' -f'-> Y' -g'-> Z' with horizontal arrows composing to zero, then we obtain a commutative square X ---> kernel g | | | | kernel.map | | v v X' --> kernel g'

@[simp]
theorem CategoryTheory.Limits.kernel.mapIso_hom {C : Type u} {X : C} {Y : C} (f : X Y) {X' : C} {Y' : C} (f' : X' Y') (p : X X') (q : Y Y') (w : ) :
.hom = CategoryTheory.Limits.kernel.map f f' p.hom q.hom w
@[simp]
theorem CategoryTheory.Limits.kernel.mapIso_inv {C : Type u} {X : C} {Y : C} (f : X Y) {X' : C} {Y' : C} (f' : X' Y') (p : X X') (q : Y Y') (w : ) :
.inv = CategoryTheory.Limits.kernel.map f' f p.inv q.inv
def CategoryTheory.Limits.kernel.mapIso {C : Type u} {X : C} {Y : C} (f : X Y) {X' : C} {Y' : C} (f' : X' Y') (p : X X') (q : Y Y') (w : ) :

A commuting square of isomorphisms induces an isomorphism of kernels.

Equations
• One or more equations did not get rendered due to their size.
Instances For
instance CategoryTheory.Limits.kernel.ι_zero_isIso {C : Type u} {X : C} {Y : C} :

Every kernel of the zero morphism is an isomorphism

Equations
• =
theorem CategoryTheory.Limits.eq_zero_of_epi_kernel {C : Type u} {X : C} {Y : C} (f : X Y) :
f = 0
def CategoryTheory.Limits.kernelZeroIsoSource {C : Type u} {X : C} {Y : C} :

The kernel of a zero morphism is isomorphic to the source.

Equations
• CategoryTheory.Limits.kernelZeroIsoSource =
Instances For
@[simp]
theorem CategoryTheory.Limits.kernelZeroIsoSource_hom {C : Type u} {X : C} {Y : C} :
CategoryTheory.Limits.kernelZeroIsoSource.hom =
@[simp]
theorem CategoryTheory.Limits.kernelZeroIsoSource_inv {C : Type u} {X : C} {Y : C} :
CategoryTheory.Limits.kernelZeroIsoSource.inv =
def CategoryTheory.Limits.kernelIsoOfEq {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} (h : f = g) :

If two morphisms are known to be equal, then their kernels are isomorphic.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.kernelIsoOfEq_refl {C : Type u} {X : C} {Y : C} (f : X Y) {h : f = f} :
@[simp]
theorem CategoryTheory.Limits.kernelIsoOfEq_hom_comp_ι_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} (h : f = g) {Z : C} (h : X Z) :
@[simp]
theorem CategoryTheory.Limits.kernelIsoOfEq_hom_comp_ι {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} (h : f = g) :
@[simp]
theorem CategoryTheory.Limits.kernelIsoOfEq_inv_comp_ι_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} (h : f = g) {Z : C} (h : X Z) :
@[simp]
theorem CategoryTheory.Limits.kernelIsoOfEq_inv_comp_ι {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} (h : f = g) :
@[simp]
theorem CategoryTheory.Limits.lift_comp_kernelIsoOfEq_hom_assoc {C : Type u} {X : C} {Y : C} {Z : C} {f : X Y} {g : X Y} (h : f = g) (e : Z✝ X) (he : ) {Z : C} (h : ) :
@[simp]
theorem CategoryTheory.Limits.lift_comp_kernelIsoOfEq_hom {C : Type u} {X : C} {Y : C} {Z : C} {f : X Y} {g : X Y} (h : f = g) (e : Z X) (he : ) :
@[simp]
theorem CategoryTheory.Limits.lift_comp_kernelIsoOfEq_inv_assoc {C : Type u} {X : C} {Y : C} {Z : C} {f : X Y} {g : X Y} (h : f = g) (e : Z✝ X) (he : ) {Z : C} (h : ) :
@[simp]
theorem CategoryTheory.Limits.lift_comp_kernelIsoOfEq_inv {C : Type u} {X : C} {Y : C} {Z : C} {f : X Y} {g : X Y} (h : f = g) (e : Z X) (he : ) :
@[simp]
theorem CategoryTheory.Limits.kernelIsoOfEq_trans {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {h : X Y} (w₁ : f = g) (w₂ : g = h) :
theorem CategoryTheory.Limits.kernel_not_epi_of_nonzero {C : Type u} {X : C} {Y : C} {f : X Y} (w : f 0) :
theorem CategoryTheory.Limits.kernel_not_iso_of_nonzero {C : Type u} {X : C} {Y : C} {f : X Y} (w : f 0) :
instance CategoryTheory.Limits.hasKernel_comp_mono {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
Equations
• =
@[simp]
theorem CategoryTheory.Limits.kernelCompMono_hom {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
@[simp]
theorem CategoryTheory.Limits.kernelCompMono_inv {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
def CategoryTheory.Limits.kernelCompMono {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :

When g is a monomorphism, the kernel of f ≫ g is isomorphic to the kernel of f.

Equations
• One or more equations did not get rendered due to their size.
Instances For
instance CategoryTheory.Limits.hasKernel_iso_comp {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
Equations
• =
@[simp]
theorem CategoryTheory.Limits.kernelIsIsoComp_hom {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
@[simp]
theorem CategoryTheory.Limits.kernelIsIsoComp_inv {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
def CategoryTheory.Limits.kernelIsIsoComp {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :

When f is an isomorphism, the kernel of f ≫ g is isomorphic to the kernel of g.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.kernel.zeroKernelFork {C : Type u} {X : C} {Y : C} (f : X Y) :

The morphism from the zero object determines a cone on a kernel diagram

Equations
Instances For

The map from the zero object is a kernel of a monomorphism

Equations
Instances For
def CategoryTheory.Limits.kernel.ofMono {C : Type u} {X : C} {Y : C} (f : X Y) :

The kernel of a monomorphism is isomorphic to the zero object

Equations
• One or more equations did not get rendered due to their size.
Instances For
theorem CategoryTheory.Limits.kernel.ι_of_mono {C : Type u} {X : C} {Y : C} (f : X Y) :

The kernel morphism of a monomorphism is a zero morphism

def CategoryTheory.Limits.zeroKernelOfCancelZero {C : Type u} {X : C} {Y : C} (f : X Y) (hf : ∀ (Z : C) (g : Z X), g = 0) :

If g ≫ f = 0 implies g = 0 for all g, then 0 : 0 ⟶ X is a kernel of f.

Equations
Instances For
def CategoryTheory.Limits.IsKernel.ofCompIso {C : Type u} {X : C} {Y : C} (f : X Y) {Z : C} (l : X Z) (i : Z Y) (h : = f) (hs : ) :

If i is an isomorphism such that l ≫ i.hom = f, any kernel of f is a kernel of l.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.kernel.ofCompIso {C : Type u} {X : C} {Y : C} (f : X Y) {Z : C} (l : X Z) (i : Z Y) (h : = f) :

If i is an isomorphism such that l ≫ i.hom = f, the kernel of f is a kernel of l.

Equations
Instances For
def CategoryTheory.Limits.IsKernel.isoKernel {C : Type u} {X : C} {Y : C} (f : X Y) {Z : C} (l : Z X) (hs : ) (i : Z s.pt) (h : ) :

If s is any limit kernel cone over f and if i is an isomorphism such that i.hom ≫ s.ι = l, then l is a kernel of f.

Equations
Instances For
def CategoryTheory.Limits.kernel.isoKernel {C : Type u} {X : C} {Y : C} (f : X Y) {Z : C} (l : Z X) (i : ) (h : ) :

If i is an isomorphism such that i.hom ≫ kernel.ι f = l, then l is a kernel of f.

Equations
Instances For
theorem CategoryTheory.Limits.kernel.ι_of_zero {C : Type u} (X : C) (Y : C) :

The kernel morphism of a zero morphism is an isomorphism

@[reducible, inline]
abbrev CategoryTheory.Limits.CokernelCofork {C : Type u} {X : C} {Y : C} (f : X Y) :
Type (max u v)

A cokernel cofork is just a cofork where the second morphism is a zero morphism.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.CokernelCofork.condition_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {Z : C} (h : ) :
@[simp]
theorem CategoryTheory.Limits.CokernelCofork.condition {C : Type u} {X : C} {Y : C} {f : X Y} :
theorem CategoryTheory.Limits.CokernelCofork.π_eq_zero {C : Type u} {X : C} {Y : C} {f : X Y} :
@[reducible, inline]
abbrev CategoryTheory.Limits.CokernelCofork.ofπ {C : Type u} {X : C} {Y : C} {f : X Y} {Z : C} (π : Y Z) (w : ) :

A morphism π satisfying f ≫ π = 0 determines a cokernel cofork on f.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.CokernelCofork.π_ofπ {C : Type u} {X : C} {Y : C} {P : C} (f : X Y) (π : Y P) (w : ) :
def CategoryTheory.Limits.isoOfπ {C : Type u} {X : C} {Y : C} {f : X Y} (s : ) :

Every cokernel cofork s is isomorphic (actually, equal) to cofork.ofπ (cofork.π s) _.

Equations
Instances For
def CategoryTheory.Limits.ofπCongr {C : Type u} {X : C} {Y : C} {f : X Y} {P : C} {π : Y P} {π' : Y P} {w : } (h : π = π') :

If π = π', then CokernelCofork.of_π π _ and CokernelCofork.of_π π' _ are isomorphic.

Equations
Instances For
def CategoryTheory.Limits.CokernelCofork.IsColimit.desc' {C : Type u} {X : C} {Y : C} {f : X Y} (hs : ) {W : C} (k : Y W) (h : ) :
{ l : s.pt W // }

If s is a colimit cokernel cofork, then every k : Y ⟶ W satisfying f ≫ k = 0 induces l : s.X ⟶ W such that cofork.π s ≫ l = k.

Equations
• = hs.desc ,
Instances For
def CategoryTheory.Limits.isColimitAux {C : Type u} {X : C} {Y : C} {f : X Y} (desc : (s : ) → t.pt s.pt) (fac : ) (uniq : ∀ (s : ) (m : t.pt s.pt), ) :

This is a slightly more convenient method to verify that a cokernel cofork is a colimit cocone. It only asks for a proof of facts that carry any mathematical content

Equations
Instances For
def CategoryTheory.Limits.CokernelCofork.IsColimit.ofπ {C : Type u} {X : C} {Y : C} {f : X Y} {Z : C} (g : Y Z) (eq : ) (desc : {Z' : C} → (g' : Y Z') → (Z Z')) (fac : ∀ {Z' : C} (g' : Y Z') (eq' : ), CategoryTheory.CategoryStruct.comp g (desc g' eq') = g') (uniq : ∀ {Z' : C} (g' : Y Z') (eq' : ) (m : Z Z'), m = desc g' eq') :

This is a more convenient formulation to show that a CokernelCofork constructed using CokernelCofork.ofπ is a limit cone.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.CokernelCofork.IsColimit.ofπ' {C : Type u} {X : C} {Y : C} {Q : C} {f : X Y} (p : Y Q) (w : ) (h : {A : C} → (k : Y A) → { l : Q A // }) [hp : ] :

This is a more convenient formulation to show that a CokernelCofork of the form CokernelCofork.ofπ p _ is a colimit cocone when we know that p is an epimorphism.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.isCokernelEpiComp {C : Type u} {X : C} {Y : C} {f : X Y} {W : C} (g : W X) [hg : ] {h : W Y} (hh : ) :

Every cokernel of f induces a cokernel of g ≫ f if g is epi.

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem CategoryTheory.Limits.isCokernelEpiComp_desc {C : Type u} {X : C} {Y : C} {f : X Y} {W : C} (g : W X) [hg : ] {h : W Y} (hh : ) :
.desc s =
def CategoryTheory.Limits.isCokernelOfComp {C : Type u} {X : C} {Y : C} {f : X Y} {W : C} (g : W X) (h : W Y) (hfg : ) :

Every cokernel of g ≫ f is also a cokernel of f, as long as f ≫ c.π vanishes.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.CokernelCofork.IsColimit.ofId {C : Type u} {X : C} {Y : C} (f : X Y) (hf : f = 0) :

Y identifies to the cokernel of a zero map X ⟶ Y.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.CokernelCofork.IsColimit.ofEpiOfIsZero {C : Type u} {X : C} {Y : C} {f : X Y} (hf : ) (h : ) :

Any zero object identifies to the cokernel of a given epimorphisms.

Equations
Instances For
theorem CategoryTheory.Limits.CokernelCofork.IsColimit.isIso_π {C : Type u} {X : C} {Y : C} {f : X Y} (hc : ) (hf : f = 0) :
def CategoryTheory.Limits.CokernelCofork.mapOfIsColimit {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} (hf : ) (cc' : ) (φ : ) :
cc.pt cc'.pt

The morphism between points of cokernel coforks induced by a morphism in the category of arrows.

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem CategoryTheory.Limits.CokernelCofork.π_mapOfIsColimit_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} (hf : ) (cc' : ) (φ : ) {Z : C} (h : cc'.pt Z) :
@[simp]
theorem CategoryTheory.Limits.CokernelCofork.π_mapOfIsColimit {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} (hf : ) (cc' : ) (φ : ) :
@[simp]
theorem CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit_inv {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} {cc' : } (hf : ) (hf' : ) (φ : ) :
.inv =
@[simp]
theorem CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit_hom {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} {cc' : } (hf : ) (hf' : ) (φ : ) :
.hom =
def CategoryTheory.Limits.CokernelCofork.mapIsoOfIsColimit {C : Type u} {X : C} {Y : C} {f : X Y} {X' : C} {Y' : C} {f' : X' Y'} {cc' : } (hf : ) (hf' : ) (φ : ) :
cc.pt cc'.pt

The isomorphism between points of limit cokernel coforks induced by an isomorphism in the category of arrows.

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[reducible, inline]
abbrev CategoryTheory.Limits.cokernel {C : Type u} {X : C} {Y : C} (f : X Y) :
C

The cokernel of a morphism, expressed as the coequalizer with the 0 morphism.

Equations
Instances For
@[reducible, inline]
abbrev CategoryTheory.Limits.cokernel.π {C : Type u} {X : C} {Y : C} (f : X Y) :

The map from the target of f to cokernel f.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.coequalizer_as_cokernel {C : Type u} {X : C} {Y : C} (f : X Y) :
@[simp]
theorem CategoryTheory.Limits.cokernel.condition_assoc {C : Type u} {X : C} {Y : C} (f : X Y) {Z : C} (h : ) :
@[simp]
theorem CategoryTheory.Limits.cokernel.condition {C : Type u} {X : C} {Y : C} (f : X Y) :
def CategoryTheory.Limits.cokernelIsCokernel {C : Type u} {X : C} {Y : C} (f : X Y) :

The cokernel built from cokernel.π f is colimiting.

Equations
• One or more equations did not get rendered due to their size.
Instances For
@[reducible, inline]
abbrev CategoryTheory.Limits.cokernel.desc {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (k : Y W) (h : ) :

Given any morphism k : Y ⟶ W such that f ≫ k = 0, k factors through cokernel.π f via cokernel.desc : cokernel f ⟶ W.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.cokernel.π_desc_assoc {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (k : Y W) (h : ) {Z : C} (h : W Z) :
@[simp]
theorem CategoryTheory.Limits.cokernel.π_desc {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (k : Y W) (h : ) :
@[simp]
theorem CategoryTheory.Limits.colimit_ι_zero_cokernel_desc_assoc {C : Type u_1} [] {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z✝) (h : ) {Z : C} (h : Z✝ Z) :
@[simp]
theorem CategoryTheory.Limits.colimit_ι_zero_cokernel_desc {C : Type u_1} [] {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) (h : ) :
@[simp]
theorem CategoryTheory.Limits.cokernel.desc_zero {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} {h : } :
instance CategoryTheory.Limits.cokernel.desc_epi {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (k : Y W) (h : ) :
Equations
• =
def CategoryTheory.Limits.cokernel.desc' {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (k : Y W) (h : ) :

Any morphism k : Y ⟶ W satisfying f ≫ k = 0 induces l : cokernel f ⟶ W such that cokernel.π f ≫ l = k.

Equations
Instances For
@[reducible, inline]
abbrev CategoryTheory.Limits.cokernel.map {C : Type u} {X : C} {Y : C} (f : X Y) {X' : C} {Y' : C} (f' : X' Y') (p : X X') (q : Y Y') :

A commuting square induces a morphism of cokernels.

Equations
Instances For
theorem CategoryTheory.Limits.cokernel.map_desc {C : Type u} {X : C} {Y : C} {Z : C} {X' : C} {Y' : C} {Z' : C} (f : X Y) (g : Y Z) (w : ) (f' : X' Y') (g' : Y' Z') (w' : ) (p : X X') (q : Y Y') (r : Z Z') :

Given a commutative diagram X --f--> Y --g--> Z | | | | | | v v v X' -f'-> Y' -g'-> Z' with horizontal arrows composing to zero, then we obtain a commutative square cokernel f ---> Z | | | cokernel.map | | | v v cokernel f' --> Z'

@[simp]
theorem CategoryTheory.Limits.cokernel.mapIso_hom {C : Type u} {X : C} {Y : C} (f : X Y) {X' : C} {Y' : C} (f' : X' Y') (p : X X') (q : Y Y') (w : ) :
.hom = CategoryTheory.Limits.cokernel.map f f' p.hom q.hom w
@[simp]
theorem CategoryTheory.Limits.cokernel.mapIso_inv {C : Type u} {X : C} {Y : C} (f : X Y) {X' : C} {Y' : C} (f' : X' Y') (p : X X') (q : Y Y') (w : ) :
.inv = CategoryTheory.Limits.cokernel.map f' f p.inv q.inv
def CategoryTheory.Limits.cokernel.mapIso {C : Type u} {X : C} {Y : C} (f : X Y) {X' : C} {Y' : C} (f' : X' Y') (p : X X') (q : Y Y') (w : ) :

A commuting square of isomorphisms induces an isomorphism of cokernels.

Equations
• One or more equations did not get rendered due to their size.
Instances For
instance CategoryTheory.Limits.cokernel.π_zero_isIso {C : Type u} {X : C} {Y : C} :

The cokernel of the zero morphism is an isomorphism

Equations
• =
theorem CategoryTheory.Limits.eq_zero_of_mono_cokernel {C : Type u} {X : C} {Y : C} (f : X Y) :
f = 0

The cokernel of a zero morphism is isomorphic to the target.

Equations
• CategoryTheory.Limits.cokernelZeroIsoTarget =
Instances For
@[simp]
theorem CategoryTheory.Limits.cokernelZeroIsoTarget_hom {C : Type u} {X : C} {Y : C} :
CategoryTheory.Limits.cokernelZeroIsoTarget.hom =
@[simp]
theorem CategoryTheory.Limits.cokernelZeroIsoTarget_inv {C : Type u} {X : C} {Y : C} :
CategoryTheory.Limits.cokernelZeroIsoTarget.inv =
def CategoryTheory.Limits.cokernelIsoOfEq {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} (h : f = g) :

If two morphisms are known to be equal, then their cokernels are isomorphic.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.cokernelIsoOfEq_refl {C : Type u} {X : C} {Y : C} (f : X Y) {h : f = f} :
@[simp]
theorem CategoryTheory.Limits.π_comp_cokernelIsoOfEq_hom_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} (h : f = g) {Z : C} (h : ) :
@[simp]
theorem CategoryTheory.Limits.π_comp_cokernelIsoOfEq_hom {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} (h : f = g) :
@[simp]
theorem CategoryTheory.Limits.π_comp_cokernelIsoOfEq_inv_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} (h : f = g) {Z : C} (h : ) :
@[simp]
theorem CategoryTheory.Limits.π_comp_cokernelIsoOfEq_inv {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} (h : f = g) :
@[simp]
theorem CategoryTheory.Limits.cokernelIsoOfEq_hom_comp_desc_assoc {C : Type u} {X : C} {Y : C} {Z : C} {f : X Y} {g : X Y} (h : f = g) (e : Y Z✝) (he : ) {Z : C} (h : Z✝ Z) :
@[simp]
theorem CategoryTheory.Limits.cokernelIsoOfEq_hom_comp_desc {C : Type u} {X : C} {Y : C} {Z : C} {f : X Y} {g : X Y} (h : f = g) (e : Y Z) (he : ) :
@[simp]
theorem CategoryTheory.Limits.cokernelIsoOfEq_inv_comp_desc_assoc {C : Type u} {X : C} {Y : C} {Z : C} {f : X Y} {g : X Y} (h : f = g) (e : Y Z✝) (he : ) {Z : C} (h : Z✝ Z) :
@[simp]
theorem CategoryTheory.Limits.cokernelIsoOfEq_inv_comp_desc {C : Type u} {X : C} {Y : C} {Z : C} {f : X Y} {g : X Y} (h : f = g) (e : Y Z) (he : ) :
@[simp]
theorem CategoryTheory.Limits.cokernelIsoOfEq_trans {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {h : X Y} (w₁ : f = g) (w₂ : g = h) :
theorem CategoryTheory.Limits.cokernel_not_mono_of_nonzero {C : Type u} {X : C} {Y : C} {f : X Y} (w : f 0) :
theorem CategoryTheory.Limits.cokernel_not_iso_of_nonzero {C : Type u} {X : C} {Y : C} {f : X Y} (w : f 0) :
instance CategoryTheory.Limits.hasCokernel_comp_iso {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
Equations
• =
@[simp]
theorem CategoryTheory.Limits.cokernelCompIsIso_inv {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
@[simp]
theorem CategoryTheory.Limits.cokernelCompIsIso_hom {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
def CategoryTheory.Limits.cokernelCompIsIso {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :

When g is an isomorphism, the cokernel of f ≫ g is isomorphic to the cokernel of f.

Equations
• One or more equations did not get rendered due to their size.
Instances For
instance CategoryTheory.Limits.hasCokernel_epi_comp {C : Type u} {X : C} {Y : C} (f : X Y) {W : C} (g : W X) :
Equations
• =
@[simp]
theorem CategoryTheory.Limits.cokernelEpiComp_hom {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
@[simp]
theorem CategoryTheory.Limits.cokernelEpiComp_inv {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :
def CategoryTheory.Limits.cokernelEpiComp {C : Type u} {X : C} {Y : C} {Z : C} (f : X Y) (g : Y Z) :

When f is an epimorphism, the cokernel of f ≫ g is isomorphic to the cokernel of g.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.cokernel.zeroCokernelCofork {C : Type u} {X : C} {Y : C} (f : X Y) :

The morphism to the zero object determines a cocone on a cokernel diagram

Equations
Instances For

The morphism to the zero object is a cokernel of an epimorphism

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.cokernel.ofEpi {C : Type u} {X : C} {Y : C} (f : X Y) :

The cokernel of an epimorphism is isomorphic to the zero object

Equations
• One or more equations did not get rendered due to their size.
Instances For
theorem CategoryTheory.Limits.cokernel.π_of_epi {C : Type u} {X : C} {Y : C} (f : X Y) :

The cokernel morphism of an epimorphism is a zero morphism

@[simp]
theorem CategoryTheory.Limits.MonoFactorisation.kernel_ι_comp {C : Type u} {X : C} {Y : C} {f : X Y} :
@[simp]
@[simp]

The cokernel of the image inclusion of a morphism f is isomorphic to the cokernel of f.

(This result requires that the factorisation through the image is an epimorphism. This holds in any category with equalizers.)

Equations
• One or more equations did not get rendered due to their size.
Instances For
theorem CategoryTheory.Limits.cokernel.π_of_zero {C : Type u} (X : C) (Y : C) :

The cokernel of a zero morphism is an isomorphism

The kernel of the cokernel of an epimorphism is an isomorphism

Equations
• =

The cokernel of the kernel of a monomorphism is an isomorphism

Equations
• =
def CategoryTheory.Limits.zeroCokernelOfZeroCancel {C : Type u} {X : C} {Y : C} (f : X Y) (hf : ∀ (Z : C) (g : Y Z), g = 0) :

If f ≫ g = 0 implies g = 0 for all g, then 0 : Y ⟶ 0 is a cokernel of f.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.IsCokernel.ofIsoComp {C : Type u} {X : C} {Y : C} (f : X Y) {Z : C} (l : Z Y) (i : X Z) (h : = f) (hs : ) :

If i is an isomorphism such that i.hom ≫ l = f, then any cokernel of f is a cokernel of l.

Equations
• One or more equations did not get rendered due to their size.
Instances For
def CategoryTheory.Limits.cokernel.ofIsoComp {C : Type u} {X : C} {Y : C} (f : X Y) {Z : C} (l : Z Y) (i : X Z) (h : = f) :

If i is an isomorphism such that i.hom ≫ l = f, then the cokernel of f is a cokernel of l.

Equations
Instances For
def CategoryTheory.Limits.IsCokernel.cokernelIso {C : Type u} {X : C} {Y : C} (f : X Y) {Z : C} (l : Y Z) (hs : ) (i : s.pt Z) (h : ) :

If s is any colimit cokernel cocone over f and i is an isomorphism such that s.π ≫ i.hom = l, then l is a cokernel of f.

Equations
• = hs.ofIsoColimit
Instances For
def CategoryTheory.Limits.cokernel.cokernelIso {C : Type u} {X : C} {Y : C} (f : X Y) {Z : C} (l : Y Z) (i : ) (h : ) :

If i is an isomorphism such that cokernel.π f ≫ i.hom = l, then l is a cokernel of f.

Equations
Instances For
def CategoryTheory.Limits.kernelComparison {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasKernel (G.map f)] :

The comparison morphism for the kernel of f. This is an isomorphism iff G preserves the kernel of f; see CategoryTheory/Limits/Preserves/Shapes/Kernels.lean

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.kernelComparison_comp_ι_assoc {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasKernel (G.map f)] {Z : D} (h : G.obj X Z) :
@[simp]
theorem CategoryTheory.Limits.kernelComparison_comp_ι {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasKernel (G.map f)] :
= G.map
@[simp]
theorem CategoryTheory.Limits.map_lift_kernelComparison_assoc {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasKernel (G.map f)] {Z : C} {h : Z✝ X} (w : ) {Z : D} (h : CategoryTheory.Limits.kernel (G.map f) Z) :
@[simp]
theorem CategoryTheory.Limits.map_lift_kernelComparison {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasKernel (G.map f)] {Z : C} {h : Z X} (w : ) :
= CategoryTheory.Limits.kernel.lift (G.map f) (G.map h)
theorem CategoryTheory.Limits.kernelComparison_comp_kernel_map_assoc {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] {X' : C} {Y' : C} [CategoryTheory.Limits.HasKernel (G.map f)] (g : X' Y') [CategoryTheory.Limits.HasKernel (G.map g)] (p : X X') (q : Y Y') {Z : D} (h : CategoryTheory.Limits.kernel (G.map g) Z) :
theorem CategoryTheory.Limits.kernelComparison_comp_kernel_map {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] {X' : C} {Y' : C} [CategoryTheory.Limits.HasKernel (G.map f)] (g : X' Y') [CategoryTheory.Limits.HasKernel (G.map g)] (p : X X') (q : Y Y') :
def CategoryTheory.Limits.cokernelComparison {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasCokernel (G.map f)] :

The comparison morphism for the cokernel of f.

Equations
Instances For
@[simp]
theorem CategoryTheory.Limits.π_comp_cokernelComparison_assoc {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasCokernel (G.map f)] {Z : D} (h : G.obj Z) :
@[simp]
theorem CategoryTheory.Limits.π_comp_cokernelComparison {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasCokernel (G.map f)] :
@[simp]
theorem CategoryTheory.Limits.cokernelComparison_map_desc_assoc {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasCokernel (G.map f)] {Z : C} {h : Y Z✝} (w : ) {Z : D} (h : G.obj Z✝ Z) :
@[simp]
theorem CategoryTheory.Limits.cokernelComparison_map_desc {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] [CategoryTheory.Limits.HasCokernel (G.map f)] {Z : C} {h : Y Z} (w : ) :
= CategoryTheory.Limits.cokernel.desc (G.map f) (G.map h)
theorem CategoryTheory.Limits.cokernel_map_comp_cokernelComparison_assoc {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] {X' : C} {Y' : C} [CategoryTheory.Limits.HasCokernel (G.map f)] (g : X' Y') [CategoryTheory.Limits.HasCokernel (G.map g)] (p : X X') (q : Y Y') {Z : D} (h : G.obj Z) :
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.cokernel.map (G.map f) (G.map g) (G.map p) (G.map q) ) =
theorem CategoryTheory.Limits.cokernel_map_comp_cokernelComparison {C : Type u} {X : C} {Y : C} (f : X Y) {D : Type u₂} [] (G : ) [G.PreservesZeroMorphisms] {X' : C} {Y' : C} [CategoryTheory.Limits.HasCokernel (G.map f)] (g : X' Y') [CategoryTheory.Limits.HasCokernel (G.map g)] (p : X X') (q : Y Y') :

HasKernels represents the existence of kernels for every morphism.

• has_limit : ∀ {X Y : C} (f : X Y),
Instances
theorem CategoryTheory.Limits.HasKernels.has_limit {C : Type u} [self : ] {X : C} {Y : C} (f : X Y) :

HasCokernels represents the existence of cokernels for every morphism.

• has_colimit : ∀ {X Y : C} (f : X Y),
Instances
theorem CategoryTheory.Limits.HasCokernels.has_colimit {C : Type u} [self : ] {X : C} {Y : C} (f : X Y) :
@[instance 100]
Equations
• =
@[instance 100]
Equations
• =