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} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (f : X ⟶ Y) (g : X ⟶ Y) {Z : C} (π : Y ⟶ Z) : Type v

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 : CategoryTheory.CategoryStruct.comp f π = CategoryTheory.CategoryStruct.comp g π

  Composition of π with f and with g agree

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

  rightSection splits π

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

  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

instance CategoryTheory.instInhabitedIsSplitCoequalizerIdToCategoryStruct {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} : Inhabited (CategoryTheory.IsSplitCoequalizer (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X))

Equations

• One or more equations did not get rendered due to their size.

theorem CategoryTheory.IsSplitCoequalizer.condition_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {π : Y ⟶ Z✝} (self : CategoryTheory.IsSplitCoequalizer f g π) {Z : C} (h : Z✝ ⟶ Z) : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp π h) = CategoryTheory.CategoryStruct.comp g (CategoryTheory.CategoryStruct.comp π h)

@[simp]

theorem CategoryTheory.IsSplitCoequalizer.rightSection_π_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {π : Y ⟶ Z✝} (self : CategoryTheory.IsSplitCoequalizer f g π) {Z : C} (h : Z✝ ⟶ Z) : CategoryTheory.CategoryStruct.comp self.rightSection (CategoryTheory.CategoryStruct.comp π h) = h

@[simp]

theorem CategoryTheory.IsSplitCoequalizer.leftSection_top_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {π : Y ⟶ Z✝} (self : CategoryTheory.IsSplitCoequalizer f g π) {Z : C} (h : Y ⟶ Z) : CategoryTheory.CategoryStruct.comp self.leftSection (CategoryTheory.CategoryStruct.comp f h) = CategoryTheory.CategoryStruct.comp π (CategoryTheory.CategoryStruct.comp self.rightSection h)

@[simp]

theorem CategoryTheory.IsSplitCoequalizer.leftSection_bottom_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {π : Y ⟶ Z✝} (self : CategoryTheory.IsSplitCoequalizer f g π) {Z : C} (h : Y ⟶ Z) : CategoryTheory.CategoryStruct.comp self.leftSection (CategoryTheory.CategoryStruct.comp g h) = h

@[simp]

theorem CategoryTheory.IsSplitCoequalizer.map_leftSection {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {π : Y ⟶ Z} (q : CategoryTheory.IsSplitCoequalizer f g π) (F : CategoryTheory.Functor C D) : (CategoryTheory.IsSplitCoequalizer.map q F).leftSection = F.toPrefunctor.map q.leftSection

@[simp]

theorem CategoryTheory.IsSplitCoequalizer.map_rightSection {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {π : Y ⟶ Z} (q : CategoryTheory.IsSplitCoequalizer f g π) (F : CategoryTheory.Functor C D) : (CategoryTheory.IsSplitCoequalizer.map q F).rightSection = F.toPrefunctor.map q.rightSection

def CategoryTheory.IsSplitCoequalizer.map {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {π : Y ⟶ Z} (q : CategoryTheory.IsSplitCoequalizer f g π) (F : CategoryTheory.Functor C D) : CategoryTheory.IsSplitCoequalizer (F.toPrefunctor.map f) (F.toPrefunctor.map g) (F.toPrefunctor.map π)

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

Equations

• One or more equations did not get rendered due to their size.

@[simp]

theorem CategoryTheory.IsSplitCoequalizer.asCofork_pt {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {h : Y ⟶ Z} (t : CategoryTheory.IsSplitCoequalizer f g h) : (CategoryTheory.IsSplitCoequalizer.asCofork t).pt = Z

def CategoryTheory.IsSplitCoequalizer.asCofork {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {h : Y ⟶ Z} (t : CategoryTheory.IsSplitCoequalizer f g h) : CategoryTheory.Limits.Cofork f g

A split coequalizer clearly induces a cofork.

Equations

• CategoryTheory.IsSplitCoequalizer.asCofork t = CategoryTheory.Limits.Cofork.ofπ h (_ : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h)

@[simp]

theorem CategoryTheory.IsSplitCoequalizer.asCofork_π {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {h : Y ⟶ Z} (t : CategoryTheory.IsSplitCoequalizer f g h) : CategoryTheory.Limits.Cofork.π (CategoryTheory.IsSplitCoequalizer.asCofork t) = h

def CategoryTheory.IsSplitCoequalizer.isCoequalizer {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {Z : C} {h : Y ⟶ Z} (t : CategoryTheory.IsSplitCoequalizer f g h) : CategoryTheory.Limits.IsColimit (CategoryTheory.IsSplitCoequalizer.asCofork 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

• One or more equations did not get rendered due to their size.

class CategoryTheory.HasSplitCoequalizer {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (f : X ⟶ Y) (g : X ⟶ Y) : Prop

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), Nonempty (CategoryTheory.IsSplitCoequalizer f g h)

  There is some split coequalizer

@[inline, reducible]

abbrev CategoryTheory.Functor.IsSplitPair {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) {X : C} {Y : C} (f : X ⟶ Y) (g : X ⟶ Y) : Prop

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

• CategoryTheory.Functor.IsSplitPair G f g = CategoryTheory.HasSplitCoequalizer (G.toPrefunctor.map f) (G.toPrefunctor.map g)

noncomputable def CategoryTheory.HasSplitCoequalizer.coequalizerOfSplit {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (f : X ⟶ Y) (g : X ⟶ Y) [CategoryTheory.HasSplitCoequalizer f g] : C

Get the coequalizer object from the typeclass IsSplitPair.

Equations

• CategoryTheory.HasSplitCoequalizer.coequalizerOfSplit f g = Exists.choose (_ : ∃ (Z : C) (h : Y ⟶ Z), Nonempty (CategoryTheory.IsSplitCoequalizer f g h))

noncomputable def CategoryTheory.HasSplitCoequalizer.coequalizerπ {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (f : X ⟶ Y) (g : X ⟶ Y) [CategoryTheory.HasSplitCoequalizer f g] : Y ⟶ CategoryTheory.HasSplitCoequalizer.coequalizerOfSplit f g

Get the coequalizer morphism from the typeclass IsSplitPair.

Equations

• One or more equations did not get rendered due to their size.

noncomputable def CategoryTheory.HasSplitCoequalizer.isSplitCoequalizer {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (f : X ⟶ Y) (g : X ⟶ Y) [CategoryTheory.HasSplitCoequalizer f g] : CategoryTheory.IsSplitCoequalizer f g (CategoryTheory.HasSplitCoequalizer.coequalizerπ f g)

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

Equations

• One or more equations did not get rendered due to their size.

instance CategoryTheory.map_is_split_pair {C : Type u} [CategoryTheory.Category.{v, u} C] {D : Type u₂} [CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) {X : C} {Y : C} (f : X ⟶ Y) (g : X ⟶ Y) [CategoryTheory.HasSplitCoequalizer f g] : CategoryTheory.HasSplitCoequalizer (G.toPrefunctor.map f) (G.toPrefunctor.map g)

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

Equations

• (_ : CategoryTheory.HasSplitCoequalizer (G.toPrefunctor.map f) (G.toPrefunctor.map g)) = (_ : CategoryTheory.HasSplitCoequalizer (G.toPrefunctor.map f) (G.toPrefunctor.map g))

instance CategoryTheory.Limits.hasCoequalizer_of_hasSplitCoequalizer {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (f : X ⟶ Y) (g : X ⟶ Y) [CategoryTheory.HasSplitCoequalizer f g] : CategoryTheory.Limits.HasCoequalizer f g

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

Equations

• (_ : CategoryTheory.Limits.HasCoequalizer f g) = (_ : CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.parallelPair f g))