Documentation

Mathlib.CategoryTheory.Limits.Shapes.SplitEqualizer

Split Equalizers #

We define what it means for a triple of morphisms f g : X ⟶ Y, ι : W ⟶ X to be a split equalizer: there is a retraction r of ι and a retraction t of g, which additionally satisfy t ≫ f = r ≫ ι.

In addition, we show that every split equalizer is an equalizer (CategoryTheory.IsSplitEqualizer.isEqualizer) and absolute (CategoryTheory.IsSplitEqualizer.map)

A pair f g : X ⟶ Y has a split equalizer if there is a W and ι : W ⟶ X making f,g,ι a split equalizer. A pair f g : X ⟶ Y has a G-split equalizer if G f, G g has a split equalizer.

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

This file was adapted from Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer. Please try to keep them in sync.

structure CategoryTheory.IsSplitEqualizer {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} (f : X ⟶ Y) (g : X ⟶ Y) {W : C} (ι : W ⟶ X) :

A split equalizer diagram consists of morphisms

      ι   f
    W → X ⇉ Y
          g

satisfying ι ≫ f = ι ≫ g together with morphisms

      r   t
    W ← X ← Y

satisfying ι ≫ r = 𝟙 W, g ≫ t = 𝟙 X and f ≫ t = r ≫ ι.

The name "equalizer" is appropriate, since any split equalizer is a equalizer, see CategoryTheory.IsSplitEqualizer.isEqualizer. Split equalizers are also absolute, since a functor preserves all the structure above.

leftRetraction : X ⟶ W
A map from X to the equalizer
rightRetraction : 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
ι_leftRetraction : CategoryTheory.CategoryStruct.comp ι self.leftRetraction = CategoryTheory.CategoryStruct.id W
leftRetraction splits ι
bottom_rightRetraction : CategoryTheory.CategoryStruct.comp g self.rightRetraction = CategoryTheory.CategoryStruct.id X
rightRetraction splits g
top_rightRetraction : CategoryTheory.CategoryStruct.comp f self.rightRetraction = CategoryTheory.CategoryStruct.comp self.leftRetraction ι
f composed with rightRetraction is leftRetraction composed with ι

Instances For

theorem CategoryTheory.IsSplitEqualizer.condition {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι) :

CategoryTheory.CategoryStruct.comp ι f = CategoryTheory.CategoryStruct.comp ι g

Composition of ι with f and with g agree

@[simp]

theorem CategoryTheory.IsSplitEqualizer.ι_leftRetraction {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι) :

CategoryTheory.CategoryStruct.comp ι self.leftRetraction = CategoryTheory.CategoryStruct.id W

leftRetraction splits ι

@[simp]

theorem CategoryTheory.IsSplitEqualizer.bottom_rightRetraction {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι) :

CategoryTheory.CategoryStruct.comp g self.rightRetraction = CategoryTheory.CategoryStruct.id X

rightRetraction splits g

@[simp]

theorem CategoryTheory.IsSplitEqualizer.top_rightRetraction {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι) :

CategoryTheory.CategoryStruct.comp f self.rightRetraction = CategoryTheory.CategoryStruct.comp self.leftRetraction ι

f composed with rightRetraction is leftRetraction composed with ι

instance CategoryTheory.instInhabitedIsSplitEqualizerId {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} :

Inhabited (CategoryTheory.IsSplitEqualizer (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.IsSplitEqualizer.condition_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι) {Z : C} (h : Y ⟶ Z) :

CategoryTheory.CategoryStruct.comp ι (CategoryTheory.CategoryStruct.comp f h) = CategoryTheory.CategoryStruct.comp ι (CategoryTheory.CategoryStruct.comp g h)

@[simp]

theorem CategoryTheory.IsSplitEqualizer.bottom_rightRetraction_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι) {Z : C} (h : X ⟶ Z) :

CategoryTheory.CategoryStruct.comp g (CategoryTheory.CategoryStruct.comp self.rightRetraction h) = h

@[simp]

theorem CategoryTheory.IsSplitEqualizer.top_rightRetraction_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι) {Z : C} (h : X ⟶ Z) :

CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp self.rightRetraction h) = CategoryTheory.CategoryStruct.comp self.leftRetraction (CategoryTheory.CategoryStruct.comp ι h)

@[simp]

theorem CategoryTheory.IsSplitEqualizer.ι_leftRetraction_assoc {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {ι : W ⟶ X} (self : CategoryTheory.IsSplitEqualizer f g ι) {Z : C} (h : W ⟶ Z) :

CategoryTheory.CategoryStruct.comp ι (CategoryTheory.CategoryStruct.comp self.leftRetraction h) = h

def CategoryTheory.IsSplitEqualizer.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} {W : C} {ι : W ⟶ X} (q : CategoryTheory.IsSplitEqualizer f g ι) (F : CategoryTheory.Functor C D) :

CategoryTheory.IsSplitEqualizer (F.map f) (F.map g) (F.map ι)

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

Equations

q.map F = { leftRetraction := F.map q.leftRetraction, rightRetraction := F.map q.rightRetraction, condition := ⋯, ι_leftRetraction := ⋯, bottom_rightRetraction := ⋯, top_rightRetraction := ⋯ }

Instances For

@[simp]

theorem CategoryTheory.IsSplitEqualizer.map_leftRetraction {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} {W : C} {ι : W ⟶ X} (q : CategoryTheory.IsSplitEqualizer f g ι) (F : CategoryTheory.Functor C D) :

(q.map F).leftRetraction = F.map q.leftRetraction

@[simp]

theorem CategoryTheory.IsSplitEqualizer.map_rightRetraction {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} {W : C} {ι : W ⟶ X} (q : CategoryTheory.IsSplitEqualizer f g ι) (F : CategoryTheory.Functor C D) :

(q.map F).rightRetraction = F.map q.rightRetraction

def CategoryTheory.IsSplitEqualizer.asFork {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {h : W ⟶ X} (t : CategoryTheory.IsSplitEqualizer f g h) :

CategoryTheory.Limits.Fork f g

A split equalizer clearly induces a fork.

Equations

t.asFork = CategoryTheory.Limits.Fork.ofι h ⋯

Instances For

@[simp]

theorem CategoryTheory.IsSplitEqualizer.asFork_pt {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {h : W ⟶ X} (t : CategoryTheory.IsSplitEqualizer f g h) :

t.asFork.pt = W

@[simp]

theorem CategoryTheory.IsSplitEqualizer.asFork_ι {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {h : W ⟶ X} (t : CategoryTheory.IsSplitEqualizer f g h) :

t.asFork.ι = h

def CategoryTheory.IsSplitEqualizer.isEqualizer {C : Type u} [CategoryTheory.Category.{v, u} C] {X : C} {Y : C} {f : X ⟶ Y} {g : X ⟶ Y} {W : C} {h : W ⟶ X} (t : CategoryTheory.IsSplitEqualizer f g h) :

CategoryTheory.Limits.IsLimit t.asFork

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

Equations

t.isEqualizer = CategoryTheory.Limits.Fork.IsLimit.mk' t.asFork fun (s : CategoryTheory.Limits.Fork f g) => ⟨CategoryTheory.CategoryStruct.comp s.ι t.leftRetraction, ⋯⟩

Instances For

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

The pair f,g is a cosplit pair if there is an h : W ⟶ X so that f, g, h forms a split equalizer in C.

splittable : ∃ (W : C) (h : W ⟶ X), Nonempty (CategoryTheory.IsSplitEqualizer f g h)
There is some split equalizer

Instances

theorem CategoryTheory.HasSplitEqualizer.splittable {C : Type u} :

∀ {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f g : X ⟶ Y} [self : CategoryTheory.HasSplitEqualizer f g], ∃ (W : C) (h : W ⟶ X), Nonempty (CategoryTheory.IsSplitEqualizer f g h)

There is some split equalizer

@[reducible, inline]

abbrev CategoryTheory.Functor.IsCosplitPair {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) :

The pair f,g is a G-cosplit pair if there is an h : W ⟶ G X so that G f, G g, h forms a split equalizer in D.

Equations

G.IsCosplitPair f g = CategoryTheory.HasSplitEqualizer (G.map f) (G.map g)

Instances For

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

C

Get the equalizer object from the typeclass IsCosplitPair.

Equations

CategoryTheory.HasSplitEqualizer.equalizerOfSplit f g = ⋯.choose

Instances For

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

CategoryTheory.HasSplitEqualizer.equalizerOfSplit f g ⟶ X

Get the equalizer morphism from the typeclass IsCosplitPair.

Equations

CategoryTheory.HasSplitEqualizer.equalizerι f g = ⋯.choose

Instances For

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

CategoryTheory.IsSplitEqualizer f g (CategoryTheory.HasSplitEqualizer.equalizerι f g)

The equalizer morphism equalizerι gives a split equalizer on f,g.

Equations

CategoryTheory.HasSplitEqualizer.isSplitEqualizer f g = Classical.choice ⋯

Instances For

instance CategoryTheory.map_is_cosplit_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.HasSplitEqualizer f g] :

CategoryTheory.HasSplitEqualizer (G.map f) (G.map g)

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

Equations

⋯ = ⋯

@[instance 1]

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

CategoryTheory.Limits.HasEqualizer f g

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

Equations

⋯ = ⋯