File: Mathlib/CategoryTheory/Limits/Over.lean

full_name: CategoryTheory.Over.hasColimit_of_hasColimit_comp_forget
code: instance hasColimit_of_hasColimit_comp_forget (F : J ⥤ Over X) [i : HasColimit (F ⋙ forget X)] :
    HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Over.instHasColimitsOfShape
code: instance [HasColimitsOfShape J C] : HasColimitsOfShape J (Over X) 
goal: CategoryTheory.Limits.HasColimitsOfShape J (CategoryTheory.Over X)

full_name: CategoryTheory.Over.instHasColimits
code: instance [HasColimits C] : HasColimits (Over X) 
goal: CategoryTheory.Limits.HasColimits (CategoryTheory.Over X)

full_name: CategoryTheory.Over.createsColimitsOfSize
code: instance createsColimitsOfSize : CreatesColimitsOfSize.{w, w'} (forget X) 
goal: CategoryTheory.CreatesColimitsOfSize.{w, w', v, v, max u v, u} (CategoryTheory.Over.forget X)

full_name: CategoryTheory.Over.epi_left_of_epi
code: theorem epi_left_of_epi [HasPushouts C] {f g : Over X} (h : f ⟶ g) [Epi h] : Epi h.left 
goal: CategoryTheory.Epi h.left

full_name: CategoryTheory.Over.epi_iff_epi_left
code: theorem epi_iff_epi_left [HasPushouts C] {f g : Over X} (h : f ⟶ g) : Epi h ↔ Epi h.left 
goal: CategoryTheory.Epi h ↔ CategoryTheory.Epi h.left

full_name: CategoryTheory.Over.createsColimitsOfSizeMapCompForget
code: instance createsColimitsOfSizeMapCompForget {Y : C} (f : X ⟶ Y) :
    CreatesColimitsOfSize.{w, w'} (map f ⋙ forget Y) 
goal: CategoryTheory.CreatesColimitsOfSize.{w, w', v, v, max u v, u}
  (CategoryTheory.Over.map f ⋙ CategoryTheory.Over.forget Y)

full_name: CategoryTheory.Over.preservesColimitsOfSizeMap
code: instance preservesColimitsOfSizeMap [HasColimitsOfSize.{w, w'} C] {Y : C} (f : X ⟶ Y) :
    PreservesColimitsOfSize.{w, w'} (map f) 
goal: CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v, v, max u v, max u v} (CategoryTheory.Over.map f)

full_name: CategoryTheory.Over.isColimitToOver
code: /-- If `c` is a colimit cocone, then so is the cocone `c.toOver` with cocone point `𝟙 c.pt`. -/
def isColimitToOver {F : J ⥤ C} {c : Cocone F} (hc : IsColimit c) : IsColimit c.toOver 
goal: CategoryTheory.Limits.IsColimit c.toOver

full_name: CategoryTheory.Limits.colimit.isColimitToOver
code: /-- If `F` has a colimit, then the cocone `colimit.toOver F` with cocone point `𝟙 (colimit F)` is
    also a colimit cocone. -/
def _root_.CategoryTheory.Limits.colimit.isColimitToOver (F : J ⥤ C) [HasColimit F] :
    IsColimit (colimit.toOver F) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.colimit.toOver F)

full_name: CategoryTheory.Under.hasLimit_of_hasLimit_comp_forget
code: instance hasLimit_of_hasLimit_comp_forget (F : J ⥤ Under X) [i : HasLimit (F ⋙ forget X)] :
    HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Under.instHasLimitsOfShape
code: instance [HasLimitsOfShape J C] : HasLimitsOfShape J (Under X) 
goal: CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Under X)

full_name: CategoryTheory.Under.instHasLimits
code: instance [HasLimits C] : HasLimits (Under X) 
goal: CategoryTheory.Limits.HasLimits (CategoryTheory.Under X)

full_name: CategoryTheory.Under.mono_right_of_mono
code: theorem mono_right_of_mono [HasPullbacks C] {f g : Under X} (h : f ⟶ g) [Mono h] : Mono h.right 
goal: CategoryTheory.Mono h.right

full_name: CategoryTheory.Under.mono_iff_mono_right
code: theorem mono_iff_mono_right [HasPullbacks C] {f g : Under X} (h : f ⟶ g) : Mono h ↔ Mono h.right 
goal: CategoryTheory.Mono h ↔ CategoryTheory.Mono h.right

full_name: CategoryTheory.Under.createsLimitsOfSize
code: instance createsLimitsOfSize : CreatesLimitsOfSize.{w, w'} (forget X) 
goal: CategoryTheory.CreatesLimitsOfSize.{w, w', v, v, max u v, u} (CategoryTheory.Under.forget X)

full_name: CategoryTheory.Under.createLimitsOfSizeMapCompForget
code: instance createLimitsOfSizeMapCompForget {Y : C} (f : X ⟶ Y) :
    CreatesLimitsOfSize.{w, w'} (map f ⋙ forget X) 
goal: CategoryTheory.CreatesLimitsOfSize.{w, w', v, v, max u v, u}
  (CategoryTheory.Under.map f ⋙ CategoryTheory.Under.forget X)

full_name: CategoryTheory.Under.preservesLimitsOfSizeMap
code: instance preservesLimitsOfSizeMap [HasLimitsOfSize.{w, w'} C] {Y : C} (f : X ⟶ Y) :
    PreservesLimitsOfSize.{w, w'} (map f) 
goal: CategoryTheory.Limits.PreservesLimitsOfSize.{w, w', v, v, max u v, max u v} (CategoryTheory.Under.map f)

full_name: CategoryTheory.Under.isLimitToUnder
code: /-- If `c` is a limit cone, then so is the cone `c.toUnder` with cone point `𝟙 c.pt`. -/
def isLimitToUnder {F : J ⥤ C} {c : Cone F} (hc : IsLimit c) : IsLimit c.toUnder 
goal: CategoryTheory.Limits.IsLimit c.toUnder

full_name: CategoryTheory.Limits.limit.isLimitToOver
code: /-- If `F` has a limit, then the cone `limit.toUnder F` with cone point `𝟙 (limit F)` is
    also a limit cone. -/
def _root_.CategoryTheory.Limits.limit.isLimitToOver (F : J ⥤ C) [HasLimit F] :
    IsLimit (limit.toUnder F) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.limit.toUnder F)