Limits and colimits in comma categories #
We build limits in the comma category Comma L R provided that the two source categories have
limits and R preserves them.
This is used to construct limits in the arrow category, structured arrow category and under
category, and show that the appropriate forgetful functors create limits.
The duals of all the above are also given.
def
CategoryTheory.Comma.limitAuxiliaryCone
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
(c₁ : Limits.Cone (F.comp (fst L R)))
:
Limits.Cone ((F.comp (snd L R)).comp R)
(Implementation). An auxiliary cone which is useful in order to construct limits in the comma category.
Equations
- CategoryTheory.Comma.limitAuxiliaryCone F c₁ = (CategoryTheory.Limits.Cones.postcompose (CategoryTheory.whiskerLeft F (CategoryTheory.Comma.natTrans L R))).obj (L.mapCone c₁)
Instances For
@[simp]
theorem
CategoryTheory.Comma.limitAuxiliaryCone_pt
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
(c₁ : Limits.Cone (F.comp (fst L R)))
:
(limitAuxiliaryCone F c₁).pt = L.obj c₁.pt
@[simp]
theorem
CategoryTheory.Comma.limitAuxiliaryCone_π_app
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
(c₁ : Limits.Cone (F.comp (fst L R)))
(X : J)
:
(limitAuxiliaryCone F c₁).π.app X = CategoryStruct.comp (L.map (c₁.π.app X)) (F.obj X).hom
noncomputable def
CategoryTheory.Comma.coneOfPreserves
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesLimit (F.comp (snd L R)) R]
(c₁ : Limits.Cone (F.comp (fst L R)))
{c₂ : Limits.Cone (F.comp (snd L R))}
(t₂ : Limits.IsLimit c₂)
:
If R preserves the appropriate limit, then given a cone for F ⋙ fst L R : J ⥤ L and a
limit cone for F ⋙ snd L R : J ⥤ R we can build a cone for F which will turn out to be a limit
cone.
Equations
- One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem
CategoryTheory.Comma.coneOfPreserves_π_app_right
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesLimit (F.comp (snd L R)) R]
(c₁ : Limits.Cone (F.comp (fst L R)))
{c₂ : Limits.Cone (F.comp (snd L R))}
(t₂ : Limits.IsLimit c₂)
(j : J)
:
((coneOfPreserves F c₁ t₂).π.app j).right = c₂.π.app j
@[simp]
theorem
CategoryTheory.Comma.coneOfPreserves_pt_right
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesLimit (F.comp (snd L R)) R]
(c₁ : Limits.Cone (F.comp (fst L R)))
{c₂ : Limits.Cone (F.comp (snd L R))}
(t₂ : Limits.IsLimit c₂)
:
(coneOfPreserves F c₁ t₂).pt.right = c₂.pt
@[simp]
theorem
CategoryTheory.Comma.coneOfPreserves_π_app_left
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesLimit (F.comp (snd L R)) R]
(c₁ : Limits.Cone (F.comp (fst L R)))
{c₂ : Limits.Cone (F.comp (snd L R))}
(t₂ : Limits.IsLimit c₂)
(j : J)
:
((coneOfPreserves F c₁ t₂).π.app j).left = c₁.π.app j
@[simp]
theorem
CategoryTheory.Comma.coneOfPreserves_pt_left
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesLimit (F.comp (snd L R)) R]
(c₁ : Limits.Cone (F.comp (fst L R)))
{c₂ : Limits.Cone (F.comp (snd L R))}
(t₂ : Limits.IsLimit c₂)
:
(coneOfPreserves F c₁ t₂).pt.left = c₁.pt
@[simp]
theorem
CategoryTheory.Comma.coneOfPreserves_pt_hom
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesLimit (F.comp (snd L R)) R]
(c₁ : Limits.Cone (F.comp (fst L R)))
{c₂ : Limits.Cone (F.comp (snd L R))}
(t₂ : Limits.IsLimit c₂)
:
(coneOfPreserves F c₁ t₂).pt.hom = (Limits.isLimitOfPreserves R t₂).lift (limitAuxiliaryCone F c₁)
noncomputable def
CategoryTheory.Comma.coneOfPreservesIsLimit
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesLimit (F.comp (snd L R)) R]
{c₁ : Limits.Cone (F.comp (fst L R))}
(t₁ : Limits.IsLimit c₁)
{c₂ : Limits.Cone (F.comp (snd L R))}
(t₂ : Limits.IsLimit c₂)
:
Limits.IsLimit (coneOfPreserves F c₁ t₂)
Provided that R preserves the appropriate limit, then the cone in coneOfPreserves is a
limit.
Equations
- One or more equations did not get rendered due to their size.
Instances For
def
CategoryTheory.Comma.colimitAuxiliaryCocone
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
(c₂ : Limits.Cocone (F.comp (snd L R)))
:
Limits.Cocone ((F.comp (fst L R)).comp L)
(Implementation). An auxiliary cocone which is useful in order to construct colimits in the comma category.
Equations
- CategoryTheory.Comma.colimitAuxiliaryCocone F c₂ = (CategoryTheory.Limits.Cocones.precompose (CategoryTheory.whiskerLeft F (CategoryTheory.Comma.natTrans L R))).obj (R.mapCocone c₂)
Instances For
@[simp]
theorem
CategoryTheory.Comma.colimitAuxiliaryCocone_pt
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
(c₂ : Limits.Cocone (F.comp (snd L R)))
:
(colimitAuxiliaryCocone F c₂).pt = R.obj c₂.pt
@[simp]
theorem
CategoryTheory.Comma.colimitAuxiliaryCocone_ι_app
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
(c₂ : Limits.Cocone (F.comp (snd L R)))
(X : J)
:
(colimitAuxiliaryCocone F c₂).ι.app X = CategoryStruct.comp (F.obj X).hom (R.map (c₂.ι.app X))
noncomputable def
CategoryTheory.Comma.coconeOfPreserves
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesColimit (F.comp (fst L R)) L]
{c₁ : Limits.Cocone (F.comp (fst L R))}
(t₁ : Limits.IsColimit c₁)
(c₂ : Limits.Cocone (F.comp (snd L R)))
:
If L preserves the appropriate colimit, then given a colimit cocone for F ⋙ fst L R : J ⥤ L and
a cocone for F ⋙ snd L R : J ⥤ R we can build a cocone for F which will turn out to be a
colimit cocone.
Equations
- One or more equations did not get rendered due to their size.
Instances For
@[simp]
theorem
CategoryTheory.Comma.coconeOfPreserves_ι_app_right
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesColimit (F.comp (fst L R)) L]
{c₁ : Limits.Cocone (F.comp (fst L R))}
(t₁ : Limits.IsColimit c₁)
(c₂ : Limits.Cocone (F.comp (snd L R)))
(j : J)
:
((coconeOfPreserves F t₁ c₂).ι.app j).right = c₂.ι.app j
@[simp]
theorem
CategoryTheory.Comma.coconeOfPreserves_pt_left
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesColimit (F.comp (fst L R)) L]
{c₁ : Limits.Cocone (F.comp (fst L R))}
(t₁ : Limits.IsColimit c₁)
(c₂ : Limits.Cocone (F.comp (snd L R)))
:
(coconeOfPreserves F t₁ c₂).pt.left = c₁.pt
@[simp]
theorem
CategoryTheory.Comma.coconeOfPreserves_pt_hom
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesColimit (F.comp (fst L R)) L]
{c₁ : Limits.Cocone (F.comp (fst L R))}
(t₁ : Limits.IsColimit c₁)
(c₂ : Limits.Cocone (F.comp (snd L R)))
:
(coconeOfPreserves F t₁ c₂).pt.hom = (Limits.isColimitOfPreserves L t₁).desc (colimitAuxiliaryCocone F c₂)
@[simp]
theorem
CategoryTheory.Comma.coconeOfPreserves_ι_app_left
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesColimit (F.comp (fst L R)) L]
{c₁ : Limits.Cocone (F.comp (fst L R))}
(t₁ : Limits.IsColimit c₁)
(c₂ : Limits.Cocone (F.comp (snd L R)))
(j : J)
:
((coconeOfPreserves F t₁ c₂).ι.app j).left = c₁.ι.app j
@[simp]
theorem
CategoryTheory.Comma.coconeOfPreserves_pt_right
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesColimit (F.comp (fst L R)) L]
{c₁ : Limits.Cocone (F.comp (fst L R))}
(t₁ : Limits.IsColimit c₁)
(c₂ : Limits.Cocone (F.comp (snd L R)))
:
(coconeOfPreserves F t₁ c₂).pt.right = c₂.pt
noncomputable def
CategoryTheory.Comma.coconeOfPreservesIsColimit
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.PreservesColimit (F.comp (fst L R)) L]
{c₁ : Limits.Cocone (F.comp (fst L R))}
(t₁ : Limits.IsColimit c₁)
{c₂ : Limits.Cocone (F.comp (snd L R))}
(t₂ : Limits.IsColimit c₂)
:
Limits.IsColimit (coconeOfPreserves F t₁ c₂)
Provided that L preserves the appropriate colimit, then the cocone in coconeOfPreserves is
a colimit.
Equations
- One or more equations did not get rendered due to their size.
Instances For
instance
CategoryTheory.Comma.hasLimit
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.HasLimit (F.comp (fst L R))]
[Limits.HasLimit (F.comp (snd L R))]
[Limits.PreservesLimit (F.comp (snd L R)) R]
:
instance
CategoryTheory.Comma.hasLimitsOfShape
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
[Limits.HasLimitsOfShape J A]
[Limits.HasLimitsOfShape J B]
[Limits.PreservesLimitsOfShape J R]
:
Limits.HasLimitsOfShape J (Comma L R)
instance
CategoryTheory.Comma.hasLimitsOfSize
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
[Limits.HasLimitsOfSize.{w, w', v₁, u₁} A]
[Limits.HasLimitsOfSize.{w, w', v₂, u₂} B]
[Limits.PreservesLimitsOfSize.{w, w', v₂, v₃, u₂, u₃} R]
:
instance
CategoryTheory.Comma.hasColimit
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
(F : Functor J (Comma L R))
[Limits.HasColimit (F.comp (fst L R))]
[Limits.HasColimit (F.comp (snd L R))]
[Limits.PreservesColimit (F.comp (fst L R)) L]
:
instance
CategoryTheory.Comma.hasColimitsOfShape
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
[Limits.HasColimitsOfShape J A]
[Limits.HasColimitsOfShape J B]
[Limits.PreservesColimitsOfShape J L]
:
Limits.HasColimitsOfShape J (Comma L R)
instance
CategoryTheory.Comma.hasColimitsOfSize
{A : Type u₁}
[Category.{v₁, u₁} A]
{B : Type u₂}
[Category.{v₂, u₂} B]
{T : Type u₃}
[Category.{v₃, u₃} T]
{L : Functor A T}
{R : Functor B T}
[Limits.HasColimitsOfSize.{w, w', v₁, u₁} A]
[Limits.HasColimitsOfSize.{w, w', v₂, u₂} B]
[Limits.PreservesColimitsOfSize.{w, w', v₁, v₃, u₁, u₃} L]
:
instance
CategoryTheory.Arrow.hasLimit
{J : Type w}
[Category.{w', w} J]
{T : Type u₃}
[Category.{v₃, u₃} T]
(F : Functor J (Arrow T))
[i₁ : Limits.HasLimit (F.comp leftFunc)]
[i₂ : Limits.HasLimit (F.comp rightFunc)]
:
instance
CategoryTheory.Arrow.hasLimitsOfShape
{J : Type w}
[Category.{w', w} J]
{T : Type u₃}
[Category.{v₃, u₃} T]
[Limits.HasLimitsOfShape J T]
:
Limits.HasLimitsOfShape J (Arrow T)
instance
CategoryTheory.Arrow.hasColimit
{J : Type w}
[Category.{w', w} J]
{T : Type u₃}
[Category.{v₃, u₃} T]
(F : Functor J (Arrow T))
[i₁ : Limits.HasColimit (F.comp leftFunc)]
[i₂ : Limits.HasColimit (F.comp rightFunc)]
:
instance
CategoryTheory.Arrow.hasColimitsOfShape
{J : Type w}
[Category.{w', w} J]
{T : Type u₃}
[Category.{v₃, u₃} T]
[Limits.HasColimitsOfShape J T]
:
instance
CategoryTheory.Arrow.hasColimits
{T : Type u₃}
[Category.{v₃, u₃} T]
[Limits.HasColimits T]
:
instance
CategoryTheory.StructuredArrow.hasLimit
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{X : T}
{G : Functor A T}
(F : Functor J (StructuredArrow X G))
[i₁ : Limits.HasLimit (F.comp (proj X G))]
[i₂ : Limits.PreservesLimit (F.comp (proj X G)) G]
:
instance
CategoryTheory.StructuredArrow.hasLimitsOfShape
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{X : T}
{G : Functor A T}
[Limits.HasLimitsOfShape J A]
[Limits.PreservesLimitsOfShape J G]
:
instance
CategoryTheory.StructuredArrow.hasLimitsOfSize
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{X : T}
{G : Functor A T}
[Limits.HasLimitsOfSize.{w, w', v₁, u₁} A]
[Limits.PreservesLimitsOfSize.{w, w', v₁, v₃, u₁, u₃} G]
:
noncomputable instance
CategoryTheory.StructuredArrow.createsLimit
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{X : T}
{G : Functor A T}
(F : Functor J (StructuredArrow X G))
[i : Limits.PreservesLimit (F.comp (proj X G)) G]
:
CreatesLimit F (proj X G)
Equations
- One or more equations did not get rendered due to their size.
noncomputable instance
CategoryTheory.StructuredArrow.createsLimitsOfShape
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{X : T}
{G : Functor A T}
[Limits.PreservesLimitsOfShape J G]
:
CreatesLimitsOfShape J (proj X G)
Equations
- CategoryTheory.StructuredArrow.createsLimitsOfShape = { CreatesLimit := fun {K : CategoryTheory.Functor J (CategoryTheory.StructuredArrow X G)} => inferInstance }
noncomputable instance
CategoryTheory.StructuredArrow.createsLimitsOfSize
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{X : T}
{G : Functor A T}
[Limits.PreservesLimitsOfSize.{w, w', v₁, v₃, u₁, u₃} G]
:
Equations
- CategoryTheory.StructuredArrow.createsLimitsOfSize = { CreatesLimitsOfShape := fun {J : Type ?u.57} [CategoryTheory.Category.{?u.56, ?u.57} J] => inferInstance }
instance
CategoryTheory.StructuredArrow.mono_right_of_mono
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{X : T}
{G : Functor A T}
[Limits.HasPullbacks A]
[Limits.PreservesLimitsOfShape Limits.WalkingCospan G]
{Y Z : StructuredArrow X G}
(f : Y ⟶ Z)
[Mono f]
:
Mono f.right
theorem
CategoryTheory.StructuredArrow.mono_iff_mono_right
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{X : T}
{G : Functor A T}
[Limits.HasPullbacks A]
[Limits.PreservesLimitsOfShape Limits.WalkingCospan G]
{Y Z : StructuredArrow X G}
(f : Y ⟶ Z)
:
instance
CategoryTheory.CostructuredArrow.hasTerminal
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{G : Functor A T}
[G.Faithful]
[G.Full]
{Y : A}
:
Limits.HasTerminal (CostructuredArrow G (G.obj Y))
instance
CategoryTheory.CostructuredArrow.hasColimit
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{G : Functor A T}
{X : T}
(F : Functor J (CostructuredArrow G X))
[i₁ : Limits.HasColimit (F.comp (proj G X))]
[i₂ : Limits.PreservesColimit (F.comp (proj G X)) G]
:
instance
CategoryTheory.CostructuredArrow.hasColimitsOfShape
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{G : Functor A T}
{X : T}
[Limits.HasColimitsOfShape J A]
[Limits.PreservesColimitsOfShape J G]
:
instance
CategoryTheory.CostructuredArrow.hasColimitsOfSize
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{G : Functor A T}
{X : T}
[Limits.HasColimitsOfSize.{w, w', v₁, u₁} A]
[Limits.PreservesColimitsOfSize.{w, w', v₁, v₃, u₁, u₃} G]
:
noncomputable instance
CategoryTheory.CostructuredArrow.createsColimit
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{G : Functor A T}
{X : T}
(F : Functor J (CostructuredArrow G X))
[i : Limits.PreservesColimit (F.comp (proj G X)) G]
:
CreatesColimit F (proj G X)
Equations
- One or more equations did not get rendered due to their size.
noncomputable instance
CategoryTheory.CostructuredArrow.createsColimitsOfShape
{J : Type w}
[Category.{w', w} J]
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{G : Functor A T}
{X : T}
[Limits.PreservesColimitsOfShape J G]
:
CreatesColimitsOfShape J (proj G X)
Equations
- CategoryTheory.CostructuredArrow.createsColimitsOfShape = { CreatesColimit := fun {K : CategoryTheory.Functor J (CategoryTheory.CostructuredArrow G X)} => inferInstance }
noncomputable instance
CategoryTheory.CostructuredArrow.createsColimitsOfSize
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{G : Functor A T}
{X : T}
[Limits.PreservesColimitsOfSize.{w, w', v₁, v₃, u₁, u₃} G]
:
Equations
- CategoryTheory.CostructuredArrow.createsColimitsOfSize = { CreatesColimitsOfShape := fun {J : Type ?u.57} [CategoryTheory.Category.{?u.56, ?u.57} J] => inferInstance }
instance
CategoryTheory.CostructuredArrow.epi_left_of_epi
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{G : Functor A T}
{X : T}
[Limits.HasPushouts A]
[Limits.PreservesColimitsOfShape Limits.WalkingSpan G]
{Y Z : CostructuredArrow G X}
(f : Y ⟶ Z)
[Epi f]
:
Epi f.left
theorem
CategoryTheory.CostructuredArrow.epi_iff_epi_left
{A : Type u₁}
[Category.{v₁, u₁} A]
{T : Type u₃}
[Category.{v₃, u₃} T]
{G : Functor A T}
{X : T}
[Limits.HasPushouts A]
[Limits.PreservesColimitsOfShape Limits.WalkingSpan G]
{Y Z : CostructuredArrow G X}
(f : Y ⟶ Z)
: