Presentation of a colimit of objects equipped with a presentation

Main definition:

• CategoryTheory.Limits.ColimitPresentation.bind: Given a colimit presentation of X and colimit presentations of the components, this is the colimit presentation over the sigma type.

def CategoryTheory.Limits.ColimitPresentation.Total {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} (P : (j : J) → ColimitPresentation (I j) (D.obj j)) : Type (max u_2 u_1)

The type underlying the category used in the construction of the composition of colimit presentations. This is simply Σ j, I j but with a different category structure.

Equations

• CategoryTheory.Limits.ColimitPresentation.Total P = ((j : J) × I j)

@[reducible, inline]

abbrev CategoryTheory.Limits.ColimitPresentation.Total.mk {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} (P : (j : J) → ColimitPresentation (I j) (D.obj j)) (i : J) (k : I i) : Total P

Constructor for Total to guide type checking.

Equations

• CategoryTheory.Limits.ColimitPresentation.Total.mk P i k = ⟨i, k⟩

structure CategoryTheory.Limits.ColimitPresentation.Total.Hom {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} (k l : Total P) : Type (max u_3 v)

Morphisms in the Total category.

• base : k.fst ⟶ l.fst

  The underlying morphism in the first component.

• hom : (P k.fst).diag.obj k.snd ⟶ (P l.fst).diag.obj l.snd

  A morphism in C.

• w : CategoryStruct.comp ((P k.fst).ι.app k.snd) (D.map self.base) = CategoryStruct.comp self.hom ((P l.fst).ι.app l.snd)

theorem CategoryTheory.Limits.ColimitPresentation.Total.Hom.ext {C : Type u} {inst✝ : Category.{v, u} C} {J : Type u_1} {I : J → Type u_2} {inst✝¹ : Category.{u_3, u_1} J} {inst✝² : (j : J) → Category.{u_4, u_2} (I j)} {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} {k l : Total P} {x y : k.Hom l} (base : x.base = y.base) (hom : x.hom = y.hom) : x = y

theorem CategoryTheory.Limits.ColimitPresentation.Total.Hom.ext_iff {C : Type u} {inst✝ : Category.{v, u} C} {J : Type u_1} {I : J → Type u_2} {inst✝¹ : Category.{u_3, u_1} J} {inst✝² : (j : J) → Category.{u_4, u_2} (I j)} {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} {k l : Total P} {x y : k.Hom l} : x = y ↔ x.base = y.base ∧ x.hom = y.hom

theorem CategoryTheory.Limits.ColimitPresentation.Total.Hom.w_assoc {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} {k l : Total P} (self : k.Hom l) {Z : C} (h : D.obj l.fst ⟶ Z) : CategoryStruct.comp ((P k.fst).ι.app k.snd) (CategoryStruct.comp (D.map self.base) h) = CategoryStruct.comp self.hom (CategoryStruct.comp ((P l.fst).ι.app l.snd) h)

def CategoryTheory.Limits.ColimitPresentation.Total.Hom.comp {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} {k l m : Total P} (f : k.Hom l) (g : l.Hom m) : k.Hom m

Composition of morphisms in the Total category.

Equations

• f.comp g = { base := CategoryTheory.CategoryStruct.comp f.base g.base, hom := CategoryTheory.CategoryStruct.comp f.hom g.hom, w := ⋯ }

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.Total.Hom.comp_hom {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} {k l m : Total P} (f : k.Hom l) (g : l.Hom m) : (f.comp g).hom = CategoryStruct.comp f.hom g.hom

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.Total.Hom.comp_base {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} {k l m : Total P} (f : k.Hom l) (g : l.Hom m) : (f.comp g).base = CategoryStruct.comp f.base g.base

instance CategoryTheory.Limits.ColimitPresentation.instCategoryTotal {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} : Category.{max v u_3, max u_2 u_1} (Total P)

Equations

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

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.id_hom {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} (x✝ : Total P) : (CategoryStruct.id x✝).hom = CategoryStruct.id ((P x✝.fst).diag.obj x✝.snd)

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.comp_base {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} {X✝ Y✝ Z✝ : Total P} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) : (CategoryStruct.comp f g).base = CategoryStruct.comp f.base g.base

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.id_base {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} (x✝ : Total P) : (CategoryStruct.id x✝).base = CategoryStruct.id x✝.fst

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.comp_hom {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} {X✝ Y✝ Z✝ : Total P} (f : X✝.Hom Y✝) (g : Y✝.Hom Z✝) : (CategoryStruct.comp f g).hom = CategoryStruct.comp f.hom g.hom

instance CategoryTheory.Limits.ColimitPresentation.instLocallySmallTotal {C : Type u} [Category.{v, u} C] {J : Type u_1} {I : J → Type u_2} [Category.{u_3, u_1} J] [(j : J) → Category.{u_4, u_2} (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} [LocallySmall.{w, v, u} C] [LocallySmall.{w, u_3, u_1} J] : LocallySmall.{w, max v u_3, max u_2 u_1} (Total P)

theorem CategoryTheory.Limits.ColimitPresentation.Total.exists_hom_of_hom {C : Type u} [Category.{v, u} C] {J : Type w} {I : J → Type w} [SmallCategory J] [(j : J) → SmallCategory (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} {j j' : J} (i : I j) (u : j ⟶ j') [IsFiltered (I j')] [IsFinitelyPresentable ((P j).diag.obj i)] : ∃ (i' : I j') (f : mk P j i ⟶ mk P j' i'), f.base = u

instance CategoryTheory.Limits.ColimitPresentation.instNonemptyTotalOfIsFiltered {C : Type u} [Category.{v, u} C] {J : Type w} {I : J → Type w} [SmallCategory J] [(j : J) → SmallCategory (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} [IsFiltered J] [∀ (j : J), IsFiltered (I j)] : Nonempty (Total P)

instance CategoryTheory.Limits.ColimitPresentation.instIsFilteredTotalOfIsFinitelyPresentableObjDiag {C : Type u} [Category.{v, u} C] {J : Type w} {I : J → Type w} [SmallCategory J] [(j : J) → SmallCategory (I j)] {D : Functor J C} {P : (j : J) → ColimitPresentation (I j) (D.obj j)} [IsFiltered J] [∀ (j : J), IsFiltered (I j)] [∀ (j : J) (i : I j), IsFinitelyPresentable ((P j).diag.obj i)] : IsFiltered (Total P)

def CategoryTheory.Limits.ColimitPresentation.bind {C : Type u} [Category.{v, u} C] {J : Type w} {I : J → Type w} [SmallCategory J] [(j : J) → SmallCategory (I j)] {X : C} (P : ColimitPresentation J X) (Q : (j : J) → ColimitPresentation (I j) (P.diag.obj j)) [∀ (j : J), IsFiltered (I j)] [∀ (j : J) (i : I j), IsFinitelyPresentable ((Q j).diag.obj i)] : ColimitPresentation (Total Q) X

If P is a colimit presentation over J of X and for every j we are given a colimit presentation Qⱼ over I j of the P.diag.obj j, this is the refined colimit presentation of X over Total Q.

Equations

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

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.bind_ι_app {C : Type u} [Category.{v, u} C] {J : Type w} {I : J → Type w} [SmallCategory J] [(j : J) → SmallCategory (I j)] {X : C} (P : ColimitPresentation J X) (Q : (j : J) → ColimitPresentation (I j) (P.diag.obj j)) [∀ (j : J), IsFiltered (I j)] [∀ (j : J) (i : I j), IsFinitelyPresentable ((Q j).diag.obj i)] (k : Total Q) : (P.bind Q).ι.app k = CategoryStruct.comp ((Q k.fst).ι.app k.snd) (P.ι.app k.fst)

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.bind_diag_obj {C : Type u} [Category.{v, u} C] {J : Type w} {I : J → Type w} [SmallCategory J] [(j : J) → SmallCategory (I j)] {X : C} (P : ColimitPresentation J X) (Q : (j : J) → ColimitPresentation (I j) (P.diag.obj j)) [∀ (j : J), IsFiltered (I j)] [∀ (j : J) (i : I j), IsFinitelyPresentable ((Q j).diag.obj i)] (k : Total Q) : (P.bind Q).diag.obj k = (Q k.fst).diag.obj k.snd

@[simp]

theorem CategoryTheory.Limits.ColimitPresentation.bind_diag_map {C : Type u} [Category.{v, u} C] {J : Type w} {I : J → Type w} [SmallCategory J] [(j : J) → SmallCategory (I j)] {X : C} (P : ColimitPresentation J X) (Q : (j : J) → ColimitPresentation (I j) (P.diag.obj j)) [∀ (j : J), IsFiltered (I j)] [∀ (j : J) (i : I j), IsFinitelyPresentable ((Q j).diag.obj i)] {k l : Total Q} (f : k ⟶ l) : (P.bind Q).diag.map f = f.hom