The Factorisation Category of a Category

Factorisation f is the category containing as objects all factorisations of a morphism f.

We show that Factorisation f always has an initial and a terminal object.

TODO: Show that Factorisation f is isomorphic to a comma category in two ways.

TODO: Make MonoFactorisation f a special case of a Factorisation f.

structure CategoryTheory.Factorisation {C : Type u} [Category.{v, u} C] {X Y : C} (f : X ⟶ Y) : Type (max u v)

Factorisations of a morphism f as a structure, containing, one object, two morphisms, and the condition that their composition equals f.

• mid : C

  The midpoint of the factorisation.

• ι : X ⟶ self.mid

  The morphism into the factorisation midpoint.

• π : self.mid ⟶ Y

  The morphism out of the factorisation midpoint.

• ι_π : CategoryStruct.comp self.ι self.π = f

  The factorisation condition.

structure CategoryTheory.Factorisation.Hom {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d e : Factorisation f) : Type (max u v)

Morphisms of Factorisation f consist of morphism between their midpoints and the obvious commutativity conditions.

• h : d.mid ⟶ e.mid

  The morphism between the midpoints of the factorizations.

• ι_h : CategoryStruct.comp d.ι self.h = e.ι

  The left commuting triangle of the factorization morphism.

• h_π : CategoryStruct.comp self.h e.π = d.π

  The right commuting triangle of the factorization morphism.

theorem CategoryTheory.Factorisation.Hom.ext {C : Type u} {inst✝ : Category.{v, u} C} {X Y : C} {f : X ⟶ Y} {d e : Factorisation f} {x y : d.Hom e} (h : x.h = y.h) : x = y

theorem CategoryTheory.Factorisation.Hom.ext_iff {C : Type u} {inst✝ : Category.{v, u} C} {X Y : C} {f : X ⟶ Y} {d e : Factorisation f} {x y : d.Hom e} : x = y ↔ x.h = y.h

def CategoryTheory.Factorisation.Hom.id {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : Factorisation f) : d.Hom d

The identity morphism of Factorisation f.

@[simp]

theorem CategoryTheory.Factorisation.Hom.id_h {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : Factorisation f) : (Hom.id d).h = CategoryStruct.id d.mid

def CategoryTheory.Factorisation.Hom.comp {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {d₁ d₂ d₃ : Factorisation f} : d₁.Hom d₂ → (g : d₂.Hom d₃) → d₁.Hom d₃

Composition of morphisms in Factorisation f.

@[simp]

theorem CategoryTheory.Factorisation.Hom.comp_h {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {d₁ d₂ d₃ : Factorisation f} (f✝ : d₁.Hom d₂) (g : d₂.Hom d₃) : (f✝.comp g).h = CategoryStruct.comp f✝.h g.h

instance CategoryTheory.Factorisation.instCategory {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Category.{max u v, max u v} (Factorisation f)

def CategoryTheory.Factorisation.initial {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Factorisation f

The initial object in Factorisation f, with the domain of f as its midpoint.

@[simp]

theorem CategoryTheory.Factorisation.initial_mid {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Factorisation.initial.mid = X

@[simp]

theorem CategoryTheory.Factorisation.initial_ι {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Factorisation.initial.ι = CategoryStruct.id X

@[simp]

theorem CategoryTheory.Factorisation.initial_π {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Factorisation.initial.π = f

def CategoryTheory.Factorisation.initialHom {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : Factorisation f) : Factorisation.initial.Hom d

The unique morphism out of Factorisation.initial f.

@[simp]

theorem CategoryTheory.Factorisation.initialHom_h {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : Factorisation f) : d.initialHom.h = d.ι

instance CategoryTheory.Factorisation.instUniqueHomInitial {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : Factorisation f) : Unique (Factorisation.initial ⟶ d)

def CategoryTheory.Factorisation.terminal {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Factorisation f

The terminal object in Factorisation f, with the codomain of f as its midpoint.

@[simp]

theorem CategoryTheory.Factorisation.terminal_mid {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Factorisation.terminal.mid = Y

@[simp]

theorem CategoryTheory.Factorisation.terminal_π {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Factorisation.terminal.π = CategoryStruct.id Y

@[simp]

theorem CategoryTheory.Factorisation.terminal_ι {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Factorisation.terminal.ι = f

def CategoryTheory.Factorisation.terminalHom {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : Factorisation f) : d.Hom Factorisation.terminal

The unique morphism into Factorisation.terminal f.

@[simp]

theorem CategoryTheory.Factorisation.terminalHom_h {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : Factorisation f) : d.terminalHom.h = d.π

instance CategoryTheory.Factorisation.instUniqueHomTerminal {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (d : Factorisation f) : Unique (d ⟶ Factorisation.terminal)

def CategoryTheory.Factorisation.IsInitial_initial {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Limits.IsInitial Factorisation.initial

The initial factorisation is an initial object

instance CategoryTheory.Factorisation.instHasInitial {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Limits.HasInitial (Factorisation f)

def CategoryTheory.Factorisation.IsTerminal_terminal {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Limits.IsTerminal Factorisation.terminal

The terminal factorisation is a terminal object

instance CategoryTheory.Factorisation.instHasTerminal {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Limits.HasTerminal (Factorisation f)

def CategoryTheory.Factorisation.forget {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} : Functor (Factorisation f) C

The forgetful functor from Factorisation f to the underlying category C.

@[simp]

theorem CategoryTheory.Factorisation.forget_map {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} {X✝ Y✝ : Factorisation f} (f✝ : X✝ ⟶ Y✝) : forget.map f✝ = f✝.h

@[simp]

theorem CategoryTheory.Factorisation.forget_obj {C : Type u} [Category.{v, u} C] {X Y : C} {f : X ⟶ Y} (self : Factorisation f) : forget.obj self = self.mid