# Split coequalizers #

We define what it means for a triple of morphisms f g : X ⟶ Y, π : Y ⟶ Z to be a split coequalizer: there is a section s of π and a section t of g, which additionally satisfy t ≫ f = π ≫ s.

In addition, we show that every split coequalizer is a coequalizer (CategoryTheory.IsSplitCoequalizer.isCoequalizer) and absolute (CategoryTheory.IsSplitCoequalizer.map)

A pair f g : X ⟶ Y has a split coequalizer if there is a Z and π : Y ⟶ Z making f,g,π a split coequalizer. A pair f g : X ⟶ Y has a G-split coequalizer if G f, G g has a split coequalizer.

These definitions and constructions are useful in particular for the monadicity theorems.

## TODO #

Dualise to split equalizers.

structure CategoryTheory.IsSplitCoequalizer {C : Type u} {X : C} {Y : C} (f : X Y) (g : X Y) {Z : C} (π : Y Z) :

A split coequalizer diagram consists of morphisms

  f   π
X ⇉ Y → Z
g


satisfying f ≫ π = g ≫ π together with morphisms

  t   s
X ← Y ← Z


satisfying s ≫ π = 𝟙 Z, t ≫ g = 𝟙 Y and t ≫ f = π ≫ s.

The name "coequalizer" is appropriate, since any split coequalizer is a coequalizer, see Category_theory.IsSplitCoequalizer.isCoequalizer. Split coequalizers are also absolute, since a functor preserves all the structure above.

• rightSection : Z Y

A map from the coequalizer to Y

• leftSection : Y X

A map in the opposite direction to f and g

• condition :

Composition of π with f and with g agree

• rightSection_π : CategoryTheory.CategoryStruct.comp self.rightSection π =

rightSection splits π

• leftSection_bottom : CategoryTheory.CategoryStruct.comp self.leftSection g =

leftSection splits g

• leftSection_top : CategoryTheory.CategoryStruct.comp self.leftSection f = CategoryTheory.CategoryStruct.comp π self.rightSection

leftSection composed with f is pi composed with rightSection

Instances For
theorem CategoryTheory.IsSplitCoequalizer.condition {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z} (self : ) :

Composition of π with f and with g agree

@[simp]
theorem CategoryTheory.IsSplitCoequalizer.rightSection_π {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z} (self : ) :

rightSection splits π

@[simp]
theorem CategoryTheory.IsSplitCoequalizer.leftSection_bottom {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z} (self : ) :

leftSection splits g

@[simp]
theorem CategoryTheory.IsSplitCoequalizer.leftSection_top {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z} (self : ) :

leftSection composed with f is pi composed with rightSection

Equations
• One or more equations did not get rendered due to their size.
theorem CategoryTheory.IsSplitCoequalizer.condition_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z✝} (self : ) {Z : C} (h : Z✝ Z) :
@[simp]
theorem CategoryTheory.IsSplitCoequalizer.leftSection_top_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z✝} (self : ) {Z : C} (h : Y Z) :
@[simp]
theorem CategoryTheory.IsSplitCoequalizer.rightSection_π_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z✝} (self : ) {Z : C} (h : Z✝ Z) :
@[simp]
theorem CategoryTheory.IsSplitCoequalizer.leftSection_bottom_assoc {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z✝} (self : ) {Z : C} (h : Y Z) :
@[simp]
theorem CategoryTheory.IsSplitCoequalizer.map_rightSection {C : Type u} {D : Type u₂} [] {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z} (q : ) (F : ) :
(q.map F).rightSection = F.map q.rightSection
@[simp]
theorem CategoryTheory.IsSplitCoequalizer.map_leftSection {C : Type u} {D : Type u₂} [] {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z} (q : ) (F : ) :
(q.map F).leftSection = F.map q.leftSection
def CategoryTheory.IsSplitCoequalizer.map {C : Type u} {D : Type u₂} [] {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {π : Y Z} (q : ) (F : ) :
CategoryTheory.IsSplitCoequalizer (F.map f) (F.map g) (F.map π)

Split coequalizers are absolute: they are preserved by any functor.

Equations
• q.map F = { rightSection := F.map q.rightSection, leftSection := F.map q.leftSection, condition := , rightSection_π := , leftSection_bottom := , leftSection_top := }
Instances For
@[simp]
theorem CategoryTheory.IsSplitCoequalizer.asCofork_pt {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {h : Y Z} (t : ) :
t.asCofork.pt = Z
def CategoryTheory.IsSplitCoequalizer.asCofork {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {h : Y Z} (t : ) :

A split coequalizer clearly induces a cofork.

Equations
• t.asCofork =
Instances For
@[simp]
theorem CategoryTheory.IsSplitCoequalizer.asCofork_π {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {h : Y Z} (t : ) :
t.asCofork = h
def CategoryTheory.IsSplitCoequalizer.isCoequalizer {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} {Z : C} {h : Y Z} (t : ) :

The cofork induced by a split coequalizer is a coequalizer, justifying the name. In some cases it is more convenient to show a given cofork is a coequalizer by showing it is split.

Equations
Instances For
class CategoryTheory.HasSplitCoequalizer {C : Type u} {X : C} {Y : C} (f : X Y) (g : X Y) :

The pair f,g is a split pair if there is an h : Y ⟶ Z so that f, g, h forms a split coequalizer in C.

• splittable : ∃ (Z : C) (h : Y Z),

There is some split coequalizer

Instances
theorem CategoryTheory.HasSplitCoequalizer.splittable {C : Type u} {X : C} {Y : C} {f : X Y} {g : X Y} [self : ] :
∃ (Z : C) (h : Y Z),

There is some split coequalizer

@[reducible, inline]
abbrev CategoryTheory.Functor.IsSplitPair {C : Type u} {D : Type u₂} [] (G : ) {X : C} {Y : C} (f : X Y) (g : X Y) :

The pair f,g is a G-split pair if there is an h : G Y ⟶ Z so that G f, G g, h forms a split coequalizer in D.

Equations
Instances For
noncomputable def CategoryTheory.HasSplitCoequalizer.coequalizerOfSplit {C : Type u} {X : C} {Y : C} (f : X Y) (g : X Y) :
C

Get the coequalizer object from the typeclass IsSplitPair.

Equations
Instances For
noncomputable def CategoryTheory.HasSplitCoequalizer.coequalizerπ {C : Type u} {X : C} {Y : C} (f : X Y) (g : X Y) :

Get the coequalizer morphism from the typeclass IsSplitPair.

Equations
• = .choose
Instances For
noncomputable def CategoryTheory.HasSplitCoequalizer.isSplitCoequalizer {C : Type u} {X : C} {Y : C} (f : X Y) (g : X Y) :

The coequalizer morphism coequalizeπ gives a split coequalizer on f,g.

Equations
Instances For
instance CategoryTheory.map_is_split_pair {C : Type u} {D : Type u₂} [] (G : ) {X : C} {Y : C} (f : X Y) (g : X Y) :

If f, g is split, then G f, G g is split.

Equations
• =
@[instance 1]
instance CategoryTheory.Limits.hasCoequalizer_of_hasSplitCoequalizer {C : Type u} {X : C} {Y : C} (f : X Y) (g : X Y) :

If a pair has a split coequalizer, it has a coequalizer.

Equations
• =