File: Mathlib/CategoryTheory/Limits/HasLimits.lean

full_name: CategoryTheory.Limits.LimitCone.cone
code: /-- `LimitCone F` contains a cone over `F` together with the information that it is a limit. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): removed; linter not ported yet
structure LimitCone (F : J ⥤ C) where
  /-- The cone itself -/
  cone : Cone F
  /-- The proof that is the limit cone -/
  isLimit : IsLimit cone
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.LimitCone
code: /-- `LimitCone F` contains a cone over `F` together with the information that it is a limit. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): removed; linter not ported yet
structure LimitCone (F : J ⥤ C) where
  /-- The cone itself -/
  cone : Cone F
  /-- The proof that is the limit cone -/
  isLimit : IsLimit cone
goal: Type (max (max u u₁) v)

full_name: CategoryTheory.Limits.LimitCone.isLimit
code: /-- `LimitCone F` contains a cone over `F` together with the information that it is a limit. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): removed; linter not ported yet
structure LimitCone (F : J ⥤ C) where
  /-- The cone itself -/
  cone : Cone F
  /-- The proof that is the limit cone -/
  isLimit : IsLimit cone
goal: CategoryTheory.Limits.IsLimit self.cone

full_name: CategoryTheory.Limits.HasLimit.exists_limit
code: /-- `HasLimit F` represents the mere existence of a limit for `F`. -/
class HasLimit (F : J ⥤ C) : Prop where mk' ::
  /-- There is some limit cone for `F` -/
  exists_limit : Nonempty (LimitCone F)
goal: Nonempty (CategoryTheory.Limits.LimitCone F)

full_name: CategoryTheory.Limits.HasLimit
code: /-- `HasLimit F` represents the mere existence of a limit for `F`. -/
class HasLimit (F : J ⥤ C) : Prop where mk' ::
  /-- There is some limit cone for `F` -/
  exists_limit : Nonempty (LimitCone F)
goal: Prop

full_name: CategoryTheory.Limits.HasLimit.mk'
code: /-- `HasLimit F` represents the mere existence of a limit for `F`. -/
class HasLimit (F : J ⥤ C) : Prop where mk' ::
  /-- There is some limit cone for `F` -/
  exists_limit : Nonempty (LimitCone F)
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.HasLimit.mk
code: theorem HasLimit.mk {F : J ⥤ C} (d : LimitCone F) : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.getLimitCone
code: /-- Use the axiom of choice to extract explicit `LimitCone F` from `HasLimit F`. -/
def getLimitCone (F : J ⥤ C) [HasLimit F] : LimitCone F 
goal: CategoryTheory.Limits.LimitCone F

full_name: CategoryTheory.Limits.HasLimitsOfShape
code: /-- `C` has limits of shape `J` if there exists a limit for every functor `F : J ⥤ C`. -/
class HasLimitsOfShape : Prop where
  /-- All functors `F : J ⥤ C` from `J` have limits -/
  has_limit : ∀ F : J ⥤ C, HasLimit F := by infer_instance
goal: Prop

full_name: CategoryTheory.Limits.HasLimitsOfShape.has_limit
code: /-- `C` has limits of shape `J` if there exists a limit for every functor `F : J ⥤ C`. -/
class HasLimitsOfShape : Prop where
  /-- All functors `F : J ⥤ C` from `J` have limits -/
  has_limit : ∀ F : J ⥤ C, HasLimit F := by infer_instance
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.HasLimitsOfSize
code: /-- `C` has all limits of size `v₁ u₁` (`HasLimitsOfSize.{v₁ u₁} C`)
if it has limits of every shape `J : Type u₁` with `[Category.{v₁} J]`.
-/
@[pp_with_univ]
class HasLimitsOfSize (C : Type u) [Category.{v} C] : Prop where
  /-- All functors `F : J ⥤ C` from all small `J` have limits -/
  has_limits_of_shape : ∀ (J : Type u₁) [Category.{v₁} J], HasLimitsOfShape J C := by
    infer_instance
goal: Prop

full_name: CategoryTheory.Limits.HasLimitsOfSize.has_limits_of_shape
code: /-- `C` has all limits of size `v₁ u₁` (`HasLimitsOfSize.{v₁ u₁} C`)
if it has limits of every shape `J : Type u₁` with `[Category.{v₁} J]`.
-/
@[pp_with_univ]
class HasLimitsOfSize (C : Type u) [Category.{v} C] : Prop where
  /-- All functors `F : J ⥤ C` from all small `J` have limits -/
  has_limits_of_shape : ∀ (J : Type u₁) [Category.{v₁} J], HasLimitsOfShape J C := by
    infer_instance
goal: CategoryTheory.Limits.HasLimitsOfShape J C

full_name: CategoryTheory.Limits.HasLimits
code: /-- `C` has all (small) limits if it has limits of every shape that is as big as its hom-sets. -/
abbrev HasLimits (C : Type u) [Category.{v} C] : Prop 
goal: Prop

full_name: CategoryTheory.Limits.HasLimits.has_limits_of_shape
code: theorem HasLimits.has_limits_of_shape {C : Type u} [Category.{v} C] [HasLimits C] (J : Type v)
    [Category.{v} J] : HasLimitsOfShape J C 
goal: CategoryTheory.Limits.HasLimitsOfShape J C

full_name: CategoryTheory.Limits.hasLimitOfHasLimitsOfShape
code: instance (priority := 100) hasLimitOfHasLimitsOfShape {J : Type u₁} [Category.{v₁} J]
    [HasLimitsOfShape J C] (F : J ⥤ C) : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.hasLimitsOfShapeOfHasLimits
code: instance (priority := 100) hasLimitsOfShapeOfHasLimits {J : Type u₁} [Category.{v₁} J]
    [HasLimitsOfSize.{v₁, u₁} C] : HasLimitsOfShape J C 
goal: CategoryTheory.Limits.HasLimitsOfShape J C

full_name: CategoryTheory.Limits.limit.cone
code: /-- An arbitrary choice of limit cone for a functor. -/
def limit.cone (F : J ⥤ C) [HasLimit F] : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.limit
code: /-- An arbitrary choice of limit object of a functor. -/
def limit (F : J ⥤ C) [HasLimit F] 
goal: C

full_name: CategoryTheory.Limits.limit.π
code: /-- The projection from the limit object to a value of the functor. -/
def limit.π (F : J ⥤ C) [HasLimit F] (j : J) : limit F ⟶ F.obj j 
goal: CategoryTheory.Limits.limit F ⟶ F.obj j

full_name: CategoryTheory.Limits.limit.cone_x
code: @[simp]
theorem limit.cone_x {F : J ⥤ C} [HasLimit F] : (limit.cone F).pt = limit F 
goal: (CategoryTheory.Limits.limit.cone F).pt = CategoryTheory.Limits.limit F

full_name: CategoryTheory.Limits.limit.cone_π
code: @[simp]
theorem limit.cone_π {F : J ⥤ C} [HasLimit F] : (limit.cone F).π.app = limit.π _ 
goal: (CategoryTheory.Limits.limit.cone F).π.app = CategoryTheory.Limits.limit.π F

full_name: CategoryTheory.Limits.limit.w
code: @[reassoc (attr := simp)]
theorem limit.w (F : J ⥤ C) [HasLimit F] {j j' : J} (f : j ⟶ j') :
    limit.π F j ≫ F.map f = limit.π F j' 
goal: CategoryTheory.Limits.limit.π F j ≫ F.map f = CategoryTheory.Limits.limit.π F j'

full_name: CategoryTheory.Limits.limit.isLimit
code: /-- Evidence that the arbitrary choice of cone provided by `limit.cone F` is a limit cone. -/
def limit.isLimit (F : J ⥤ C) [HasLimit F] : IsLimit (limit.cone F) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.limit.cone F)

full_name: CategoryTheory.Limits.limit.lift
code: /-- The morphism from the cone point of any other cone to the limit object. -/
def limit.lift (F : J ⥤ C) [HasLimit F] (c : Cone F) : c.pt ⟶ limit F 
goal: c.pt ⟶ CategoryTheory.Limits.limit F

full_name: CategoryTheory.Limits.limit.isLimit_lift
code: @[simp]
theorem limit.isLimit_lift {F : J ⥤ C} [HasLimit F] (c : Cone F) :
    (limit.isLimit F).lift c = limit.lift F c 
goal: (CategoryTheory.Limits.limit.isLimit F).lift c = CategoryTheory.Limits.limit.lift F c

full_name: CategoryTheory.Limits.limit.lift_π
code: @[reassoc (attr := simp)]
theorem limit.lift_π {F : J ⥤ C} [HasLimit F] (c : Cone F) (j : J) :
    limit.lift F c ≫ limit.π F j = c.π.app j 
goal: CategoryTheory.Limits.limit.lift F c ≫ CategoryTheory.Limits.limit.π F j = c.π.app j

full_name: CategoryTheory.Limits.limMap
code: /-- Functoriality of limits.

Usually this morphism should be accessed through `lim.map`,
but may be needed separately when you have specified limits for the source and target functors,
but not necessarily for all functors of shape `J`.
-/
def limMap {F G : J ⥤ C} [HasLimit F] [HasLimit G] (α : F ⟶ G) : limit F ⟶ limit G 
goal: CategoryTheory.Limits.limit F ⟶ CategoryTheory.Limits.limit G

full_name: CategoryTheory.Limits.limMap_π
code: @[reassoc (attr := simp)]
theorem limMap_π {F G : J ⥤ C} [HasLimit F] [HasLimit G] (α : F ⟶ G) (j : J) :
    limMap α ≫ limit.π G j = limit.π F j ≫ α.app j 
goal: CategoryTheory.Limits.limMap α ≫ CategoryTheory.Limits.limit.π G j = CategoryTheory.Limits.limit.π F j ≫ α.app j

full_name: CategoryTheory.Limits.limit.coneMorphism
code: /-- The cone morphism from any cone to the arbitrary choice of limit cone. -/
def limit.coneMorphism {F : J ⥤ C} [HasLimit F] (c : Cone F) : c ⟶ limit.cone F 
goal: c ⟶ CategoryTheory.Limits.limit.cone F

full_name: CategoryTheory.Limits.limit.coneMorphism_hom
code: @[simp]
theorem limit.coneMorphism_hom {F : J ⥤ C} [HasLimit F] (c : Cone F) :
    (limit.coneMorphism c).hom = limit.lift F c 
goal: (CategoryTheory.Limits.limit.coneMorphism c).hom = CategoryTheory.Limits.limit.lift F c

full_name: CategoryTheory.Limits.limit.coneMorphism_π
code: theorem limit.coneMorphism_π {F : J ⥤ C} [HasLimit F] (c : Cone F) (j : J) :
    (limit.coneMorphism c).hom ≫ limit.π F j = c.π.app j 
goal: (CategoryTheory.Limits.limit.coneMorphism c).hom ≫ CategoryTheory.Limits.limit.π F j = c.π.app j

full_name: CategoryTheory.Limits.limit.conePointUniqueUpToIso_hom_comp
code: @[reassoc (attr := simp)]
theorem limit.conePointUniqueUpToIso_hom_comp {F : J ⥤ C} [HasLimit F] {c : Cone F} (hc : IsLimit c)
    (j : J) : (IsLimit.conePointUniqueUpToIso hc (limit.isLimit _)).hom ≫ limit.π F j = c.π.app j 
goal: (hc.conePointUniqueUpToIso (CategoryTheory.Limits.limit.isLimit F)).hom ≫ CategoryTheory.Limits.limit.π F j = c.π.app j

full_name: CategoryTheory.Limits.limit.conePointUniqueUpToIso_inv_comp
code: @[reassoc (attr := simp)]
theorem limit.conePointUniqueUpToIso_inv_comp {F : J ⥤ C} [HasLimit F] {c : Cone F} (hc : IsLimit c)
    (j : J) : (IsLimit.conePointUniqueUpToIso (limit.isLimit _) hc).inv ≫ limit.π F j = c.π.app j 
goal: ((CategoryTheory.Limits.limit.isLimit F).conePointUniqueUpToIso hc).inv ≫ CategoryTheory.Limits.limit.π F j = c.π.app j

full_name: CategoryTheory.Limits.limit.existsUnique
code: theorem limit.existsUnique {F : J ⥤ C} [HasLimit F] (t : Cone F) :
    ∃! l : t.pt ⟶ limit F, ∀ j, l ≫ limit.π F j = t.π.app j 
goal: ∃! l, ∀ (j : J), l ≫ CategoryTheory.Limits.limit.π F j = t.π.app j

full_name: CategoryTheory.Limits.limit.isoLimitCone
code: /-- Given any other limit cone for `F`, the chosen `limit F` is isomorphic to the cone point.
-/
def limit.isoLimitCone {F : J ⥤ C} [HasLimit F] (t : LimitCone F) : limit F ≅ t.cone.pt 
goal: CategoryTheory.Limits.limit F ≅ t.cone.pt

full_name: CategoryTheory.Limits.limit.isoLimitCone_hom_π
code: @[reassoc (attr := simp)]
theorem limit.isoLimitCone_hom_π {F : J ⥤ C} [HasLimit F] (t : LimitCone F) (j : J) :
    (limit.isoLimitCone t).hom ≫ t.cone.π.app j = limit.π F j 
goal: (CategoryTheory.Limits.limit.isoLimitCone t).hom ≫ t.cone.π.app j = CategoryTheory.Limits.limit.π F j

full_name: CategoryTheory.Limits.limit.isoLimitCone_inv_π
code: @[reassoc (attr := simp)]
theorem limit.isoLimitCone_inv_π {F : J ⥤ C} [HasLimit F] (t : LimitCone F) (j : J) :
    (limit.isoLimitCone t).inv ≫ limit.π F j = t.cone.π.app j 
goal: (CategoryTheory.Limits.limit.isoLimitCone t).inv ≫ CategoryTheory.Limits.limit.π F j = t.cone.π.app j

full_name: CategoryTheory.Limits.limit.hom_ext
code: @[ext]
theorem limit.hom_ext {F : J ⥤ C} [HasLimit F] {X : C} {f f' : X ⟶ limit F}
    (w : ∀ j, f ≫ limit.π F j = f' ≫ limit.π F j) : f = f' 
goal: f = f'

full_name: CategoryTheory.Limits.limit.lift_map
code: @[simp]
theorem limit.lift_map {F G : J ⥤ C} [HasLimit F] [HasLimit G] (c : Cone F) (α : F ⟶ G) :
    limit.lift F c ≫ limMap α = limit.lift G ((Cones.postcompose α).obj c) 
goal: CategoryTheory.Limits.limit.lift F c ≫ CategoryTheory.Limits.limMap α =
  CategoryTheory.Limits.limit.lift G ((CategoryTheory.Limits.Cones.postcompose α).obj c)

full_name: CategoryTheory.Limits.limit.lift_cone
code: @[simp]
theorem limit.lift_cone {F : J ⥤ C} [HasLimit F] : limit.lift F (limit.cone F) = 𝟙 (limit F) 
goal: CategoryTheory.Limits.limit.lift F (CategoryTheory.Limits.limit.cone F) = 𝟙 (CategoryTheory.Limits.limit F)

full_name: CategoryTheory.Limits.limit.homIso
code: /-- The isomorphism (in `Type`) between
morphisms from a specified object `W` to the limit object,
and cones with cone point `W`.
-/
def limit.homIso (F : J ⥤ C) [HasLimit F] (W : C) :
    ULift.{u₁} (W ⟶ limit F : Type v) ≅ F.cones.obj (op W) 
goal: ULift.{u₁, v} (W ⟶ CategoryTheory.Limits.limit F) ≅ F.cones.obj (Opposite.op W)

full_name: CategoryTheory.Limits.limit.homIso_hom
code: @[simp]
theorem limit.homIso_hom (F : J ⥤ C) [HasLimit F] {W : C} (f : ULift (W ⟶ limit F)) :
    (limit.homIso F W).hom f = (const J).map f.down ≫ (limit.cone F).π 
goal: (CategoryTheory.Limits.limit.homIso F W).hom f =
  (CategoryTheory.Functor.const J).map f.down ≫ (CategoryTheory.Limits.limit.cone F).π

full_name: CategoryTheory.Limits.limit.homIso'
code: /-- The isomorphism (in `Type`) between
morphisms from a specified object `W` to the limit object,
and an explicit componentwise description of cones with cone point `W`.
-/
def limit.homIso' (F : J ⥤ C) [HasLimit F] (W : C) :
    ULift.{u₁} (W ⟶ limit F : Type v) ≅
      { p : ∀ j, W ⟶ F.obj j // ∀ {j j' : J} (f : j ⟶ j'), p j ≫ F.map f = p j' } 
goal: ULift.{u₁, v} (W ⟶ CategoryTheory.Limits.limit F) ≅ { p // ∀ {j j' : J} (f : j ⟶ j'), p j ≫ F.map f = p j' }

full_name: CategoryTheory.Limits.limit.lift_extend
code: theorem limit.lift_extend {F : J ⥤ C} [HasLimit F] (c : Cone F) {X : C} (f : X ⟶ c.pt) :
    limit.lift F (c.extend f) = f ≫ limit.lift F c 
goal: CategoryTheory.Limits.limit.lift F (c.extend f) = f ≫ CategoryTheory.Limits.limit.lift F c

full_name: CategoryTheory.Limits.hasLimitOfIso
code: /-- If a functor `F` has a limit, so does any naturally isomorphic functor.
-/
theorem hasLimitOfIso {F G : J ⥤ C} [HasLimit F] (α : F ≅ G) : HasLimit G 
goal: CategoryTheory.Limits.HasLimit G

full_name: CategoryTheory.Limits.HasLimit.ofConesIso
code: /-- If a functor `G` has the same collection of cones as a functor `F`
which has a limit, then `G` also has a limit. -/
theorem HasLimit.ofConesIso {J K : Type u₁} [Category.{v₁} J] [Category.{v₂} K] (F : J ⥤ C)
    (G : K ⥤ C) (h : F.cones ≅ G.cones) [HasLimit F] : HasLimit G 
goal: CategoryTheory.Limits.HasLimit G

full_name: CategoryTheory.Limits.HasLimit.isoOfNatIso
code: /-- The limits of `F : J ⥤ C` and `G : J ⥤ C` are isomorphic,
if the functors are naturally isomorphic.
-/
def HasLimit.isoOfNatIso {F G : J ⥤ C} [HasLimit F] [HasLimit G] (w : F ≅ G) : limit F ≅ limit G 
goal: CategoryTheory.Limits.limit F ≅ CategoryTheory.Limits.limit G

full_name: CategoryTheory.Limits.HasLimit.isoOfNatIso_hom_π
code: @[reassoc (attr := simp)]
theorem HasLimit.isoOfNatIso_hom_π {F G : J ⥤ C} [HasLimit F] [HasLimit G] (w : F ≅ G) (j : J) :
    (HasLimit.isoOfNatIso w).hom ≫ limit.π G j = limit.π F j ≫ w.hom.app j 
goal: (CategoryTheory.Limits.HasLimit.isoOfNatIso w).hom ≫ CategoryTheory.Limits.limit.π G j =
  CategoryTheory.Limits.limit.π F j ≫ w.hom.app j

full_name: CategoryTheory.Limits.HasLimit.isoOfNatIso_inv_π
code: @[reassoc (attr := simp)]
theorem HasLimit.isoOfNatIso_inv_π {F G : J ⥤ C} [HasLimit F] [HasLimit G] (w : F ≅ G) (j : J) :
    (HasLimit.isoOfNatIso w).inv ≫ limit.π F j = limit.π G j ≫ w.inv.app j 
goal: (CategoryTheory.Limits.HasLimit.isoOfNatIso w).inv ≫ CategoryTheory.Limits.limit.π F j =
  CategoryTheory.Limits.limit.π G j ≫ w.inv.app j

full_name: CategoryTheory.Limits.HasLimit.lift_isoOfNatIso_hom
code: @[reassoc (attr := simp)]
theorem HasLimit.lift_isoOfNatIso_hom {F G : J ⥤ C} [HasLimit F] [HasLimit G] (t : Cone F)
    (w : F ≅ G) :
    limit.lift F t ≫ (HasLimit.isoOfNatIso w).hom =
      limit.lift G ((Cones.postcompose w.hom).obj _) 
goal: CategoryTheory.Limits.limit.lift F t ≫ (CategoryTheory.Limits.HasLimit.isoOfNatIso w).hom =
  CategoryTheory.Limits.limit.lift G ((CategoryTheory.Limits.Cones.postcompose w.hom).obj t)

full_name: CategoryTheory.Limits.HasLimit.lift_isoOfNatIso_inv
code: @[reassoc (attr := simp)]
theorem HasLimit.lift_isoOfNatIso_inv {F G : J ⥤ C} [HasLimit F] [HasLimit G] (t : Cone G)
    (w : F ≅ G) :
    limit.lift G t ≫ (HasLimit.isoOfNatIso w).inv =
      limit.lift F ((Cones.postcompose w.inv).obj _) 
goal: CategoryTheory.Limits.limit.lift G t ≫ (CategoryTheory.Limits.HasLimit.isoOfNatIso w).inv =
  CategoryTheory.Limits.limit.lift F ((CategoryTheory.Limits.Cones.postcompose w.inv).obj t)

full_name: CategoryTheory.Limits.HasLimit.isoOfEquivalence
code: /-- The limits of `F : J ⥤ C` and `G : K ⥤ C` are isomorphic,
if there is an equivalence `e : J ≌ K` making the triangle commute up to natural isomorphism.
-/
def HasLimit.isoOfEquivalence {F : J ⥤ C} [HasLimit F] {G : K ⥤ C} [HasLimit G] (e : J ≌ K)
    (w : e.functor ⋙ G ≅ F) : limit F ≅ limit G 
goal: CategoryTheory.Limits.limit F ≅ CategoryTheory.Limits.limit G

full_name: CategoryTheory.Limits.HasLimit.isoOfEquivalence_hom_π
code: @[simp]
theorem HasLimit.isoOfEquivalence_hom_π {F : J ⥤ C} [HasLimit F] {G : K ⥤ C} [HasLimit G]
    (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (k : K) :
    (HasLimit.isoOfEquivalence e w).hom ≫ limit.π G k =
      limit.π F (e.inverse.obj k) ≫ w.inv.app (e.inverse.obj k) ≫ G.map (e.counit.app k) 
goal: (CategoryTheory.Limits.HasLimit.isoOfEquivalence e w).hom ≫ CategoryTheory.Limits.limit.π G k =
  CategoryTheory.Limits.limit.π F (e.inverse.obj k) ≫ w.inv.app (e.inverse.obj k) ≫ G.map (e.counit.app k)

full_name: CategoryTheory.Limits.HasLimit.isoOfEquivalence_inv_π
code: @[simp]
theorem HasLimit.isoOfEquivalence_inv_π {F : J ⥤ C} [HasLimit F] {G : K ⥤ C} [HasLimit G]
    (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (j : J) :
    (HasLimit.isoOfEquivalence e w).inv ≫ limit.π F j =
    limit.π G (e.functor.obj j) ≫ w.hom.app j 
goal: (CategoryTheory.Limits.HasLimit.isoOfEquivalence e w).inv ≫ CategoryTheory.Limits.limit.π F j =
  CategoryTheory.Limits.limit.π G (e.functor.obj j) ≫ w.hom.app j

full_name: CategoryTheory.Limits.limit.pre
code: /-- The canonical morphism from the limit of `F` to the limit of `E ⋙ F`.
-/
def limit.pre : limit F ⟶ limit (E ⋙ F) 
goal: CategoryTheory.Limits.limit F ⟶ CategoryTheory.Limits.limit (E ⋙ F)

full_name: CategoryTheory.Limits.limit.pre_π
code: @[reassoc (attr := simp)]
theorem limit.pre_π (k : K) : limit.pre F E ≫ limit.π (E ⋙ F) k = limit.π F (E.obj k) 
goal: CategoryTheory.Limits.limit.pre F E ≫ CategoryTheory.Limits.limit.π (E ⋙ F) k =
  CategoryTheory.Limits.limit.π F (E.obj k)

full_name: CategoryTheory.Limits.limit.lift_pre
code: @[simp]
theorem limit.lift_pre (c : Cone F) :
    limit.lift F c ≫ limit.pre F E = limit.lift (E ⋙ F) (c.whisker E) 
goal: CategoryTheory.Limits.limit.lift F c ≫ CategoryTheory.Limits.limit.pre F E =
  CategoryTheory.Limits.limit.lift (E ⋙ F) (CategoryTheory.Limits.Cone.whisker E c)

full_name: CategoryTheory.Limits.limit.pre_pre
code: @[simp]
theorem limit.pre_pre [h : HasLimit (D ⋙ E ⋙ F)] : haveI : HasLimit ((D ⋙ E) ⋙ F) := h
    limit.pre F E ≫ limit.pre (E ⋙ F) D = limit.pre F (D ⋙ E) 
goal: CategoryTheory.Limits.limit.pre F E ≫ CategoryTheory.Limits.limit.pre (E ⋙ F) D =
  CategoryTheory.Limits.limit.pre F (D ⋙ E)

full_name: CategoryTheory.Limits.limit.pre_eq
code: /-- -
If we have particular limit cones available for `E ⋙ F` and for `F`,
we obtain a formula for `limit.pre F E`.
-/
theorem limit.pre_eq (s : LimitCone (E ⋙ F)) (t : LimitCone F) :
    limit.pre F E = (limit.isoLimitCone t).hom ≫ s.isLimit.lift (t.cone.whisker E) ≫
      (limit.isoLimitCone s).inv 
goal: CategoryTheory.Limits.limit.pre F E =
  (CategoryTheory.Limits.limit.isoLimitCone t).hom ≫
    s.isLimit.lift (CategoryTheory.Limits.Cone.whisker E t.cone) ≫ (CategoryTheory.Limits.limit.isoLimitCone s).inv

full_name: CategoryTheory.Limits.limit.post
code: /-- The canonical morphism from `G` applied to the limit of `F` to the limit of `F ⋙ G`.
-/
def limit.post : G.obj (limit F) ⟶ limit (F ⋙ G) 
goal: G.obj (CategoryTheory.Limits.limit F) ⟶ CategoryTheory.Limits.limit (F ⋙ G)

full_name: CategoryTheory.Limits.limit.post_π
code: @[reassoc (attr := simp)]
theorem limit.post_π (j : J) : limit.post F G ≫ limit.π (F ⋙ G) j = G.map (limit.π F j) 
goal: CategoryTheory.Limits.limit.post F G ≫ CategoryTheory.Limits.limit.π (F ⋙ G) j =
  G.map (CategoryTheory.Limits.limit.π F j)

full_name: CategoryTheory.Limits.limit.lift_post
code: @[simp]
theorem limit.lift_post (c : Cone F) :
    G.map (limit.lift F c) ≫ limit.post F G = limit.lift (F ⋙ G) (G.mapCone c) 
goal: G.map (CategoryTheory.Limits.limit.lift F c) ≫ CategoryTheory.Limits.limit.post F G =
  CategoryTheory.Limits.limit.lift (F ⋙ G) (G.mapCone c)

full_name: CategoryTheory.Limits.limit.post_post
code: @[simp]
theorem limit.post_post {E : Type u''} [Category.{v''} E] (H : D ⥤ E) [h : HasLimit ((F ⋙ G) ⋙ H)] :
    -- H G (limit F) ⟶ H (limit (F ⋙ G)) ⟶ limit ((F ⋙ G) ⋙ H) equals
    -- H G (limit F) ⟶ limit (F ⋙ (G ⋙ H))
    haveI : HasLimit (F ⋙ G ⋙ H) := h
    H.map (limit.post F G) ≫ limit.post (F ⋙ G) H = limit.post F (G ⋙ H) 
goal: H.map (CategoryTheory.Limits.limit.post F G) ≫ CategoryTheory.Limits.limit.post (F ⋙ G) H =
  CategoryTheory.Limits.limit.post F (G ⋙ H)

full_name: CategoryTheory.Limits.limit.pre_post
code: theorem limit.pre_post {D : Type u'} [Category.{v'} D] (E : K ⥤ J) (F : J ⥤ C) (G : C ⥤ D)
    [HasLimit F] [HasLimit (E ⋙ F)] [HasLimit (F ⋙ G)]
    [h : HasLimit ((E ⋙ F) ⋙ G)] :-- G (limit F) ⟶ G (limit (E ⋙ F)) ⟶ limit ((E ⋙ F) ⋙ G) vs
            -- G (limit F) ⟶ limit F ⋙ G ⟶ limit (E ⋙ (F ⋙ G)) or
    haveI : HasLimit (E ⋙ F ⋙ G) := h
    G.map (limit.pre F E) ≫ limit.post (E ⋙ F) G = limit.post F G ≫ limit.pre (F ⋙ G) E 
goal: G.map (CategoryTheory.Limits.limit.pre F E) ≫ CategoryTheory.Limits.limit.post (E ⋙ F) G =
  CategoryTheory.Limits.limit.post F G ≫ CategoryTheory.Limits.limit.pre (F ⋙ G) E

full_name: CategoryTheory.Limits.hasLimitEquivalenceComp
code: instance hasLimitEquivalenceComp (e : K ≌ J) [HasLimit F] : HasLimit (e.functor ⋙ F) 
goal: CategoryTheory.Limits.HasLimit (e.functor ⋙ F)

full_name: CategoryTheory.Limits.hasLimitOfEquivalenceComp
code: /-- If a `E ⋙ F` has a limit, and `E` is an equivalence, we can construct a limit of `F`.
-/
theorem hasLimitOfEquivalenceComp (e : K ≌ J) [HasLimit (e.functor ⋙ F)] : HasLimit F 
goal: CategoryTheory.Limits.HasLimit F

full_name: CategoryTheory.Limits.lim_map
code: /-- `limit F` is functorial in `F`, when `C` has all limits of shape `J`. -/
@[simps]
def lim : (J ⥤ C) ⥤ C 
goal: ∀ {X Y : J ⥤ C} (α : X ⟶ Y), CategoryTheory.Limits.lim.map α = CategoryTheory.Limits.limMap α

full_name: CategoryTheory.Limits.lim_obj
code: /-- `limit F` is functorial in `F`, when `C` has all limits of shape `J`. -/
@[simps]
def lim : (J ⥤ C) ⥤ C 
goal: CategoryTheory.Limits.lim.obj F = CategoryTheory.Limits.limit F

full_name: CategoryTheory.Limits.lim
code: /-- `limit F` is functorial in `F`, when `C` has all limits of shape `J`. -/
@[simps]
def lim : (J ⥤ C) ⥤ C 
goal: (J ⥤ C) ⥤ C

full_name: CategoryTheory.Limits.limit.map_pre
code: theorem limit.map_pre [HasLimitsOfShape K C] (E : K ⥤ J) :
    lim.map α ≫ limit.pre G E = limit.pre F E ≫ lim.map (whiskerLeft E α) 
goal: CategoryTheory.Limits.lim.map α ≫ CategoryTheory.Limits.limit.pre G E =
  CategoryTheory.Limits.limit.pre F E ≫ CategoryTheory.Limits.lim.map (CategoryTheory.whiskerLeft E α)

full_name: CategoryTheory.Limits.limit.map_pre'
code: theorem limit.map_pre' [HasLimitsOfShape K C] (F : J ⥤ C) {E₁ E₂ : K ⥤ J} (α : E₁ ⟶ E₂) :
    limit.pre F E₂ = limit.pre F E₁ ≫ lim.map (whiskerRight α F) 
goal: CategoryTheory.Limits.limit.pre F E₂ =
  CategoryTheory.Limits.limit.pre F E₁ ≫ CategoryTheory.Limits.lim.map (CategoryTheory.whiskerRight α F)

full_name: CategoryTheory.Limits.limit.id_pre
code: theorem limit.id_pre (F : J ⥤ C) : limit.pre F (𝟭 _) = lim.map (Functor.leftUnitor F).inv 
goal: CategoryTheory.Limits.limit.pre F (𝟭 J) = CategoryTheory.Limits.lim.map F.leftUnitor.inv

full_name: CategoryTheory.Limits.limit.map_post
code: theorem limit.map_post {D : Type u'} [Category.{v'} D] [HasLimitsOfShape J D] (H : C ⥤ D) :
    /- H (limit F) ⟶ H (limit G) ⟶ limit (G ⋙ H) vs
     H (limit F) ⟶ limit (F ⋙ H) ⟶ limit (G ⋙ H) -/
    H.map (limMap α) ≫ limit.post G H = limit.post F H ≫ limMap (whiskerRight α H) 
goal: H.map (CategoryTheory.Limits.limMap α) ≫ CategoryTheory.Limits.limit.post G H =
  CategoryTheory.Limits.limit.post F H ≫ CategoryTheory.Limits.limMap (CategoryTheory.whiskerRight α H)

full_name: CategoryTheory.Limits.limYoneda
code: /-- The isomorphism between
morphisms from `W` to the cone point of the limit cone for `F`
and cones over `F` with cone point `W`
is natural in `F`.
-/
def limYoneda :
    lim ⋙ yoneda ⋙ (whiskeringRight _ _ _).obj uliftFunctor.{u₁} ≅ CategoryTheory.cones J C 
goal: CategoryTheory.Limits.lim ⋙
    CategoryTheory.yoneda ⋙
      (CategoryTheory.whiskeringRight Cᵒᵖ (Type v) (Type (max v u₁))).obj CategoryTheory.uliftFunctor.{u₁, v} ≅
  CategoryTheory.cones J C

full_name: CategoryTheory.Limits.constLimAdj
code: /-- The constant functor and limit functor are adjoint to each other-/
def constLimAdj : (const J : C ⥤ J ⥤ C) ⊣ lim 
goal: CategoryTheory.Functor.const J ⊣ CategoryTheory.Limits.lim

full_name: CategoryTheory.Limits.instIsRightAdjointFunctorLim
code: instance : IsRightAdjoint (lim : (J ⥤ C) ⥤ C) 
goal: CategoryTheory.Limits.lim.IsRightAdjoint

full_name: CategoryTheory.Limits.limMap_mono'
code: instance limMap_mono' {F G : J ⥤ C} [HasLimitsOfShape J C] (α : F ⟶ G) [Mono α] : Mono (limMap α) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.limMap α)

full_name: CategoryTheory.Limits.limMap_mono
code: instance limMap_mono {F G : J ⥤ C} [HasLimit F] [HasLimit G] (α : F ⟶ G) [∀ j, Mono (α.app j)] :
    Mono (limMap α) 
goal: CategoryTheory.Mono (CategoryTheory.Limits.limMap α)

full_name: CategoryTheory.Limits.coneOfAdj
code: /-- The limit cone obtained from a right adjoint of the constant functor. -/
@[simps]
noncomputable def coneOfAdj (F : J ⥤ C) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.coneOfAdj_pt
code: /-- The limit cone obtained from a right adjoint of the constant functor. -/
@[simps]
noncomputable def coneOfAdj (F : J ⥤ C) : Cone F 
goal: (CategoryTheory.Limits.coneOfAdj adj F).pt = L.obj F

full_name: CategoryTheory.Limits.coneOfAdj_π
code: /-- The limit cone obtained from a right adjoint of the constant functor. -/
@[simps]
noncomputable def coneOfAdj (F : J ⥤ C) : Cone F 
goal: (CategoryTheory.Limits.coneOfAdj adj F).π = adj.counit.app F

full_name: CategoryTheory.Limits.isLimitConeOfAdj
code: /-- The cones defined by `coneOfAdj` are limit cones. -/
@[simps]
def isLimitConeOfAdj (F : J ⥤ C) :
    IsLimit (coneOfAdj adj F) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfAdj adj F)

full_name: CategoryTheory.Limits.isLimitConeOfAdj_lift
code: /-- The cones defined by `coneOfAdj` are limit cones. -/
@[simps]
def isLimitConeOfAdj (F : J ⥤ C) :
    IsLimit (coneOfAdj adj F) 
goal: (CategoryTheory.Limits.isLimitConeOfAdj adj F).lift s = (adj.homEquiv s.pt F) s.π

full_name: CategoryTheory.Limits.hasLimitsOfShape_of_equivalence
code: /-- We can transport limits of shape `J` along an equivalence `J ≌ J'`.
-/
theorem hasLimitsOfShape_of_equivalence {J' : Type u₂} [Category.{v₂} J'] (e : J ≌ J')
    [HasLimitsOfShape J C] : HasLimitsOfShape J' C 
goal: CategoryTheory.Limits.HasLimitsOfShape J' C

full_name: CategoryTheory.Limits.hasLimitsOfSizeOfUnivLE
code: /-- A category that has larger limits also has smaller limits. -/
theorem hasLimitsOfSizeOfUnivLE [UnivLE.{v₂, v₁}] [UnivLE.{u₂, u₁}]
    [HasLimitsOfSize.{v₁, u₁} C] : HasLimitsOfSize.{v₂, u₂} C 
goal: CategoryTheory.Limits.HasLimitsOfSize.{v₂, u₂, v, u} C

full_name: CategoryTheory.Limits.hasLimitsOfSizeShrink
code: /-- `hasLimitsOfSizeShrink.{v u} C` tries to obtain `HasLimitsOfSize.{v u} C`
from some other `HasLimitsOfSize C`.
-/
theorem hasLimitsOfSizeShrink [HasLimitsOfSize.{max v₁ v₂, max u₁ u₂} C] :
    HasLimitsOfSize.{v₁, u₁} C 
goal: CategoryTheory.Limits.HasLimitsOfSize.{v₁, u₁, v, u} C

full_name: CategoryTheory.Limits.hasSmallestLimitsOfHasLimits
code: instance (priority := 100) hasSmallestLimitsOfHasLimits [HasLimits C] : HasLimitsOfSize.{0, 0} C 
goal: CategoryTheory.Limits.HasLimitsOfSize.{0, 0, v, u} C

full_name: CategoryTheory.Limits.ColimitCocone.cocone
code: /-- `ColimitCocone F` contains a cocone over `F` together with the information that it is a
    colimit. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): removed; linter not ported yet
structure ColimitCocone (F : J ⥤ C) where
  /-- The cocone itself -/
  cocone : Cocone F
  /-- The proof that it is the colimit cocone -/
  isColimit : IsColimit cocone
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.ColimitCocone.isColimit
code: /-- `ColimitCocone F` contains a cocone over `F` together with the information that it is a
    colimit. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): removed; linter not ported yet
structure ColimitCocone (F : J ⥤ C) where
  /-- The cocone itself -/
  cocone : Cocone F
  /-- The proof that it is the colimit cocone -/
  isColimit : IsColimit cocone
goal: CategoryTheory.Limits.IsColimit self.cocone

full_name: CategoryTheory.Limits.ColimitCocone
code: /-- `ColimitCocone F` contains a cocone over `F` together with the information that it is a
    colimit. -/
-- @[nolint has_nonempty_instance] -- Porting note(#5171): removed; linter not ported yet
structure ColimitCocone (F : J ⥤ C) where
  /-- The cocone itself -/
  cocone : Cocone F
  /-- The proof that it is the colimit cocone -/
  isColimit : IsColimit cocone
goal: Type (max (max u u₁) v)

full_name: CategoryTheory.Limits.HasColimit.exists_colimit
code: /-- `HasColimit F` represents the mere existence of a colimit for `F`. -/
class HasColimit (F : J ⥤ C) : Prop where mk' ::
  /-- There exists a colimit for `F` -/
  exists_colimit : Nonempty (ColimitCocone F)
goal: Nonempty (CategoryTheory.Limits.ColimitCocone F)

full_name: CategoryTheory.Limits.HasColimit.mk'
code: /-- `HasColimit F` represents the mere existence of a colimit for `F`. -/
class HasColimit (F : J ⥤ C) : Prop where mk' ::
  /-- There exists a colimit for `F` -/
  exists_colimit : Nonempty (ColimitCocone F)
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.HasColimit
code: /-- `HasColimit F` represents the mere existence of a colimit for `F`. -/
class HasColimit (F : J ⥤ C) : Prop where mk' ::
  /-- There exists a colimit for `F` -/
  exists_colimit : Nonempty (ColimitCocone F)
goal: Prop

full_name: CategoryTheory.Limits.HasColimit.mk
code: theorem HasColimit.mk {F : J ⥤ C} (d : ColimitCocone F) : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.getColimitCocone
code: /-- Use the axiom of choice to extract explicit `ColimitCocone F` from `HasColimit F`. -/
def getColimitCocone (F : J ⥤ C) [HasColimit F] : ColimitCocone F 
goal: CategoryTheory.Limits.ColimitCocone F

full_name: CategoryTheory.Limits.HasColimitsOfShape.has_colimit
code: /-- `C` has colimits of shape `J` if there exists a colimit for every functor `F : J ⥤ C`. -/
class HasColimitsOfShape : Prop where
  /-- All `F : J ⥤ C` have colimits for a fixed `J` -/
  has_colimit : ∀ F : J ⥤ C, HasColimit F := by infer_instance
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.HasColimitsOfShape
code: /-- `C` has colimits of shape `J` if there exists a colimit for every functor `F : J ⥤ C`. -/
class HasColimitsOfShape : Prop where
  /-- All `F : J ⥤ C` have colimits for a fixed `J` -/
  has_colimit : ∀ F : J ⥤ C, HasColimit F := by infer_instance
goal: Prop

full_name: CategoryTheory.Limits.HasColimitsOfSize.has_colimits_of_shape
code: /-- `C` has all colimits of size `v₁ u₁` (`HasColimitsOfSize.{v₁ u₁} C`)
if it has colimits of every shape `J : Type u₁` with `[Category.{v₁} J]`.
-/
@[pp_with_univ]
class HasColimitsOfSize (C : Type u) [Category.{v} C] : Prop where
  /-- All `F : J ⥤ C` have colimits for all small `J` -/
  has_colimits_of_shape : ∀ (J : Type u₁) [Category.{v₁} J], HasColimitsOfShape J C := by
    infer_instance
goal: CategoryTheory.Limits.HasColimitsOfShape J C

full_name: CategoryTheory.Limits.HasColimitsOfSize
code: /-- `C` has all colimits of size `v₁ u₁` (`HasColimitsOfSize.{v₁ u₁} C`)
if it has colimits of every shape `J : Type u₁` with `[Category.{v₁} J]`.
-/
@[pp_with_univ]
class HasColimitsOfSize (C : Type u) [Category.{v} C] : Prop where
  /-- All `F : J ⥤ C` have colimits for all small `J` -/
  has_colimits_of_shape : ∀ (J : Type u₁) [Category.{v₁} J], HasColimitsOfShape J C := by
    infer_instance
goal: Prop

full_name: CategoryTheory.Limits.HasColimits
code: /-- `C` has all (small) colimits if it has colimits of every shape that is as big as its hom-sets.
-/
abbrev HasColimits (C : Type u) [Category.{v} C] : Prop 
goal: Prop

full_name: CategoryTheory.Limits.HasColimits.hasColimitsOfShape
code: theorem HasColimits.hasColimitsOfShape {C : Type u} [Category.{v} C] [HasColimits C] (J : Type v)
    [Category.{v} J] : HasColimitsOfShape J C 
goal: CategoryTheory.Limits.HasColimitsOfShape J C

full_name: CategoryTheory.Limits.hasColimitOfHasColimitsOfShape
code: instance (priority := 100) hasColimitOfHasColimitsOfShape {J : Type u₁} [Category.{v₁} J]
    [HasColimitsOfShape J C] (F : J ⥤ C) : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.hasColimitsOfShapeOfHasColimitsOfSize
code: instance (priority := 100) hasColimitsOfShapeOfHasColimitsOfSize {J : Type u₁} [Category.{v₁} J]
    [HasColimitsOfSize.{v₁, u₁} C] : HasColimitsOfShape J C 
goal: CategoryTheory.Limits.HasColimitsOfShape J C

full_name: CategoryTheory.Limits.colimit.cocone
code: /-- An arbitrary choice of colimit cocone of a functor. -/
def colimit.cocone (F : J ⥤ C) [HasColimit F] : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.colimit
code: /-- An arbitrary choice of colimit object of a functor. -/
def colimit (F : J ⥤ C) [HasColimit F] 
goal: C

full_name: CategoryTheory.Limits.colimit.ι
code: /-- The coprojection from a value of the functor to the colimit object. -/
def colimit.ι (F : J ⥤ C) [HasColimit F] (j : J) : F.obj j ⟶ colimit F 
goal: F.obj j ⟶ CategoryTheory.Limits.colimit F

full_name: CategoryTheory.Limits.colimit.cocone_ι
code: @[simp]
theorem colimit.cocone_ι {F : J ⥤ C} [HasColimit F] (j : J) :
    (colimit.cocone F).ι.app j = colimit.ι _ j 
goal: (CategoryTheory.Limits.colimit.cocone F).ι.app j = CategoryTheory.Limits.colimit.ι F j

full_name: CategoryTheory.Limits.colimit.cocone_x
code: @[simp]
theorem colimit.cocone_x {F : J ⥤ C} [HasColimit F] : (colimit.cocone F).pt = colimit F 
goal: (CategoryTheory.Limits.colimit.cocone F).pt = CategoryTheory.Limits.colimit F

full_name: CategoryTheory.Limits.colimit.w
code: @[reassoc (attr := simp)]
theorem colimit.w (F : J ⥤ C) [HasColimit F] {j j' : J} (f : j ⟶ j') :
    F.map f ≫ colimit.ι F j' = colimit.ι F j 
goal: F.map f ≫ CategoryTheory.Limits.colimit.ι F j' = CategoryTheory.Limits.colimit.ι F j

full_name: CategoryTheory.Limits.colimit.isColimit
code: /-- Evidence that the arbitrary choice of cocone is a colimit cocone. -/
def colimit.isColimit (F : J ⥤ C) [HasColimit F] : IsColimit (colimit.cocone F) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.colimit.cocone F)

full_name: CategoryTheory.Limits.colimit.desc
code: /-- The morphism from the colimit object to the cone point of any other cocone. -/
def colimit.desc (F : J ⥤ C) [HasColimit F] (c : Cocone F) : colimit F ⟶ c.pt 
goal: CategoryTheory.Limits.colimit F ⟶ c.pt

full_name: CategoryTheory.Limits.colimit.isColimit_desc
code: @[simp]
theorem colimit.isColimit_desc {F : J ⥤ C} [HasColimit F] (c : Cocone F) :
    (colimit.isColimit F).desc c = colimit.desc F c 
goal: (CategoryTheory.Limits.colimit.isColimit F).desc c = CategoryTheory.Limits.colimit.desc F c

full_name: CategoryTheory.Limits.colimit.ι_desc
code: /-- We have lots of lemmas describing how to simplify `colimit.ι F j ≫ _`,
and combined with `colimit.ext` we rely on these lemmas for many calculations.

However, since `Category.assoc` is a `@[simp]` lemma, often expressions are
right associated, and it's hard to apply these lemmas about `colimit.ι`.

We thus use `reassoc` to define additional `@[simp]` lemmas, with an arbitrary extra morphism.
(see `Tactic/reassoc_axiom.lean`)
 -/
@[reassoc (attr := simp)]
theorem colimit.ι_desc {F : J ⥤ C} [HasColimit F] (c : Cocone F) (j : J) :
    colimit.ι F j ≫ colimit.desc F c = c.ι.app j 
goal: CategoryTheory.Limits.colimit.ι F j ≫ CategoryTheory.Limits.colimit.desc F c = c.ι.app j

full_name: CategoryTheory.Limits.colimMap
code: /-- Functoriality of colimits.

Usually this morphism should be accessed through `colim.map`,
but may be needed separately when you have specified colimits for the source and target functors,
but not necessarily for all functors of shape `J`.
-/
def colimMap {F G : J ⥤ C} [HasColimit F] [HasColimit G] (α : F ⟶ G) : colimit F ⟶ colimit G 
goal: CategoryTheory.Limits.colimit F ⟶ CategoryTheory.Limits.colimit G

full_name: CategoryTheory.Limits.ι_colimMap
code: @[reassoc (attr := simp)]
theorem ι_colimMap {F G : J ⥤ C} [HasColimit F] [HasColimit G] (α : F ⟶ G) (j : J) :
    colimit.ι F j ≫ colimMap α = α.app j ≫ colimit.ι G j 
goal: CategoryTheory.Limits.colimit.ι F j ≫ CategoryTheory.Limits.colimMap α = α.app j ≫ CategoryTheory.Limits.colimit.ι G j

full_name: CategoryTheory.Limits.colimit.coconeMorphism
code: /-- The cocone morphism from the arbitrary choice of colimit cocone to any cocone. -/
def colimit.coconeMorphism {F : J ⥤ C} [HasColimit F] (c : Cocone F) : colimit.cocone F ⟶ c 
goal: CategoryTheory.Limits.colimit.cocone F ⟶ c

full_name: CategoryTheory.Limits.colimit.coconeMorphism_hom
code: @[simp]
theorem colimit.coconeMorphism_hom {F : J ⥤ C} [HasColimit F] (c : Cocone F) :
    (colimit.coconeMorphism c).hom = colimit.desc F c 
goal: (CategoryTheory.Limits.colimit.coconeMorphism c).hom = CategoryTheory.Limits.colimit.desc F c

full_name: CategoryTheory.Limits.colimit.ι_coconeMorphism
code: theorem colimit.ι_coconeMorphism {F : J ⥤ C} [HasColimit F] (c : Cocone F) (j : J) :
    colimit.ι F j ≫ (colimit.coconeMorphism c).hom = c.ι.app j 
goal: CategoryTheory.Limits.colimit.ι F j ≫ (CategoryTheory.Limits.colimit.coconeMorphism c).hom = c.ι.app j

full_name: CategoryTheory.Limits.colimit.comp_coconePointUniqueUpToIso_hom
code: @[reassoc (attr := simp)]
theorem colimit.comp_coconePointUniqueUpToIso_hom {F : J ⥤ C} [HasColimit F] {c : Cocone F}
    (hc : IsColimit c) (j : J) :
    colimit.ι F j ≫ (IsColimit.coconePointUniqueUpToIso (colimit.isColimit _) hc).hom = c.ι.app j 
goal: CategoryTheory.Limits.colimit.ι F j ≫ ((CategoryTheory.Limits.colimit.isColimit F).coconePointUniqueUpToIso hc).hom =
  c.ι.app j

full_name: CategoryTheory.Limits.colimit.comp_coconePointUniqueUpToIso_inv
code: @[reassoc (attr := simp)]
theorem colimit.comp_coconePointUniqueUpToIso_inv {F : J ⥤ C} [HasColimit F] {c : Cocone F}
    (hc : IsColimit c) (j : J) :
    colimit.ι F j ≫ (IsColimit.coconePointUniqueUpToIso hc (colimit.isColimit _)).inv = c.ι.app j 
goal: CategoryTheory.Limits.colimit.ι F j ≫ (hc.coconePointUniqueUpToIso (CategoryTheory.Limits.colimit.isColimit F)).inv =
  c.ι.app j

full_name: CategoryTheory.Limits.colimit.existsUnique
code: theorem colimit.existsUnique {F : J ⥤ C} [HasColimit F] (t : Cocone F) :
    ∃! d : colimit F ⟶ t.pt, ∀ j, colimit.ι F j ≫ d = t.ι.app j 
goal: ∃! d, ∀ (j : J), CategoryTheory.Limits.colimit.ι F j ≫ d = t.ι.app j

full_name: CategoryTheory.Limits.colimit.isoColimitCocone
code: /--
Given any other colimit cocone for `F`, the chosen `colimit F` is isomorphic to the cocone point.
-/
def colimit.isoColimitCocone {F : J ⥤ C} [HasColimit F] (t : ColimitCocone F) :
    colimit F ≅ t.cocone.pt 
goal: CategoryTheory.Limits.colimit F ≅ t.cocone.pt

full_name: CategoryTheory.Limits.colimit.isoColimitCocone_ι_hom
code: @[reassoc (attr := simp)]
theorem colimit.isoColimitCocone_ι_hom {F : J ⥤ C} [HasColimit F] (t : ColimitCocone F) (j : J) :
    colimit.ι F j ≫ (colimit.isoColimitCocone t).hom = t.cocone.ι.app j 
goal: CategoryTheory.Limits.colimit.ι F j ≫ (CategoryTheory.Limits.colimit.isoColimitCocone t).hom = t.cocone.ι.app j

full_name: CategoryTheory.Limits.colimit.isoColimitCocone_ι_inv
code: @[reassoc (attr := simp)]
theorem colimit.isoColimitCocone_ι_inv {F : J ⥤ C} [HasColimit F] (t : ColimitCocone F) (j : J) :
    t.cocone.ι.app j ≫ (colimit.isoColimitCocone t).inv = colimit.ι F j 
goal: t.cocone.ι.app j ≫ (CategoryTheory.Limits.colimit.isoColimitCocone t).inv = CategoryTheory.Limits.colimit.ι F j

full_name: CategoryTheory.Limits.colimit.hom_ext
code: @[ext]
theorem colimit.hom_ext {F : J ⥤ C} [HasColimit F] {X : C} {f f' : colimit F ⟶ X}
    (w : ∀ j, colimit.ι F j ≫ f = colimit.ι F j ≫ f') : f = f' 
goal: f = f'

full_name: CategoryTheory.Limits.colimit.desc_cocone
code: @[simp]
theorem colimit.desc_cocone {F : J ⥤ C} [HasColimit F] :
    colimit.desc F (colimit.cocone F) = 𝟙 (colimit F) 
goal: CategoryTheory.Limits.colimit.desc F (CategoryTheory.Limits.colimit.cocone F) = 𝟙 (CategoryTheory.Limits.colimit F)

full_name: CategoryTheory.Limits.colimit.homIso
code: /-- The isomorphism (in `Type`) between
morphisms from the colimit object to a specified object `W`,
and cocones with cone point `W`.
-/
def colimit.homIso (F : J ⥤ C) [HasColimit F] (W : C) :
    ULift.{u₁} (colimit F ⟶ W : Type v) ≅ F.cocones.obj W 
goal: ULift.{u₁, v} (CategoryTheory.Limits.colimit F ⟶ W) ≅ F.cocones.obj W

full_name: CategoryTheory.Limits.colimit.homIso_hom
code: @[simp]
theorem colimit.homIso_hom (F : J ⥤ C) [HasColimit F] {W : C} (f : ULift (colimit F ⟶ W)) :
    (colimit.homIso F W).hom f = (colimit.cocone F).ι ≫ (const J).map f.down 
goal: (CategoryTheory.Limits.colimit.homIso F W).hom f =
  (CategoryTheory.Limits.colimit.cocone F).ι ≫ (CategoryTheory.Functor.const J).map f.down

full_name: CategoryTheory.Limits.colimit.homIso'
code: /-- The isomorphism (in `Type`) between
morphisms from the colimit object to a specified object `W`,
and an explicit componentwise description of cocones with cone point `W`.
-/
def colimit.homIso' (F : J ⥤ C) [HasColimit F] (W : C) :
    ULift.{u₁} (colimit F ⟶ W : Type v) ≅
      { p : ∀ j, F.obj j ⟶ W // ∀ {j j'} (f : j ⟶ j'), F.map f ≫ p j' = p j } 
goal: ULift.{u₁, v} (CategoryTheory.Limits.colimit F ⟶ W) ≅ { p // ∀ {j j' : J} (f : j ⟶ j'), F.map f ≫ p j' = p j }

full_name: CategoryTheory.Limits.colimit.desc_extend
code: theorem colimit.desc_extend (F : J ⥤ C) [HasColimit F] (c : Cocone F) {X : C} (f : c.pt ⟶ X) :
    colimit.desc F (c.extend f) = colimit.desc F c ≫ f 
goal: CategoryTheory.Limits.colimit.desc F (c.extend f) = CategoryTheory.Limits.colimit.desc F c ≫ f

full_name: CategoryTheory.Limits.hasColimitOfIso
code: /-- If `F` has a colimit, so does any naturally isomorphic functor.
-/
theorem hasColimitOfIso {F G : J ⥤ C} [HasColimit F] (α : G ≅ F) : HasColimit G 
goal: CategoryTheory.Limits.HasColimit G

full_name: CategoryTheory.Limits.HasColimit.ofCoconesIso
code: /-- If a functor `G` has the same collection of cocones as a functor `F`
which has a colimit, then `G` also has a colimit. -/
theorem HasColimit.ofCoconesIso {K : Type u₁} [Category.{v₂} K] (F : J ⥤ C) (G : K ⥤ C)
    (h : F.cocones ≅ G.cocones) [HasColimit F] : HasColimit G 
goal: CategoryTheory.Limits.HasColimit G

full_name: CategoryTheory.Limits.HasColimit.isoOfNatIso
code: /-- The colimits of `F : J ⥤ C` and `G : J ⥤ C` are isomorphic,
if the functors are naturally isomorphic.
-/
def HasColimit.isoOfNatIso {F G : J ⥤ C} [HasColimit F] [HasColimit G] (w : F ≅ G) :
    colimit F ≅ colimit G 
goal: CategoryTheory.Limits.colimit F ≅ CategoryTheory.Limits.colimit G

full_name: CategoryTheory.Limits.HasColimit.isoOfNatIso_ι_hom
code: @[reassoc (attr := simp)]
theorem HasColimit.isoOfNatIso_ι_hom {F G : J ⥤ C} [HasColimit F] [HasColimit G] (w : F ≅ G)
    (j : J) : colimit.ι F j ≫ (HasColimit.isoOfNatIso w).hom = w.hom.app j ≫ colimit.ι G j 
goal: CategoryTheory.Limits.colimit.ι F j ≫ (CategoryTheory.Limits.HasColimit.isoOfNatIso w).hom =
  w.hom.app j ≫ CategoryTheory.Limits.colimit.ι G j

full_name: CategoryTheory.Limits.HasColimit.isoOfNatIso_ι_inv
code: @[reassoc (attr := simp)]
theorem HasColimit.isoOfNatIso_ι_inv {F G : J ⥤ C} [HasColimit F] [HasColimit G] (w : F ≅ G)
    (j : J) : colimit.ι G j ≫ (HasColimit.isoOfNatIso w).inv = w.inv.app j ≫ colimit.ι F j 
goal: CategoryTheory.Limits.colimit.ι G j ≫ (CategoryTheory.Limits.HasColimit.isoOfNatIso w).inv =
  w.inv.app j ≫ CategoryTheory.Limits.colimit.ι F j

full_name: CategoryTheory.Limits.HasColimit.isoOfNatIso_hom_desc
code: @[reassoc (attr := simp)]
theorem HasColimit.isoOfNatIso_hom_desc {F G : J ⥤ C} [HasColimit F] [HasColimit G] (t : Cocone G)
    (w : F ≅ G) :
    (HasColimit.isoOfNatIso w).hom ≫ colimit.desc G t =
      colimit.desc F ((Cocones.precompose w.hom).obj _) 
goal: (CategoryTheory.Limits.HasColimit.isoOfNatIso w).hom ≫ CategoryTheory.Limits.colimit.desc G t =
  CategoryTheory.Limits.colimit.desc F ((CategoryTheory.Limits.Cocones.precompose w.hom).obj t)

full_name: CategoryTheory.Limits.HasColimit.isoOfNatIso_inv_desc
code: @[reassoc (attr := simp)]
theorem HasColimit.isoOfNatIso_inv_desc {F G : J ⥤ C} [HasColimit F] [HasColimit G] (t : Cocone F)
    (w : F ≅ G) :
    (HasColimit.isoOfNatIso w).inv ≫ colimit.desc F t =
      colimit.desc G ((Cocones.precompose w.inv).obj _) 
goal: (CategoryTheory.Limits.HasColimit.isoOfNatIso w).inv ≫ CategoryTheory.Limits.colimit.desc F t =
  CategoryTheory.Limits.colimit.desc G ((CategoryTheory.Limits.Cocones.precompose w.inv).obj t)

full_name: CategoryTheory.Limits.HasColimit.isoOfEquivalence
code: /-- The colimits of `F : J ⥤ C` and `G : K ⥤ C` are isomorphic,
if there is an equivalence `e : J ≌ K` making the triangle commute up to natural isomorphism.
-/
def HasColimit.isoOfEquivalence {F : J ⥤ C} [HasColimit F] {G : K ⥤ C} [HasColimit G] (e : J ≌ K)
    (w : e.functor ⋙ G ≅ F) : colimit F ≅ colimit G 
goal: CategoryTheory.Limits.colimit F ≅ CategoryTheory.Limits.colimit G

full_name: CategoryTheory.Limits.HasColimit.isoOfEquivalence_hom_π
code: @[simp]
theorem HasColimit.isoOfEquivalence_hom_π {F : J ⥤ C} [HasColimit F] {G : K ⥤ C} [HasColimit G]
    (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (j : J) :
    colimit.ι F j ≫ (HasColimit.isoOfEquivalence e w).hom =
      F.map (e.unit.app j) ≫ w.inv.app _ ≫ colimit.ι G _ 
goal: CategoryTheory.Limits.colimit.ι F j ≫ (CategoryTheory.Limits.HasColimit.isoOfEquivalence e w).hom =
  F.map (e.unit.app j) ≫
    w.inv.app ((e.functor ⋙ e.inverse).obj j) ≫
      CategoryTheory.Limits.colimit.ι G (e.functor.obj ((e.functor ⋙ e.inverse).obj j))

full_name: CategoryTheory.Limits.HasColimit.isoOfEquivalence_inv_π
code: @[simp]
theorem HasColimit.isoOfEquivalence_inv_π {F : J ⥤ C} [HasColimit F] {G : K ⥤ C} [HasColimit G]
    (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (k : K) :
    colimit.ι G k ≫ (HasColimit.isoOfEquivalence e w).inv =
      G.map (e.counitInv.app k) ≫ w.hom.app (e.inverse.obj k) ≫ colimit.ι F (e.inverse.obj k) 
goal: CategoryTheory.Limits.colimit.ι G k ≫ (CategoryTheory.Limits.HasColimit.isoOfEquivalence e w).inv =
  G.map (e.counitInv.app k) ≫ w.hom.app (e.inverse.obj k) ≫ CategoryTheory.Limits.colimit.ι F (e.inverse.obj k)

full_name: CategoryTheory.Limits.colimit.pre
code: /-- The canonical morphism from the colimit of `E ⋙ F` to the colimit of `F`.
-/
def colimit.pre : colimit (E ⋙ F) ⟶ colimit F 
goal: CategoryTheory.Limits.colimit (E ⋙ F) ⟶ CategoryTheory.Limits.colimit F

full_name: CategoryTheory.Limits.colimit.ι_pre
code: @[reassoc (attr := simp)]
theorem colimit.ι_pre (k : K) : colimit.ι (E ⋙ F) k ≫ colimit.pre F E = colimit.ι F (E.obj k) 
goal: CategoryTheory.Limits.colimit.ι (E ⋙ F) k ≫ CategoryTheory.Limits.colimit.pre F E =
  CategoryTheory.Limits.colimit.ι F (E.obj k)

full_name: CategoryTheory.Limits.colimit.pre_desc
code: @[reassoc (attr := simp)]
theorem colimit.pre_desc (c : Cocone F) :
    colimit.pre F E ≫ colimit.desc F c = colimit.desc (E ⋙ F) (c.whisker E) 
goal: CategoryTheory.Limits.colimit.pre F E ≫ CategoryTheory.Limits.colimit.desc F c =
  CategoryTheory.Limits.colimit.desc (E ⋙ F) (CategoryTheory.Limits.Cocone.whisker E c)

full_name: CategoryTheory.Limits.colimit.pre_pre
code: @[simp]
theorem colimit.pre_pre [h : HasColimit (D ⋙ E ⋙ F)] :
    haveI : HasColimit ((D ⋙ E) ⋙ F) := h
    colimit.pre (E ⋙ F) D ≫ colimit.pre F E = colimit.pre F (D ⋙ E) 
goal: CategoryTheory.Limits.colimit.pre (E ⋙ F) D ≫ CategoryTheory.Limits.colimit.pre F E =
  CategoryTheory.Limits.colimit.pre F (D ⋙ E)

full_name: CategoryTheory.Limits.colimit.pre_eq
code: /-- -
If we have particular colimit cocones available for `E ⋙ F` and for `F`,
we obtain a formula for `colimit.pre F E`.
-/
theorem colimit.pre_eq (s : ColimitCocone (E ⋙ F)) (t : ColimitCocone F) :
    colimit.pre F E =
      (colimit.isoColimitCocone s).hom ≫
        s.isColimit.desc (t.cocone.whisker E) ≫ (colimit.isoColimitCocone t).inv 
goal: CategoryTheory.Limits.colimit.pre F E =
  (CategoryTheory.Limits.colimit.isoColimitCocone s).hom ≫
    s.isColimit.desc (CategoryTheory.Limits.Cocone.whisker E t.cocone) ≫
      (CategoryTheory.Limits.colimit.isoColimitCocone t).inv

full_name: CategoryTheory.Limits.colimit.post
code: /-- The canonical morphism from `G` applied to the colimit of `F ⋙ G`
to `G` applied to the colimit of `F`.
-/
def colimit.post : colimit (F ⋙ G) ⟶ G.obj (colimit F) 
goal: CategoryTheory.Limits.colimit (F ⋙ G) ⟶ G.obj (CategoryTheory.Limits.colimit F)

full_name: CategoryTheory.Limits.colimit.ι_post
code: @[reassoc (attr := simp)]
theorem colimit.ι_post (j : J) :
    colimit.ι (F ⋙ G) j ≫ colimit.post F G = G.map (colimit.ι F j) 
goal: CategoryTheory.Limits.colimit.ι (F ⋙ G) j ≫ CategoryTheory.Limits.colimit.post F G =
  G.map (CategoryTheory.Limits.colimit.ι F j)

full_name: CategoryTheory.Limits.colimit.post_desc
code: @[simp]
theorem colimit.post_desc (c : Cocone F) :
    colimit.post F G ≫ G.map (colimit.desc F c) = colimit.desc (F ⋙ G) (G.mapCocone c) 
goal: CategoryTheory.Limits.colimit.post F G ≫ G.map (CategoryTheory.Limits.colimit.desc F c) =
  CategoryTheory.Limits.colimit.desc (F ⋙ G) (G.mapCocone c)

full_name: CategoryTheory.Limits.colimit.post_post
code: @[simp]
theorem colimit.post_post {E : Type u''} [Category.{v''} E] (H : D ⥤ E)
    -- H G (colimit F) ⟶ H (colimit (F ⋙ G)) ⟶ colimit ((F ⋙ G) ⋙ H) equals
    -- H G (colimit F) ⟶ colimit (F ⋙ (G ⋙ H))
    [h : HasColimit ((F ⋙ G) ⋙ H)] : haveI : HasColimit (F ⋙ G ⋙ H) := h
    colimit.post (F ⋙ G) H ≫ H.map (colimit.post F G) = colimit.post F (G ⋙ H) 
goal: CategoryTheory.Limits.colimit.post (F ⋙ G) H ≫ H.map (CategoryTheory.Limits.colimit.post F G) =
  CategoryTheory.Limits.colimit.post F (G ⋙ H)

full_name: CategoryTheory.Limits.colimit.pre_post
code: theorem colimit.pre_post {D : Type u'} [Category.{v'} D] (E : K ⥤ J) (F : J ⥤ C) (G : C ⥤ D)
    [HasColimit F] [HasColimit (E ⋙ F)] [HasColimit (F ⋙ G)] [h : HasColimit ((E ⋙ F) ⋙ G)] :
    -- G (colimit F) ⟶ G (colimit (E ⋙ F)) ⟶ colimit ((E ⋙ F) ⋙ G) vs
    -- G (colimit F) ⟶ colimit F ⋙ G ⟶ colimit (E ⋙ (F ⋙ G)) or
    haveI : HasColimit (E ⋙ F ⋙ G) := h
    colimit.post (E ⋙ F) G ≫ G.map (colimit.pre F E) =
      colimit.pre (F ⋙ G) E ≫ colimit.post F G 
goal: CategoryTheory.Limits.colimit.post (E ⋙ F) G ≫ G.map (CategoryTheory.Limits.colimit.pre F E) =
  CategoryTheory.Limits.colimit.pre (F ⋙ G) E ≫ CategoryTheory.Limits.colimit.post F G

full_name: CategoryTheory.Limits.hasColimit_equivalence_comp
code: instance hasColimit_equivalence_comp (e : K ≌ J) [HasColimit F] : HasColimit (e.functor ⋙ F) 
goal: CategoryTheory.Limits.HasColimit (e.functor ⋙ F)

full_name: CategoryTheory.Limits.hasColimit_of_equivalence_comp
code: /-- If a `E ⋙ F` has a colimit, and `E` is an equivalence, we can construct a colimit of `F`.
-/
theorem hasColimit_of_equivalence_comp (e : K ≌ J) [HasColimit (e.functor ⋙ F)] : HasColimit F 
goal: CategoryTheory.Limits.HasColimit F

full_name: CategoryTheory.Limits.colim_obj
code: /-- `colimit F` is functorial in `F`, when `C` has all colimits of shape `J`. -/
@[simps] -- Porting note: simps on all fields now
def colim : (J ⥤ C) ⥤ C 
goal: CategoryTheory.Limits.colim.obj F = CategoryTheory.Limits.colimit F

full_name: CategoryTheory.Limits.colim_map
code: /-- `colimit F` is functorial in `F`, when `C` has all colimits of shape `J`. -/
@[simps] -- Porting note: simps on all fields now
def colim : (J ⥤ C) ⥤ C 
goal: ∀ {X Y : J ⥤ C} (α : X ⟶ Y), CategoryTheory.Limits.colim.map α = CategoryTheory.Limits.colimMap α

full_name: CategoryTheory.Limits.colim
code: /-- `colimit F` is functorial in `F`, when `C` has all colimits of shape `J`. -/
@[simps] -- Porting note: simps on all fields now
def colim : (J ⥤ C) ⥤ C 
goal: (J ⥤ C) ⥤ C

full_name: CategoryTheory.Limits.colimit.ι_map
code: @[reassoc]
theorem colimit.ι_map (j : J) : colimit.ι F j ≫ colim.map α = α.app j ≫ colimit.ι G j 
goal: CategoryTheory.Limits.colimit.ι F j ≫ CategoryTheory.Limits.colim.map α = α.app j ≫ CategoryTheory.Limits.colimit.ι G j

full_name: CategoryTheory.Limits.colimit.map_desc
code: @[simp] -- Porting note: proof adjusted to account for @[simps] on all fields of colim
theorem colimit.map_desc (c : Cocone G) :
    colimMap α ≫ colimit.desc G c = colimit.desc F ((Cocones.precompose α).obj c) 
goal: CategoryTheory.Limits.colimMap α ≫ CategoryTheory.Limits.colimit.desc G c =
  CategoryTheory.Limits.colimit.desc F ((CategoryTheory.Limits.Cocones.precompose α).obj c)

full_name: CategoryTheory.Limits.colimit.pre_map
code: theorem colimit.pre_map [HasColimitsOfShape K C] (E : K ⥤ J) :
    colimit.pre F E ≫ colim.map α = colim.map (whiskerLeft E α) ≫ colimit.pre G E 
goal: CategoryTheory.Limits.colimit.pre F E ≫ CategoryTheory.Limits.colim.map α =
  CategoryTheory.Limits.colim.map (CategoryTheory.whiskerLeft E α) ≫ CategoryTheory.Limits.colimit.pre G E

full_name: CategoryTheory.Limits.colimit.pre_map'
code: theorem colimit.pre_map' [HasColimitsOfShape K C] (F : J ⥤ C) {E₁ E₂ : K ⥤ J} (α : E₁ ⟶ E₂) :
    colimit.pre F E₁ = colim.map (whiskerRight α F) ≫ colimit.pre F E₂ 
goal: CategoryTheory.Limits.colimit.pre F E₁ =
  CategoryTheory.Limits.colim.map (CategoryTheory.whiskerRight α F) ≫ CategoryTheory.Limits.colimit.pre F E₂

full_name: CategoryTheory.Limits.colimit.pre_id
code: theorem colimit.pre_id (F : J ⥤ C) :
    colimit.pre F (𝟭 _) = colim.map (Functor.leftUnitor F).hom 
goal: CategoryTheory.Limits.colimit.pre F (𝟭 J) = CategoryTheory.Limits.colim.map F.leftUnitor.hom

full_name: CategoryTheory.Limits.colimit.map_post
code: theorem colimit.map_post {D : Type u'} [Category.{v'} D] [HasColimitsOfShape J D]
    (H : C ⥤ D) :/- H (colimit F) ⟶ H (colimit G) ⟶ colimit (G ⋙ H) vs
             H (colimit F) ⟶ colimit (F ⋙ H) ⟶ colimit (G ⋙ H) -/
          colimit.post
          F H ≫
        H.map (colim.map α) =
      colim.map (whiskerRight α H) ≫ colimit.post G H 
goal: CategoryTheory.Limits.colimit.post F H ≫ H.map (CategoryTheory.Limits.colim.map α) =
  CategoryTheory.Limits.colim.map (CategoryTheory.whiskerRight α H) ≫ CategoryTheory.Limits.colimit.post G H

full_name: CategoryTheory.Limits.colimCoyoneda
code: /-- The isomorphism between
morphisms from the cone point of the colimit cocone for `F` to `W`
and cocones over `F` with cone point `W`
is natural in `F`.
-/
def colimCoyoneda : colim.op ⋙ coyoneda ⋙ (whiskeringRight _ _ _).obj uliftFunctor.{u₁}
    ≅ CategoryTheory.cocones J C 
goal: CategoryTheory.Limits.colim.op ⋙
    CategoryTheory.coyoneda ⋙
      (CategoryTheory.whiskeringRight C (Type v) (Type (max v u₁))).obj CategoryTheory.uliftFunctor.{u₁, v} ≅
  CategoryTheory.cocones J C

full_name: CategoryTheory.Limits.colimConstAdj
code: /-- The colimit functor and constant functor are adjoint to each other
-/
def colimConstAdj : (colim : (J ⥤ C) ⥤ C) ⊣ const J 
goal: CategoryTheory.Limits.colim ⊣ CategoryTheory.Functor.const J

full_name: CategoryTheory.Limits.instIsLeftAdjointFunctorColim
code: instance : IsLeftAdjoint (colim : (J ⥤ C) ⥤ C) 
goal: CategoryTheory.Limits.colim.IsLeftAdjoint

full_name: CategoryTheory.Limits.colimMap_epi'
code: instance colimMap_epi' {F G : J ⥤ C} [HasColimitsOfShape J C] (α : F ⟶ G) [Epi α] :
    Epi (colimMap α) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.colimMap α)

full_name: CategoryTheory.Limits.colimMap_epi
code: instance colimMap_epi {F G : J ⥤ C} [HasColimit F] [HasColimit G] (α : F ⟶ G) [∀ j, Epi (α.app j)] :
    Epi (colimMap α) 
goal: CategoryTheory.Epi (CategoryTheory.Limits.colimMap α)

full_name: CategoryTheory.Limits.hasColimitsOfShape_of_equivalence
code: /-- We can transport colimits of shape `J` along an equivalence `J ≌ J'`.
-/
theorem hasColimitsOfShape_of_equivalence {J' : Type u₂} [Category.{v₂} J'] (e : J ≌ J')
    [HasColimitsOfShape J C] : HasColimitsOfShape J' C 
goal: CategoryTheory.Limits.HasColimitsOfShape J' C

full_name: CategoryTheory.Limits.hasColimitsOfSizeOfUnivLE
code: /-- A category that has larger colimits also has smaller colimits. -/
theorem hasColimitsOfSizeOfUnivLE [UnivLE.{v₂, v₁}] [UnivLE.{u₂, u₁}]
    [HasColimitsOfSize.{v₁, u₁} C] : HasColimitsOfSize.{v₂, u₂} C 
goal: CategoryTheory.Limits.HasColimitsOfSize.{v₂, u₂, v, u} C

full_name: CategoryTheory.Limits.hasColimitsOfSizeShrink
code: /-- `hasColimitsOfSizeShrink.{v u} C` tries to obtain `HasColimitsOfSize.{v u} C`
from some other `HasColimitsOfSize C`.
-/
theorem hasColimitsOfSizeShrink [HasColimitsOfSize.{max v₁ v₂, max u₁ u₂} C] :
    HasColimitsOfSize.{v₁, u₁} C 
goal: CategoryTheory.Limits.HasColimitsOfSize.{v₁, u₁, v, u} C

full_name: CategoryTheory.Limits.hasSmallestColimitsOfHasColimits
code: instance (priority := 100) hasSmallestColimitsOfHasColimits [HasColimits C] :
    HasColimitsOfSize.{0, 0} C 
goal: CategoryTheory.Limits.HasColimitsOfSize.{0, 0, v, u} C

full_name: CategoryTheory.Limits.IsLimit.op
code: /-- If `t : Cone F` is a limit cone, then `t.op : Cocone F.op` is a colimit cocone.
-/
def IsLimit.op {t : Cone F} (P : IsLimit t) : IsColimit t.op 
goal: CategoryTheory.Limits.IsColimit t.op

full_name: CategoryTheory.Limits.IsColimit.op
code: /-- If `t : Cocone F` is a colimit cocone, then `t.op : Cone F.op` is a limit cone.
-/
def IsColimit.op {t : Cocone F} (P : IsColimit t) : IsLimit t.op 
goal: CategoryTheory.Limits.IsLimit t.op

full_name: CategoryTheory.Limits.IsLimit.unop
code: /-- If `t : Cone F.op` is a limit cone, then `t.unop : Cocone F` is a colimit cocone.
-/
def IsLimit.unop {t : Cone F.op} (P : IsLimit t) : IsColimit t.unop 
goal: CategoryTheory.Limits.IsColimit t.unop

full_name: CategoryTheory.Limits.IsColimit.unop
code: /-- If `t : Cocone F.op` is a colimit cocone, then `t.unop : Cone F.` is a limit cone.
-/
def IsColimit.unop {t : Cocone F.op} (P : IsColimit t) : IsLimit t.unop 
goal: CategoryTheory.Limits.IsLimit t.unop

full_name: CategoryTheory.Limits.isLimitEquivIsColimitOp
code: /-- `t : Cone F` is a limit cone if and only if `t.op : Cocone F.op` is a colimit cocone.
-/
def isLimitEquivIsColimitOp {t : Cone F} : IsLimit t ≃ IsColimit t.op 
goal: CategoryTheory.Limits.IsLimit t ≃ CategoryTheory.Limits.IsColimit t.op

full_name: CategoryTheory.Limits.isColimitEquivIsLimitOp
code: /-- `t : Cocone F` is a colimit cocone if and only if `t.op : Cone F.op` is a limit cone.
-/
def isColimitEquivIsLimitOp {t : Cocone F} : IsColimit t ≃ IsLimit t.op 
goal: CategoryTheory.Limits.IsColimit t ≃ CategoryTheory.Limits.IsLimit t.op