Limits and colimits #
We set up the general theory of limits and colimits in a category. In this introduction we only describe the setup for limits; it is repeated, with slightly different names, for colimits.
The main structures defined in this file is
IsLimit c, forc : Cone F,F : J ⥤ C, expressing thatcis a limit cone,
See also CategoryTheory.Limits.HasLimits which further builds:
LimitCone F, which consists of a choice of cone forFand the fact it is a limit cone, andHasLimit F, asserting the mere existence of some limit cone forF.
Implementation #
At present we simply say everything twice, in order to handle both limits and colimits.
It would be highly desirable to have some automation support,
e.g. a @[dualize] attribute that behaves similarly to @[to_additive].
References #
structure
CategoryTheory.Limits.IsLimit
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
(t : CategoryTheory.Limits.Cone F)
:
Type (max (max u₁ u₃) v₃)
- lift : (s : CategoryTheory.Limits.Cone F) → s.pt ⟶ t.pt
There is a morphism from any cone point to
t.pt - fac : ∀ (s_1 : CategoryTheory.Limits.Cone F) (j : J), CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.lift s s_1) (t.π.app j) = s_1.π.app j
The map makes the triangle with the two natural transformations commute
- uniq : ∀ (s_1 : CategoryTheory.Limits.Cone F) (m : s_1.pt ⟶ t.pt), (∀ (j : J), CategoryTheory.CategoryStruct.comp m (t.π.app j) = s_1.π.app j) → m = CategoryTheory.Limits.IsLimit.lift s s_1
It is the unique such map to do this
A cone t on F is a limit cone if each cone on F admits a unique
cone morphism to t.
See https://stacks.math.columbia.edu/tag/002E.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.fac_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(self : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.Cone F)
(j : J)
{Z : C}
(h : F.obj j ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.lift self s)
(CategoryTheory.CategoryStruct.comp (t.π.app j) h) = CategoryTheory.CategoryStruct.comp (s.π.app j) h
instance
CategoryTheory.Limits.IsLimit.subsingleton
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
:
def
CategoryTheory.Limits.IsLimit.map
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
(s : CategoryTheory.Limits.Cone F)
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit t)
(α : F ⟶ G)
:
s.pt ⟶ t.pt
Given a natural transformation α : F ⟶ G, we give a morphism from the cone point
of any cone over F to the cone point of a limit cone over G.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.map_π_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
(c : CategoryTheory.Limits.Cone F)
{d : CategoryTheory.Limits.Cone G}
(hd : CategoryTheory.Limits.IsLimit d)
(α : F ⟶ G)
(j : J)
{Z : C}
(h : G.obj j ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.map c hd α)
(CategoryTheory.CategoryStruct.comp (d.π.app j) h) = CategoryTheory.CategoryStruct.comp (c.π.app j) (CategoryTheory.CategoryStruct.comp (α.app j) h)
@[simp]
theorem
CategoryTheory.Limits.IsLimit.map_π
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
(c : CategoryTheory.Limits.Cone F)
{d : CategoryTheory.Limits.Cone G}
(hd : CategoryTheory.Limits.IsLimit d)
(α : F ⟶ G)
(j : J)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.map c hd α) (d.π.app j) = CategoryTheory.CategoryStruct.comp (c.π.app j) (α.app j)
theorem
CategoryTheory.Limits.IsLimit.lift_self
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{c : CategoryTheory.Limits.Cone F}
(t : CategoryTheory.Limits.IsLimit c)
:
@[simp]
theorem
CategoryTheory.Limits.IsLimit.liftConeMorphism_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(h : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.Cone F)
:
def
CategoryTheory.Limits.IsLimit.liftConeMorphism
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(h : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.Cone F)
:
s ⟶ t
The universal morphism from any other cone to a limit cone.
Instances For
theorem
CategoryTheory.Limits.IsLimit.uniq_cone_morphism
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(h : CategoryTheory.Limits.IsLimit t)
{f : s ⟶ t}
{f' : s ⟶ t}
:
f = f'
theorem
CategoryTheory.Limits.IsLimit.existsUnique
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(h : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.Cone F)
:
∃! l, ∀ (j : J), CategoryTheory.CategoryStruct.comp l (t.π.app j) = s.π.app j
Restating the definition of a limit cone in terms of the ∃! operator.
def
CategoryTheory.Limits.IsLimit.ofExistsUnique
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(ht : ∀ (s : CategoryTheory.Limits.Cone F), ∃! l, ∀ (j : J), CategoryTheory.CategoryStruct.comp l (t.π.app j) = s.π.app j)
:
Noncomputably make a colimit cocone from the existence of unique factorizations.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.mkConeMorphism_lift
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(lift : (s : CategoryTheory.Limits.Cone F) → s ⟶ t)
(uniq : ∀ (s : CategoryTheory.Limits.Cone F) (m : s ⟶ t), m = lift s)
(s : CategoryTheory.Limits.Cone F)
:
CategoryTheory.Limits.IsLimit.lift (CategoryTheory.Limits.IsLimit.mkConeMorphism lift uniq) s = (lift s).hom
def
CategoryTheory.Limits.IsLimit.mkConeMorphism
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(lift : (s : CategoryTheory.Limits.Cone F) → s ⟶ t)
(uniq : ∀ (s : CategoryTheory.Limits.Cone F) (m : s ⟶ t), m = lift s)
:
Alternative constructor for isLimit,
providing a morphism of cones rather than a morphism between the cone points
and separately the factorisation condition.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.uniqueUpToIso_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
:
@[simp]
theorem
CategoryTheory.Limits.IsLimit.uniqueUpToIso_inv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
:
def
CategoryTheory.Limits.IsLimit.uniqueUpToIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
:
s ≅ t
Limit cones on F are unique up to isomorphism.
Instances For
theorem
CategoryTheory.Limits.IsLimit.hom_isIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(f : s ⟶ t)
:
Any cone morphism between limit cones is an isomorphism.
def
CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
:
s.pt ≅ t.pt
Limits of F are unique up to isomorphism.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_hom_comp_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(j : J)
{Z : C}
(h : F.obj j ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso P Q).hom
(CategoryTheory.CategoryStruct.comp (t.π.app j) h) = CategoryTheory.CategoryStruct.comp (s.π.app j) h
@[simp]
theorem
CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_hom_comp
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(j : J)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso P Q).hom (t.π.app j) = s.π.app j
@[simp]
theorem
CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_inv_comp_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(j : J)
{Z : C}
(h : F.obj j ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso P Q).inv
(CategoryTheory.CategoryStruct.comp (s.π.app j) h) = CategoryTheory.CategoryStruct.comp (t.π.app j) h
@[simp]
theorem
CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_inv_comp
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(j : J)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso P Q).inv (s.π.app j) = t.π.app j
@[simp]
theorem
CategoryTheory.Limits.IsLimit.lift_comp_conePointUniqueUpToIso_hom_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
{Z : C}
(h : t.pt ⟶ Z)
:
@[simp]
theorem
CategoryTheory.Limits.IsLimit.lift_comp_conePointUniqueUpToIso_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
:
@[simp]
theorem
CategoryTheory.Limits.IsLimit.lift_comp_conePointUniqueUpToIso_inv_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
{Z : C}
(h : s.pt ⟶ Z)
:
@[simp]
theorem
CategoryTheory.Limits.IsLimit.lift_comp_conePointUniqueUpToIso_inv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
:
def
CategoryTheory.Limits.IsLimit.ofIsoLimit
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit r)
(i : r ≅ t)
:
Transport evidence that a cone is a limit cone across an isomorphism of cones.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.ofIsoLimit_lift
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit r)
(i : r ≅ t)
(s : CategoryTheory.Limits.Cone F)
:
def
CategoryTheory.Limits.IsLimit.equivIsoLimit
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(i : r ≅ t)
:
Isomorphism of cones preserves whether or not they are limiting cones.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.equivIsoLimit_apply
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(i : r ≅ t)
(P : CategoryTheory.Limits.IsLimit r)
:
@[simp]
theorem
CategoryTheory.Limits.IsLimit.equivIsoLimit_symm_apply
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(i : r ≅ t)
(P : CategoryTheory.Limits.IsLimit t)
:
↑(CategoryTheory.Limits.IsLimit.equivIsoLimit i).symm P = CategoryTheory.Limits.IsLimit.ofIsoLimit P i.symm
def
CategoryTheory.Limits.IsLimit.ofPointIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit r)
[i : CategoryTheory.IsIso (CategoryTheory.Limits.IsLimit.lift P t)]
:
If the canonical morphism from a cone point to a limiting cone point is an iso, then the first cone was limiting also.
Instances For
theorem
CategoryTheory.Limits.IsLimit.hom_lift
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(h : CategoryTheory.Limits.IsLimit t)
{W : C}
(m : W ⟶ t.pt)
:
m = CategoryTheory.Limits.IsLimit.lift h
{ pt := W, π := CategoryTheory.NatTrans.mk fun b => CategoryTheory.CategoryStruct.comp m (t.π.app b) }
theorem
CategoryTheory.Limits.IsLimit.hom_ext
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(h : CategoryTheory.Limits.IsLimit t)
{W : C}
{f : W ⟶ t.pt}
{f' : W ⟶ t.pt}
(w : ∀ (j : J), CategoryTheory.CategoryStruct.comp f (t.π.app j) = CategoryTheory.CategoryStruct.comp f' (t.π.app j))
:
f = f'
Two morphisms into a limit are equal if their compositions with each cone morphism are equal.
def
CategoryTheory.Limits.IsLimit.ofRightAdjoint
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{G : CategoryTheory.Functor K D}
(h : CategoryTheory.Functor (CategoryTheory.Limits.Cone G) (CategoryTheory.Limits.Cone F))
[CategoryTheory.IsRightAdjoint h]
{c : CategoryTheory.Limits.Cone G}
(t : CategoryTheory.Limits.IsLimit c)
:
CategoryTheory.Limits.IsLimit (h.obj c)
Given a right adjoint functor between categories of cones, the image of a limit cone is a limit cone.
Instances For
def
CategoryTheory.Limits.IsLimit.ofConeEquiv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{G : CategoryTheory.Functor K D}
(h : CategoryTheory.Limits.Cone G ≌ CategoryTheory.Limits.Cone F)
{c : CategoryTheory.Limits.Cone G}
:
CategoryTheory.Limits.IsLimit (h.functor.obj c) ≃ CategoryTheory.Limits.IsLimit c
Given two functors which have equivalent categories of cones, we can transport a limiting cone across the equivalence.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.ofConeEquiv_apply_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{G : CategoryTheory.Functor K D}
(h : CategoryTheory.Limits.Cone G ≌ CategoryTheory.Limits.Cone F)
{c : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit (h.functor.obj c))
(s : CategoryTheory.Limits.Cone G)
:
CategoryTheory.Limits.IsLimit.lift (↑(CategoryTheory.Limits.IsLimit.ofConeEquiv h) P) s = CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (h.unitIso.hom.app s).hom
((CategoryTheory.Functor.inv h.functor).map
(CategoryTheory.Limits.IsLimit.liftConeMorphism P (h.functor.obj s))).hom)
(h.unitIso.inv.app c).hom
@[simp]
theorem
CategoryTheory.Limits.IsLimit.ofConeEquiv_symm_apply_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{G : CategoryTheory.Functor K D}
(h : CategoryTheory.Limits.Cone G ≌ CategoryTheory.Limits.Cone F)
{c : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit c)
(s : CategoryTheory.Limits.Cone F)
:
CategoryTheory.Limits.IsLimit.lift (↑(CategoryTheory.Limits.IsLimit.ofConeEquiv h).symm P) s = CategoryTheory.CategoryStruct.comp (h.counitIso.inv.app s).hom
(h.functor.map (CategoryTheory.Limits.IsLimit.liftConeMorphism P (h.inverse.obj s))).hom
def
CategoryTheory.Limits.IsLimit.postcomposeHomEquiv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
(α : F ≅ G)
(c : CategoryTheory.Limits.Cone F)
:
A cone postcomposed with a natural isomorphism is a limit cone if and only if the original cone is.
Instances For
def
CategoryTheory.Limits.IsLimit.postcomposeInvEquiv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
(α : F ≅ G)
(c : CategoryTheory.Limits.Cone G)
:
A cone postcomposed with the inverse of a natural isomorphism is a limit cone if and only if the original cone is.
Instances For
def
CategoryTheory.Limits.IsLimit.equivOfNatIsoOfIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
(α : F ≅ G)
(c : CategoryTheory.Limits.Cone F)
(d : CategoryTheory.Limits.Cone G)
(w : (CategoryTheory.Limits.Cones.postcompose α.hom).obj c ≅ d)
:
Constructing an equivalence IsLimit c ≃ IsLimit d from a natural isomorphism
between the underlying functors, and then an isomorphism between c transported along this and d.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(w : F ≅ G)
:
(CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso P Q w).hom = CategoryTheory.Limits.IsLimit.map s Q w.hom
@[simp]
theorem
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(w : F ≅ G)
:
(CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso P Q w).inv = CategoryTheory.Limits.IsLimit.map t P w.inv
def
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(w : F ≅ G)
:
s.pt ≅ t.pt
The cone points of two limit cones for naturally isomorphic functors are themselves isomorphic.
Instances For
theorem
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom_comp_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(w : F ≅ G)
(j : J)
{Z : C}
(h : G.obj j ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso P Q w).hom
(CategoryTheory.CategoryStruct.comp (t.π.app j) h) = CategoryTheory.CategoryStruct.comp (s.π.app j) (CategoryTheory.CategoryStruct.comp (w.hom.app j) h)
theorem
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom_comp
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(w : F ≅ G)
(j : J)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso P Q w).hom (t.π.app j) = CategoryTheory.CategoryStruct.comp (s.π.app j) (w.hom.app j)
theorem
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv_comp_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(w : F ≅ G)
(j : J)
{Z : C}
(h : F.obj j ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso P Q w).inv
(CategoryTheory.CategoryStruct.comp (s.π.app j) h) = CategoryTheory.CategoryStruct.comp (t.π.app j) (CategoryTheory.CategoryStruct.comp (w.inv.app j) h)
theorem
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv_comp
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(w : F ≅ G)
(j : J)
:
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso P Q w).inv (s.π.app j) = CategoryTheory.CategoryStruct.comp (t.π.app j) (w.inv.app j)
theorem
CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_hom_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(w : F ≅ G)
{Z : C}
(h : t.pt ⟶ Z)
:
theorem
CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone F}
{s : CategoryTheory.Limits.Cone F}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(w : F ≅ G)
:
theorem
CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_inv_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone G}
{s : CategoryTheory.Limits.Cone G}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit t)
(Q : CategoryTheory.Limits.IsLimit s)
(w : F ≅ G)
{Z : C}
(h : t.pt ⟶ Z)
:
theorem
CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_inv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cone G}
{s : CategoryTheory.Limits.Cone G}
{t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit t)
(Q : CategoryTheory.Limits.IsLimit s)
(w : F ≅ G)
:
def
CategoryTheory.Limits.IsLimit.whiskerEquivalence
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit s)
(e : K ≌ J)
:
If s : Cone F is a limit cone, so is s whiskered by an equivalence e.
Instances For
def
CategoryTheory.Limits.IsLimit.ofWhiskerEquivalence
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
(e : K ≌ J)
(P : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Cone.whisker e.functor s))
:
If s : Cone F whiskered by an equivalence e is a limit cone, so is s.
Instances For
def
CategoryTheory.Limits.IsLimit.whiskerEquivalenceEquiv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
(e : K ≌ J)
:
Given an equivalence of diagrams e, s is a limit cone iff s.whisker e.functor is.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence_inv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{G : CategoryTheory.Functor K C}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(e : J ≌ K)
(w : CategoryTheory.Functor.comp e.functor G ≅ F)
:
(CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence P Q e w).inv = CategoryTheory.Limits.IsLimit.lift P ((CategoryTheory.Limits.Cones.equivalenceOfReindexing e w).functor.obj t)
@[simp]
theorem
CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{G : CategoryTheory.Functor K C}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(e : J ≌ K)
(w : CategoryTheory.Functor.comp e.functor G ≅ F)
:
(CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence P Q e w).hom = CategoryTheory.Limits.IsLimit.lift Q
((CategoryTheory.Limits.Cones.equivalenceOfReindexing e.symm
((CategoryTheory.isoWhiskerLeft e.inverse w).symm ≪≫ CategoryTheory.Equivalence.invFunIdAssoc e G)).functor.obj
s)
def
CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cone F}
{G : CategoryTheory.Functor K C}
{t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s)
(Q : CategoryTheory.Limits.IsLimit t)
(e : J ≌ K)
(w : CategoryTheory.Functor.comp e.functor G ≅ F)
:
s.pt ≅ t.pt
We can prove two cone points (s : Cone F).pt and (t : Cone G).pt are isomorphic if
- both cones are limit cones
- their indexing categories are equivalent via some
e : J ≌ K, - the triangle of functors commutes up to a natural isomorphism:
e.functor ⋙ G ≅ F.
This is the most general form of uniqueness of cone points, allowing relabelling of both the indexing category (up to equivalence) and the functor (up to natural isomorphism).
Instances For
def
CategoryTheory.Limits.IsLimit.homIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(h : CategoryTheory.Limits.IsLimit t)
(W : C)
:
ULift.{u₁, v₃} (W ⟶ t.pt) ≅ (CategoryTheory.Functor.const J).obj W ⟶ F
The universal property of a limit cone: a map W ⟶ X is the same as
a cone on F with cone point W.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.homIso_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(h : CategoryTheory.Limits.IsLimit t)
{W : C}
(f : ULift.{u₁, v₃} (W ⟶ t.pt))
:
(h.homIso W).hom f = (CategoryTheory.Limits.Cone.extend t f.down).π
def
CategoryTheory.Limits.IsLimit.natIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(h : CategoryTheory.Limits.IsLimit t)
:
CategoryTheory.Functor.comp (CategoryTheory.yoneda.obj t.pt) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cones F
The limit of F represents the functor taking W to
the set of cones on F with cone point W.
Instances For
def
CategoryTheory.Limits.IsLimit.homIso'
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
(h : CategoryTheory.Limits.IsLimit t)
(W : C)
:
ULift.{u₁, v₃} (W ⟶ t.pt) ≅ { p // ∀ {j j' : J} (f : j ⟶ j'), CategoryTheory.CategoryStruct.comp (p j) (F.map f) = p j' }
Another, more explicit, formulation of the universal property of a limit cone.
See also homIso.
Instances For
def
CategoryTheory.Limits.IsLimit.ofFaithful
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
(G : CategoryTheory.Functor C D)
[CategoryTheory.Faithful G]
(ht : CategoryTheory.Limits.IsLimit (G.mapCone t))
(lift : (s : CategoryTheory.Limits.Cone F) → s.pt ⟶ t.pt)
(h : ∀ (s : CategoryTheory.Limits.Cone F), G.map (lift s) = CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s))
:
If G : C → D is a faithful functor which sends t to a limit cone, then it suffices to check that the induced maps for the image of t can be lifted to maps of C.
Instances For
def
CategoryTheory.Limits.IsLimit.mapConeEquiv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{K : CategoryTheory.Functor J C}
{F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor C D}
(h : F ≅ G)
{c : CategoryTheory.Limits.Cone K}
(t : CategoryTheory.Limits.IsLimit (F.mapCone c))
:
CategoryTheory.Limits.IsLimit (G.mapCone c)
If F and G are naturally isomorphic, then F.mapCone c being a limit implies
G.mapCone c is also a limit.
Instances For
def
CategoryTheory.Limits.IsLimit.isoUniqueConeMorphism
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cone F}
:
CategoryTheory.Limits.IsLimit t ≅ (s : CategoryTheory.Limits.Cone F) → Unique (s ⟶ t)
A cone is a limit cone exactly if there is a unique cone morphism from any other cone.
Instances For
def
CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.yoneda.obj X) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cones F)
{Y : C}
(f : Y ⟶ X)
:
If F.cones is represented by X, each morphism f : Y ⟶ X gives a cone with cone point
Y.
Instances For
def
CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.yoneda.obj X) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cones F)
(s : CategoryTheory.Limits.Cone F)
:
s.pt ⟶ X
If F.cones is represented by X, each cone s gives a morphism s.pt ⟶ X.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom_homOfCone
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.yoneda.obj X) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cones F)
(s : CategoryTheory.Limits.Cone F)
:
@[simp]
theorem
CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone_coneOfHom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.yoneda.obj X) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cones F)
{Y : C}
(f : Y ⟶ X)
:
def
CategoryTheory.Limits.IsLimit.OfNatIso.limitCone
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.yoneda.obj X) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cones F)
:
If F.cones is represented by X, the cone corresponding to the identity morphism on X
will be a limit cone.
Instances For
theorem
CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom_fac
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.yoneda.obj X) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cones F)
{Y : C}
(f : Y ⟶ X)
:
If F.cones is represented by X, the cone corresponding to a morphism f : Y ⟶ X is
the limit cone extended by f.
theorem
CategoryTheory.Limits.IsLimit.OfNatIso.cone_fac
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.yoneda.obj X) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cones F)
(s : CategoryTheory.Limits.Cone F)
:
If F.cones is represented by X, any cone is the extension of the limit cone by the
corresponding morphism.
def
CategoryTheory.Limits.IsLimit.ofNatIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.yoneda.obj X) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cones F)
:
If F.cones is representable, then the cone corresponding to the identity morphism on
the representing object is a limit cone.
Instances For
structure
CategoryTheory.Limits.IsColimit
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
(t : CategoryTheory.Limits.Cocone F)
:
Type (max (max u₁ u₃) v₃)
- desc : (s : CategoryTheory.Limits.Cocone F) → t.pt ⟶ s.pt
t.ptmaps to all other cocone covertices - fac : ∀ (s_1 : CategoryTheory.Limits.Cocone F) (j : J), CategoryTheory.CategoryStruct.comp (t.ι.app j) (CategoryTheory.Limits.IsColimit.desc s s_1) = s_1.ι.app j
The map
descmakes the diagram with the natural transformations commute - uniq : ∀ (s_1 : CategoryTheory.Limits.Cocone F) (m : t.pt ⟶ s_1.pt), (∀ (j : J), CategoryTheory.CategoryStruct.comp (t.ι.app j) m = s_1.ι.app j) → m = CategoryTheory.Limits.IsColimit.desc s s_1
descis the unique such map
A cocone t on F is a colimit cocone if each cocone on F admits a unique
cocone morphism from t.
See https://stacks.math.columbia.edu/tag/002F.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.fac_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(self : CategoryTheory.Limits.IsColimit t)
(s : CategoryTheory.Limits.Cocone F)
(j : J)
{Z : C}
(h : s.pt ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (t.ι.app j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsColimit.desc self s) h) = CategoryTheory.CategoryStruct.comp (s.ι.app j) h
instance
CategoryTheory.Limits.IsColimit.subsingleton
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
:
def
CategoryTheory.Limits.IsColimit.map
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(t : CategoryTheory.Limits.Cocone G)
(α : F ⟶ G)
:
s.pt ⟶ t.pt
Given a natural transformation α : F ⟶ G, we give a morphism from the cocone point
of a colimit cocone over F to the cocone point of any cocone over G.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.ι_map_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{c : CategoryTheory.Limits.Cocone F}
(hc : CategoryTheory.Limits.IsColimit c)
(d : CategoryTheory.Limits.Cocone G)
(α : F ⟶ G)
(j : J)
{Z : C}
(h : d.pt ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (c.ι.app j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsColimit.map hc d α) h) = CategoryTheory.CategoryStruct.comp (α.app j) (CategoryTheory.CategoryStruct.comp (d.ι.app j) h)
@[simp]
theorem
CategoryTheory.Limits.IsColimit.ι_map
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{c : CategoryTheory.Limits.Cocone F}
(hc : CategoryTheory.Limits.IsColimit c)
(d : CategoryTheory.Limits.Cocone G)
(α : F ⟶ G)
(j : J)
:
CategoryTheory.CategoryStruct.comp (c.ι.app j) (CategoryTheory.Limits.IsColimit.map hc d α) = CategoryTheory.CategoryStruct.comp (α.app j) (d.ι.app j)
@[simp]
theorem
CategoryTheory.Limits.IsColimit.desc_self
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
:
@[simp]
theorem
CategoryTheory.Limits.IsColimit.descCoconeMorphism_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
(s : CategoryTheory.Limits.Cocone F)
:
def
CategoryTheory.Limits.IsColimit.descCoconeMorphism
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
(s : CategoryTheory.Limits.Cocone F)
:
t ⟶ s
The universal morphism from a colimit cocone to any other cocone.
Instances For
theorem
CategoryTheory.Limits.IsColimit.uniq_cocone_morphism
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
{f : t ⟶ s}
{f' : t ⟶ s}
:
f = f'
theorem
CategoryTheory.Limits.IsColimit.existsUnique
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
(s : CategoryTheory.Limits.Cocone F)
:
∃! d, ∀ (j : J), CategoryTheory.CategoryStruct.comp (t.ι.app j) d = s.ι.app j
Restating the definition of a colimit cocone in terms of the ∃! operator.
def
CategoryTheory.Limits.IsColimit.ofExistsUnique
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(ht : ∀ (s : CategoryTheory.Limits.Cocone F), ∃! d, ∀ (j : J), CategoryTheory.CategoryStruct.comp (t.ι.app j) d = s.ι.app j)
:
Noncomputably make a colimit cocone from the existence of unique factorizations.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.mkCoconeMorphism_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(desc : (s : CategoryTheory.Limits.Cocone F) → t ⟶ s)
(uniq' : ∀ (s : CategoryTheory.Limits.Cocone F) (m : t ⟶ s), m = desc s)
(s : CategoryTheory.Limits.Cocone F)
:
CategoryTheory.Limits.IsColimit.desc (CategoryTheory.Limits.IsColimit.mkCoconeMorphism desc uniq') s = (desc s).hom
def
CategoryTheory.Limits.IsColimit.mkCoconeMorphism
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(desc : (s : CategoryTheory.Limits.Cocone F) → t ⟶ s)
(uniq' : ∀ (s : CategoryTheory.Limits.Cocone F) (m : t ⟶ s), m = desc s)
:
Alternative constructor for IsColimit,
providing a morphism of cocones rather than a morphism between the cocone points
and separately the factorisation condition.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.uniqueUpToIso_inv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
:
@[simp]
theorem
CategoryTheory.Limits.IsColimit.uniqueUpToIso_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
:
def
CategoryTheory.Limits.IsColimit.uniqueUpToIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
:
s ≅ t
Colimit cocones on F are unique up to isomorphism.
Instances For
theorem
CategoryTheory.Limits.IsColimit.hom_isIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(f : s ⟶ t)
:
Any cocone morphism between colimit cocones is an isomorphism.
def
CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
:
s.pt ≅ t.pt
Colimits of F are unique up to isomorphism.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_hom_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(j : J)
{Z : C}
(h : t.pt ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (s.ι.app j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso P Q).hom h) = CategoryTheory.CategoryStruct.comp (t.ι.app j) h
@[simp]
theorem
CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(j : J)
:
CategoryTheory.CategoryStruct.comp (s.ι.app j) (CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso P Q).hom = t.ι.app j
@[simp]
theorem
CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_inv_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(j : J)
{Z : C}
(h : s.pt ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (t.ι.app j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso P Q).inv h) = CategoryTheory.CategoryStruct.comp (s.ι.app j) h
@[simp]
theorem
CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_inv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(j : J)
:
CategoryTheory.CategoryStruct.comp (t.ι.app j) (CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso P Q).inv = s.ι.app j
@[simp]
theorem
CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_hom_desc_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cocone F}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
{Z : C}
(h : r.pt ⟶ Z)
:
@[simp]
theorem
CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_hom_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cocone F}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
:
@[simp]
theorem
CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_inv_desc_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cocone F}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
{Z : C}
(h : r.pt ⟶ Z)
:
@[simp]
theorem
CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_inv_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cocone F}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
:
def
CategoryTheory.Limits.IsColimit.ofIsoColimit
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit r)
(i : r ≅ t)
:
Transport evidence that a cocone is a colimit cocone across an isomorphism of cocones.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.ofIsoColimit_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit r)
(i : r ≅ t)
(s : CategoryTheory.Limits.Cocone F)
:
def
CategoryTheory.Limits.IsColimit.equivIsoColimit
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(i : r ≅ t)
:
Isomorphism of cocones preserves whether or not they are colimiting cocones.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.equivIsoColimit_apply
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(i : r ≅ t)
(P : CategoryTheory.Limits.IsColimit r)
:
@[simp]
theorem
CategoryTheory.Limits.IsColimit.equivIsoColimit_symm_apply
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(i : r ≅ t)
(P : CategoryTheory.Limits.IsColimit t)
:
↑(CategoryTheory.Limits.IsColimit.equivIsoColimit i).symm P = CategoryTheory.Limits.IsColimit.ofIsoColimit P i.symm
def
CategoryTheory.Limits.IsColimit.ofPointIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{r : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit r)
[i : CategoryTheory.IsIso (CategoryTheory.Limits.IsColimit.desc P t)]
:
If the canonical morphism to a cocone point from a colimiting cocone point is an iso, then the first cocone was colimiting also.
Instances For
theorem
CategoryTheory.Limits.IsColimit.hom_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
{W : C}
(m : t.pt ⟶ W)
:
m = CategoryTheory.Limits.IsColimit.desc h
{ pt := W, ι := CategoryTheory.NatTrans.mk fun b => CategoryTheory.CategoryStruct.comp (t.ι.app b) m }
theorem
CategoryTheory.Limits.IsColimit.hom_ext
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
{W : C}
{f : t.pt ⟶ W}
{f' : t.pt ⟶ W}
(w : ∀ (j : J), CategoryTheory.CategoryStruct.comp (t.ι.app j) f = CategoryTheory.CategoryStruct.comp (t.ι.app j) f')
:
f = f'
Two morphisms out of a colimit are equal if their compositions with each cocone morphism are equal.
def
CategoryTheory.Limits.IsColimit.ofLeftAdjoint
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{G : CategoryTheory.Functor K D}
(h : CategoryTheory.Functor (CategoryTheory.Limits.Cocone G) (CategoryTheory.Limits.Cocone F))
[CategoryTheory.IsLeftAdjoint h]
{c : CategoryTheory.Limits.Cocone G}
(t : CategoryTheory.Limits.IsColimit c)
:
CategoryTheory.Limits.IsColimit (h.obj c)
Given a left adjoint functor between categories of cocones, the image of a colimit cocone is a colimit cocone.
Instances For
def
CategoryTheory.Limits.IsColimit.ofCoconeEquiv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{G : CategoryTheory.Functor K D}
(h : CategoryTheory.Limits.Cocone G ≌ CategoryTheory.Limits.Cocone F)
{c : CategoryTheory.Limits.Cocone G}
:
CategoryTheory.Limits.IsColimit (h.functor.obj c) ≃ CategoryTheory.Limits.IsColimit c
Given two functors which have equivalent categories of cocones, we can transport a colimiting cocone across the equivalence.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.ofCoconeEquiv_apply_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{G : CategoryTheory.Functor K D}
(h : CategoryTheory.Limits.Cocone G ≌ CategoryTheory.Limits.Cocone F)
{c : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit (h.functor.obj c))
(s : CategoryTheory.Limits.Cocone G)
:
CategoryTheory.Limits.IsColimit.desc (↑(CategoryTheory.Limits.IsColimit.ofCoconeEquiv h) P) s = CategoryTheory.CategoryStruct.comp (h.unit.app c).hom
(CategoryTheory.CategoryStruct.comp
(h.inverse.map (CategoryTheory.Limits.IsColimit.descCoconeMorphism P (h.functor.obj s))).hom
(h.unitInv.app s).hom)
@[simp]
theorem
CategoryTheory.Limits.IsColimit.ofCoconeEquiv_symm_apply_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{G : CategoryTheory.Functor K D}
(h : CategoryTheory.Limits.Cocone G ≌ CategoryTheory.Limits.Cocone F)
{c : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit c)
(s : CategoryTheory.Limits.Cocone F)
:
CategoryTheory.Limits.IsColimit.desc (↑(CategoryTheory.Limits.IsColimit.ofCoconeEquiv h).symm P) s = CategoryTheory.CategoryStruct.comp
(h.functor.map (CategoryTheory.Limits.IsColimit.descCoconeMorphism P (h.inverse.obj s))).hom (h.counit.app s).hom
def
CategoryTheory.Limits.IsColimit.precomposeHomEquiv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
(α : F ≅ G)
(c : CategoryTheory.Limits.Cocone G)
:
A cocone precomposed with a natural isomorphism is a colimit cocone if and only if the original cocone is.
Instances For
def
CategoryTheory.Limits.IsColimit.precomposeInvEquiv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
(α : F ≅ G)
(c : CategoryTheory.Limits.Cocone F)
:
A cocone precomposed with the inverse of a natural isomorphism is a colimit cocone if and only if the original cocone is.
Instances For
def
CategoryTheory.Limits.IsColimit.equivOfNatIsoOfIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
(α : F ≅ G)
(c : CategoryTheory.Limits.Cocone F)
(d : CategoryTheory.Limits.Cocone G)
(w : (CategoryTheory.Limits.Cocones.precompose α.inv).obj c ≅ d)
:
Constructing an equivalence is_colimit c ≃ is_colimit d from a natural isomorphism
between the underlying functors, and then an isomorphism between c transported along this and d.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(w : F ≅ G)
:
(CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso P Q w).hom = CategoryTheory.Limits.IsColimit.map P t w.hom
@[simp]
theorem
CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_inv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(w : F ≅ G)
:
(CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso P Q w).inv = CategoryTheory.Limits.IsColimit.map Q s w.inv
def
CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(w : F ≅ G)
:
s.pt ≅ t.pt
The cocone points of two colimit cocones for naturally isomorphic functors are themselves isomorphic.
Instances For
theorem
CategoryTheory.Limits.IsColimit.comp_coconePointsIsoOfNatIso_hom_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(w : F ≅ G)
(j : J)
{Z : C}
(h : t.pt ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (s.ι.app j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso P Q w).hom h) = CategoryTheory.CategoryStruct.comp (w.hom.app j) (CategoryTheory.CategoryStruct.comp (t.ι.app j) h)
theorem
CategoryTheory.Limits.IsColimit.comp_coconePointsIsoOfNatIso_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(w : F ≅ G)
(j : J)
:
CategoryTheory.CategoryStruct.comp (s.ι.app j) (CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso P Q w).hom = CategoryTheory.CategoryStruct.comp (w.hom.app j) (t.ι.app j)
theorem
CategoryTheory.Limits.IsColimit.comp_coconePointsIsoOfNatIso_inv_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(w : F ≅ G)
(j : J)
{Z : C}
(h : s.pt ⟶ Z)
:
CategoryTheory.CategoryStruct.comp (t.ι.app j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso P Q w).inv h) = CategoryTheory.CategoryStruct.comp (w.inv.app j) (CategoryTheory.CategoryStruct.comp (s.ι.app j) h)
theorem
CategoryTheory.Limits.IsColimit.comp_coconePointsIsoOfNatIso_inv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(w : F ≅ G)
(j : J)
:
CategoryTheory.CategoryStruct.comp (t.ι.app j) (CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso P Q w).inv = CategoryTheory.CategoryStruct.comp (w.inv.app j) (s.ι.app j)
theorem
CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_hom_desc_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{r : CategoryTheory.Limits.Cocone G}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(w : F ≅ G)
{Z : C}
(h : r.pt ⟶ Z)
:
theorem
CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_hom_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{r : CategoryTheory.Limits.Cocone G}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(w : F ≅ G)
:
theorem
CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_inv_desc_assoc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone G}
{r : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit t)
(Q : CategoryTheory.Limits.IsColimit s)
(w : F ≅ G)
{Z : C}
(h : r.pt ⟶ Z)
:
theorem
CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_inv_desc
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{G : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone G}
{r : CategoryTheory.Limits.Cocone F}
{t : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit t)
(Q : CategoryTheory.Limits.IsColimit s)
(w : F ≅ G)
:
def
CategoryTheory.Limits.IsColimit.whiskerEquivalence
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
(P : CategoryTheory.Limits.IsColimit s)
(e : K ≌ J)
:
If s : Cocone F is a colimit cocone, so is s whiskered by an equivalence e.
Instances For
def
CategoryTheory.Limits.IsColimit.ofWhiskerEquivalence
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
(e : K ≌ J)
(P : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cocone.whisker e.functor s))
:
If s : Cocone F whiskered by an equivalence e is a colimit cocone, so is s.
Instances For
def
CategoryTheory.Limits.IsColimit.whiskerEquivalenceEquiv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
(e : K ≌ J)
:
Given an equivalence of diagrams e, s is a colimit cocone iff s.whisker e.functor is.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.coconePointsIsoOfEquivalence_inv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{G : CategoryTheory.Functor K C}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(e : J ≌ K)
(w : CategoryTheory.Functor.comp e.functor G ≅ F)
:
(CategoryTheory.Limits.IsColimit.coconePointsIsoOfEquivalence P Q e w).inv = CategoryTheory.Limits.IsColimit.desc Q
((CategoryTheory.Limits.Cocones.equivalenceOfReindexing e.symm
((CategoryTheory.isoWhiskerLeft e.inverse w).symm ≪≫ CategoryTheory.Equivalence.invFunIdAssoc e G)).functor.obj
s)
@[simp]
theorem
CategoryTheory.Limits.IsColimit.coconePointsIsoOfEquivalence_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{G : CategoryTheory.Functor K C}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(e : J ≌ K)
(w : CategoryTheory.Functor.comp e.functor G ≅ F)
:
(CategoryTheory.Limits.IsColimit.coconePointsIsoOfEquivalence P Q e w).hom = CategoryTheory.Limits.IsColimit.desc P ((CategoryTheory.Limits.Cocones.equivalenceOfReindexing e w).functor.obj t)
def
CategoryTheory.Limits.IsColimit.coconePointsIsoOfEquivalence
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂}
[CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{s : CategoryTheory.Limits.Cocone F}
{G : CategoryTheory.Functor K C}
{t : CategoryTheory.Limits.Cocone G}
(P : CategoryTheory.Limits.IsColimit s)
(Q : CategoryTheory.Limits.IsColimit t)
(e : J ≌ K)
(w : CategoryTheory.Functor.comp e.functor G ≅ F)
:
s.pt ≅ t.pt
We can prove two cocone points (s : Cocone F).pt and (t : Cocone G).pt are isomorphic if
- both cocones are colimit cocones
- their indexing categories are equivalent via some
e : J ≌ K, - the triangle of functors commutes up to a natural isomorphism:
e.functor ⋙ G ≅ F.
This is the most general form of uniqueness of cocone points, allowing relabelling of both the indexing category (up to equivalence) and the functor (up to natural isomorphism).
Instances For
def
CategoryTheory.Limits.IsColimit.homIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
(W : C)
:
ULift.{u₁, v₃} (t.pt ⟶ W) ≅ F ⟶ (CategoryTheory.Functor.const J).obj W
The universal property of a colimit cocone: a map X ⟶ W is the same as
a cocone on F with cone point W.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.homIso_hom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
{W : C}
(f : ULift.{u₁, v₃} (t.pt ⟶ W))
:
(h.homIso W).hom f = (CategoryTheory.Limits.Cocone.extend t f.down).ι
def
CategoryTheory.Limits.IsColimit.natIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
:
CategoryTheory.Functor.comp (CategoryTheory.coyoneda.obj (Opposite.op t.pt)) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cocones F
The colimit of F represents the functor taking W to
the set of cocones on F with cone point W.
Instances For
def
CategoryTheory.Limits.IsColimit.homIso'
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
(h : CategoryTheory.Limits.IsColimit t)
(W : C)
:
ULift.{u₁, v₃} (t.pt ⟶ W) ≅ { p // ∀ {j j' : J} (f : j ⟶ j'), CategoryTheory.CategoryStruct.comp (F.map f) (p j') = p j }
Another, more explicit, formulation of the universal property of a colimit cocone.
See also homIso.
Instances For
def
CategoryTheory.Limits.IsColimit.ofFaithful
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
(G : CategoryTheory.Functor C D)
[CategoryTheory.Faithful G]
(ht : CategoryTheory.Limits.IsColimit (G.mapCocone t))
(desc : (s : CategoryTheory.Limits.Cocone F) → t.pt ⟶ s.pt)
(h : ∀ (s : CategoryTheory.Limits.Cocone F), G.map (desc s) = CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s))
:
If G : C → D is a faithful functor which sends t to a colimit cocone, then it suffices to check that the induced maps for the image of t can be lifted to maps of C.
Instances For
def
CategoryTheory.Limits.IsColimit.mapCoconeEquiv
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄}
[CategoryTheory.Category.{v₄, u₄} D]
{K : CategoryTheory.Functor J C}
{F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor C D}
(h : F ≅ G)
{c : CategoryTheory.Limits.Cocone K}
(t : CategoryTheory.Limits.IsColimit (F.mapCocone c))
:
CategoryTheory.Limits.IsColimit (G.mapCocone c)
If F and G are naturally isomorphic, then F.mapCocone c being a colimit implies
G.mapCocone c is also a colimit.
Instances For
def
CategoryTheory.Limits.IsColimit.isoUniqueCoconeMorphism
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{t : CategoryTheory.Limits.Cocone F}
:
CategoryTheory.Limits.IsColimit t ≅ (s : CategoryTheory.Limits.Cocone F) → Unique (t ⟶ s)
A cocone is a colimit cocone exactly if there is a unique cocone morphism from any other cocone.
Instances For
def
CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.coyoneda.obj (Opposite.op X)) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cocones F)
{Y : C}
(f : X ⟶ Y)
:
If F.cocones is corepresented by X, each morphism f : X ⟶ Y gives a cocone with cone
point Y.
Instances For
def
CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.coyoneda.obj (Opposite.op X)) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cocones F)
(s : CategoryTheory.Limits.Cocone F)
:
X ⟶ s.pt
If F.cocones is corepresented by X, each cocone s gives a morphism X ⟶ s.pt.
Instances For
@[simp]
theorem
CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom_homOfCocone
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.coyoneda.obj (Opposite.op X)) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cocones F)
(s : CategoryTheory.Limits.Cocone F)
:
@[simp]
theorem
CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone_cooneOfHom
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.coyoneda.obj (Opposite.op X)) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cocones F)
{Y : C}
(f : X ⟶ Y)
:
def
CategoryTheory.Limits.IsColimit.OfNatIso.colimitCocone
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.coyoneda.obj (Opposite.op X)) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cocones F)
:
If F.cocones is corepresented by X, the cocone corresponding to the identity morphism on X
will be a colimit cocone.
Instances For
theorem
CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom_fac
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.coyoneda.obj (Opposite.op X)) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cocones F)
{Y : C}
(f : X ⟶ Y)
:
If F.cocones is corepresented by X, the cocone corresponding to a morphism f : Y ⟶ X is
the colimit cocone extended by f.
theorem
CategoryTheory.Limits.IsColimit.OfNatIso.cocone_fac
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.coyoneda.obj (Opposite.op X)) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cocones F)
(s : CategoryTheory.Limits.Cocone F)
:
If F.cocones is corepresented by X, any cocone is the extension of the colimit cocone by the
corresponding morphism.
def
CategoryTheory.Limits.IsColimit.ofNatIso
{J : Type u₁}
[CategoryTheory.Category.{v₁, u₁} J]
{C : Type u₃}
[CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C}
{X : C}
(h : CategoryTheory.Functor.comp (CategoryTheory.coyoneda.obj (Opposite.op X)) CategoryTheory.uliftFunctor.{u₁, v₃} ≅ CategoryTheory.Functor.cocones F)
:
If F.cocones is corepresentable, then the cocone corresponding to the identity morphism on
the representing object is a colimit cocone.