(Co)limit presentations

Let J and C be categories and X : C. We define type ColimitPresentation J X that contains the data of objects Dⱼ and natural maps sⱼ : Dⱼ ⟶ X that make X the colimit of the Dⱼ.

(See Mathlib/CategoryTheory/Presentable/ColimitPresentation.lean for the construction of a presentation of a colimit of objects that are equipped with presentations.)

Main definitions:

• CategoryTheory.Limits.ColimitPresentation: A colimit presentation of X over J is a diagram {Dᵢ} in C and natural maps sᵢ : Dᵢ ⟶ X making X into the colimit of the Dᵢ.
• CategoryTheory.Limits.LimitPresentation: A limit presentation of X over J is a diagram {Dᵢ} in C and natural maps sᵢ : X ⟶ Dᵢ making X into the limit of the Dᵢ.

TODOs:

• Refactor TransfiniteCompositionOfShape so that it extends ColimitPresentation.

structure CategoryTheory.Limits.ColimitPresentation {C : Type u} [Category.{v, u} C] (J : Type w) [Category.{t, w} J] (X : C) : Type (max (max (max t u) v) w)

A colimit presentation of X over J is a diagram {Dᵢ} in C and natural maps sᵢ : Dᵢ ⟶ X making X into the colimit of the Dᵢ.

• diag : Functor J C

  The diagram {Dᵢ}.

• ι : self.diag ⟶ (Functor.const J).obj X

  The natural maps sᵢ : Dᵢ ⟶ X.

• isColimit : IsColimit { pt := X, ι := self.ι }

  X is the colimit of the Dᵢ via sᵢ.

theorem CategoryTheory.Limits.ColimitPresentation.w {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (pres : ColimitPresentation J X) {i j : J} (f : i ⟶ j) : CategoryStruct.comp (pres.diag.map f) (pres.ι.app j) = pres.ι.app i

theorem CategoryTheory.Limits.ColimitPresentation.w_assoc {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (pres : ColimitPresentation J X) {i j : J} (f : i ⟶ j) {Z : C} (h : ((Functor.const J).obj X).obj j ⟶ Z) : CategoryStruct.comp (pres.diag.map f) (CategoryStruct.comp (pres.ι.app j) h) = CategoryStruct.comp (pres.ι.app i) h

@[reducible, inline]

abbrev CategoryTheory.Limits.ColimitPresentation.cocone {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (pres : ColimitPresentation J X) : Cocone pres.diag

The cocone associated to a colimit presentation.

theorem CategoryTheory.Limits.ColimitPresentation.hasColimit {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (pres : ColimitPresentation J X) : HasColimit pres.diag

noncomputable def CategoryTheory.Limits.ColimitPresentation.self {C : Type u} [Category.{v, u} C] (X : C) : ColimitPresentation PUnit.{s + 1} X

The canonical colimit presentation of any object over a point.

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.self_diag {C : Type u} [Category.{v, u} C] (X : C) : (self X).diag = (Functor.const PUnit.{s + 1}).obj X

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.self_ι {C : Type u} [Category.{v, u} C] (X : C) : (self X).ι = CategoryStruct.id ((Functor.const PUnit.{s + 1}).obj X)

noncomputable def CategoryTheory.Limits.ColimitPresentation.colimit {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J C) [HasColimit F] : ColimitPresentation J (Limits.colimit F)

If F : J ⥤ C is a functor that has a colimit, then this is the obvious colimit presentation of colimit F.

noncomputable def CategoryTheory.Limits.ColimitPresentation.map {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {D : Type u_1} [Category.{v_1, u_1} D] (F : Functor C D) [PreservesColimitsOfShape J F] : ColimitPresentation J (F.obj X)

If F preserves colimits of shape J, it maps colimit presentations of X to colimit presentations of F(X).

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.map_ι {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {D : Type u_1} [Category.{v_1, u_1} D] (F : Functor C D) [PreservesColimitsOfShape J F] : (P.map F).ι = CategoryStruct.comp (Functor.whiskerRight P.ι F) (Functor.constComp J X F).hom

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.map_diag {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {D : Type u_1} [Category.{v_1, u_1} D] (F : Functor C D) [PreservesColimitsOfShape J F] : (P.map F).diag = P.diag.comp F

def CategoryTheory.Limits.ColimitPresentation.changeDiag {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {F : Functor J C} (e : F ≅ P.diag) : ColimitPresentation J X

If P is a colimit presentation of X, it is possible to define another colimit presentation of X where P.diag is replaced by an isomorphic functor.

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.changeDiag_ι {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {F : Functor J C} (e : F ≅ P.diag) : (P.changeDiag e).ι = CategoryStruct.comp e.hom P.ι

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.changeDiag_diag {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {F : Functor J C} (e : F ≅ P.diag) : (P.changeDiag e).diag = F

def CategoryTheory.Limits.ColimitPresentation.ofIso {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {Y : C} (e : X ≅ Y) : ColimitPresentation J Y

Map a colimit presentation under an isomorphism.

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.ofIso_ι {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {Y : C} (e : X ≅ Y) : (P.ofIso e).ι = CategoryStruct.comp P.ι ((Functor.const J).map e.hom)

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.ofIso_diag {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {Y : C} (e : X ≅ Y) : (P.ofIso e).diag = P.diag

noncomputable def CategoryTheory.Limits.ColimitPresentation.reindex {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {J' : Type u_1} [Category.{v_1, u_1} J'] (F : Functor J' J) [F.Final] : ColimitPresentation J' X

Change the index category of a colimit presentation.

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.reindex_diag {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {J' : Type u_1} [Category.{v_1, u_1} J'] (F : Functor J' J) [F.Final] : (P.reindex F).diag = F.comp P.diag

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.reindex_ι {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : ColimitPresentation J X) {J' : Type u_1} [Category.{v_1, u_1} J'] (F : Functor J' J) [F.Final] : (P.reindex F).ι = F.whiskerLeft P.ι

structure CategoryTheory.Limits.LimitPresentation {C : Type u} [Category.{v, u} C] (J : Type w) [Category.{t, w} J] (X : C) : Type (max (max (max t u) v) w)

A limit presentation of X over J is a diagram {Dᵢ} in C and natural maps sᵢ : X ⟶ Dᵢ making X into the limit of the Dᵢ.

• diag : Functor J C

  The diagram {Dᵢ}.

• π : (Functor.const J).obj X ⟶ self.diag

  The natural maps sᵢ : X ⟶ Dᵢ.

• isLimit : IsLimit { pt := X, π := self.π }

  X is the limit of the Dᵢ via sᵢ.

theorem CategoryTheory.Limits.LimitPresentation.w {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (pres : LimitPresentation J X) {i j : J} (f : i ⟶ j) : CategoryStruct.comp (pres.π.app i) (pres.diag.map f) = pres.π.app j

theorem CategoryTheory.Limits.LimitPresentation.w_assoc {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (pres : LimitPresentation J X) {i j : J} (f : i ⟶ j) {Z : C} (h : pres.diag.obj j ⟶ Z) : CategoryStruct.comp (pres.π.app i) (CategoryStruct.comp (pres.diag.map f) h) = CategoryStruct.comp (pres.π.app j) h

@[reducible, inline]

abbrev CategoryTheory.Limits.LimitPresentation.cone {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (pres : LimitPresentation J X) : Cone pres.diag

The cone associated to a limit presentation.

theorem CategoryTheory.Limits.LimitPresentation.hasLimit {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (pres : LimitPresentation J X) : HasLimit pres.diag

noncomputable def CategoryTheory.Limits.LimitPresentation.self {C : Type u} [Category.{v, u} C] (X : C) : LimitPresentation PUnit.{s + 1} X

The canonical limit presentation of any object over a point.

@[simp]

theorem CategoryTheory.Limits.LimitPresentation.self_π {C : Type u} [Category.{v, u} C] (X : C) : (self X).π = CategoryStruct.id ((Functor.const PUnit.{s + 1}).obj X)

@[simp]

theorem CategoryTheory.Limits.LimitPresentation.self_diag {C : Type u} [Category.{v, u} C] (X : C) : (self X).diag = (Functor.const PUnit.{s + 1}).obj X

noncomputable def CategoryTheory.Limits.LimitPresentation.limit {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] (F : Functor J C) [HasLimit F] : LimitPresentation J (Limits.limit F)

If F : J ⥤ C is a functor that has a limit, then this is the obvious limit presentation of limit F.

noncomputable def CategoryTheory.Limits.LimitPresentation.map {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {D : Type u_1} [Category.{v_1, u_1} D] (F : Functor C D) [PreservesLimitsOfShape J F] : LimitPresentation J (F.obj X)

If F preserves limits of shape J, it maps limit presentations of X to limit presentations of F(X).

@[simp]

theorem CategoryTheory.Limits.LimitPresentation.map_π {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {D : Type u_1} [Category.{v_1, u_1} D] (F : Functor C D) [PreservesLimitsOfShape J F] : (P.map F).π = CategoryStruct.comp (Functor.constComp J X F).inv (Functor.whiskerRight P.π F)

@[simp]

theorem CategoryTheory.Limits.LimitPresentation.map_diag {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {D : Type u_1} [Category.{v_1, u_1} D] (F : Functor C D) [PreservesLimitsOfShape J F] : (P.map F).diag = P.diag.comp F

def CategoryTheory.Limits.LimitPresentation.changeDiag {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {F : Functor J C} (e : F ≅ P.diag) : LimitPresentation J X

If P is a limit presentation of X, it is possible to define another limit presentation of X where P.diag is replaced by an isomorphic functor.

@[simp]

theorem CategoryTheory.Limits.LimitPresentation.changeDiag_π {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {F : Functor J C} (e : F ≅ P.diag) : (P.changeDiag e).π = CategoryStruct.comp P.π e.inv

@[simp]

theorem CategoryTheory.Limits.LimitPresentation.changeDiag_diag {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {F : Functor J C} (e : F ≅ P.diag) : (P.changeDiag e).diag = F

def CategoryTheory.Limits.LimitPresentation.ofIso {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {Y : C} (e : X ≅ Y) : LimitPresentation J Y

Map a limit presentation under an isomorphism.

@[simp]

theorem CategoryTheory.Limits.LimitPresentation.ofIso_diag {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {Y : C} (e : X ≅ Y) : (P.ofIso e).diag = P.diag

@[simp]

theorem CategoryTheory.Limits.LimitPresentation.ofIso_π {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {Y : C} (e : X ≅ Y) : (P.ofIso e).π = CategoryStruct.comp ((Functor.const J).map e.inv) P.π

noncomputable def CategoryTheory.Limits.LimitPresentation.reindex {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {J' : Type u_1} [Category.{v_1, u_1} J'] (F : Functor J' J) [F.Initial] : LimitPresentation J' X

Change the index category of a limit presentation.

@[simp]

theorem CategoryTheory.Limits.LimitPresentation.reindex_π {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {J' : Type u_1} [Category.{v_1, u_1} J'] (F : Functor J' J) [F.Initial] : (P.reindex F).π = F.whiskerLeft P.π

@[simp]

theorem CategoryTheory.Limits.LimitPresentation.reindex_diag {C : Type u} [Category.{v, u} C] {J : Type w} [Category.{t, w} J] {X : C} (P : LimitPresentation J X) {J' : Type u_1} [Category.{v_1, u_1} J'] (F : Functor J' J) [F.Initial] : (P.reindex F).diag = F.comp P.diag