File: Mathlib/CategoryTheory/Limits/IsLimit.lean

full_name: CategoryTheory.Limits.IsLimit.lift
code: /-- 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>.
  -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
structure IsLimit (t : Cone F) where
  /-- There is a morphism from any cone point to `t.pt` -/
  lift : ∀ s : Cone F, s.pt ⟶ t.pt
  /-- The map makes the triangle with the two natural transformations commute -/
  fac : ∀ (s : Cone F) (j : J), lift s ≫ t.π.app j = s.π.app j := by aesop_cat
  /-- It is the unique such map to do this -/
  uniq : ∀ (s : Cone F) (m : s.pt ⟶ t.pt) (_ : ∀ j : J, m ≫ t.π.app j = s.π.app j), m = lift s := by
    aesop_cat
goal: s.pt ⟶ t.pt

full_name: CategoryTheory.Limits.IsLimit
code: /-- 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>.
  -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
structure IsLimit (t : Cone F) where
  /-- There is a morphism from any cone point to `t.pt` -/
  lift : ∀ s : Cone F, s.pt ⟶ t.pt
  /-- The map makes the triangle with the two natural transformations commute -/
  fac : ∀ (s : Cone F) (j : J), lift s ≫ t.π.app j = s.π.app j := by aesop_cat
  /-- It is the unique such map to do this -/
  uniq : ∀ (s : Cone F) (m : s.pt ⟶ t.pt) (_ : ∀ j : J, m ≫ t.π.app j = s.π.app j), m = lift s := by
    aesop_cat
goal: Type (max (max u₁ u₃) v₃)

full_name: CategoryTheory.Limits.IsLimit.uniq
code: /-- 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>.
  -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
structure IsLimit (t : Cone F) where
  /-- There is a morphism from any cone point to `t.pt` -/
  lift : ∀ s : Cone F, s.pt ⟶ t.pt
  /-- The map makes the triangle with the two natural transformations commute -/
  fac : ∀ (s : Cone F) (j : J), lift s ≫ t.π.app j = s.π.app j := by aesop_cat
  /-- It is the unique such map to do this -/
  uniq : ∀ (s : Cone F) (m : s.pt ⟶ t.pt) (_ : ∀ j : J, m ≫ t.π.app j = s.π.app j), m = lift s := by
    aesop_cat
goal: (∀ (j : J), m ≫ t.π.app j = s.π.app j) → m = self.lift s

full_name: CategoryTheory.Limits.IsLimit.fac
code: /-- 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>.
  -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
structure IsLimit (t : Cone F) where
  /-- There is a morphism from any cone point to `t.pt` -/
  lift : ∀ s : Cone F, s.pt ⟶ t.pt
  /-- The map makes the triangle with the two natural transformations commute -/
  fac : ∀ (s : Cone F) (j : J), lift s ≫ t.π.app j = s.π.app j := by aesop_cat
  /-- It is the unique such map to do this -/
  uniq : ∀ (s : Cone F) (m : s.pt ⟶ t.pt) (_ : ∀ j : J, m ≫ t.π.app j = s.π.app j), m = lift s := by
    aesop_cat
goal: self.lift s ≫ t.π.app j = s.π.app j

full_name: CategoryTheory.Limits.IsLimit.subsingleton
code: instance subsingleton {t : Cone F} : Subsingleton (IsLimit t) 
goal: Subsingleton (CategoryTheory.Limits.IsLimit t)

full_name: CategoryTheory.Limits.IsLimit.map
code: /-- 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`. -/
def map {F G : J ⥤ C} (s : Cone F) {t : Cone G} (P : IsLimit t) (α : F ⟶ G) : s.pt ⟶ t.pt 
goal: s.pt ⟶ t.pt

full_name: CategoryTheory.Limits.IsLimit.map_π
code: @[reassoc (attr := simp)]
theorem map_π {F G : J ⥤ C} (c : Cone F) {d : Cone G} (hd : IsLimit d) (α : F ⟶ G) (j : J) :
    hd.map c α ≫ d.π.app j = c.π.app j ≫ α.app j 
goal: CategoryTheory.Limits.IsLimit.map c hd α ≫ d.π.app j = c.π.app j ≫ α.app j

full_name: CategoryTheory.Limits.IsLimit.lift_self
code: @[simp]
theorem lift_self {c : Cone F} (t : IsLimit c) : t.lift c = 𝟙 c.pt 
goal: t.lift c = 𝟙 c.pt

full_name: CategoryTheory.Limits.IsLimit.liftConeMorphism_hom
code: /-- The universal morphism from any other cone to a limit cone. -/
@[simps]
def liftConeMorphism {t : Cone F} (h : IsLimit t) (s : Cone F) : s ⟶ t 
goal: (h.liftConeMorphism s).hom = h.lift s

full_name: CategoryTheory.Limits.IsLimit.liftConeMorphism
code: /-- The universal morphism from any other cone to a limit cone. -/
@[simps]
def liftConeMorphism {t : Cone F} (h : IsLimit t) (s : Cone F) : s ⟶ t 
goal: s ⟶ t

full_name: CategoryTheory.Limits.IsLimit.uniq_cone_morphism
code: theorem uniq_cone_morphism {s t : Cone F} (h : IsLimit t) {f f' : s ⟶ t} : f = f' 
goal: f = f'

full_name: CategoryTheory.Limits.IsLimit.existsUnique
code: /-- Restating the definition of a limit cone in terms of the ∃! operator. -/
theorem existsUnique {t : Cone F} (h : IsLimit t) (s : Cone F) :
    ∃! l : s.pt ⟶ t.pt, ∀ j, l ≫ t.π.app j = s.π.app j 
goal: ∃! l, ∀ (j : J), l ≫ t.π.app j = s.π.app j

full_name: CategoryTheory.Limits.IsLimit.ofExistsUnique
code: /-- Noncomputably make a limit cone from the existence of unique factorizations. -/
def ofExistsUnique {t : Cone F}
    (ht : ∀ s : Cone F, ∃! l : s.pt ⟶ t.pt, ∀ j, l ≫ t.π.app j = s.π.app j) : IsLimit t 
goal: CategoryTheory.Limits.IsLimit t

full_name: CategoryTheory.Limits.IsLimit.mkConeMorphism
code: /-- Alternative constructor for `isLimit`,
providing a morphism of cones rather than a morphism between the cone points
and separately the factorisation condition.
-/
@[simps]
def mkConeMorphism {t : Cone F} (lift : ∀ s : Cone F, s ⟶ t)
    (uniq : ∀ (s : Cone F) (m : s ⟶ t), m = lift s) : IsLimit t 
goal: CategoryTheory.Limits.IsLimit t

full_name: CategoryTheory.Limits.IsLimit.mkConeMorphism_lift
code: /-- Alternative constructor for `isLimit`,
providing a morphism of cones rather than a morphism between the cone points
and separately the factorisation condition.
-/
@[simps]
def mkConeMorphism {t : Cone F} (lift : ∀ s : Cone F, s ⟶ t)
    (uniq : ∀ (s : Cone F) (m : s ⟶ t), m = lift s) : IsLimit t 
goal: (CategoryTheory.Limits.IsLimit.mkConeMorphism lift uniq).lift s = (lift s).hom

full_name: CategoryTheory.Limits.IsLimit.uniqueUpToIso_hom
code: /-- Limit cones on `F` are unique up to isomorphism. -/
@[simps]
def uniqueUpToIso {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) : s ≅ t 
goal: (P.uniqueUpToIso Q).hom = Q.liftConeMorphism s

full_name: CategoryTheory.Limits.IsLimit.uniqueUpToIso
code: /-- Limit cones on `F` are unique up to isomorphism. -/
@[simps]
def uniqueUpToIso {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) : s ≅ t 
goal: s ≅ t

full_name: CategoryTheory.Limits.IsLimit.uniqueUpToIso_inv
code: /-- Limit cones on `F` are unique up to isomorphism. -/
@[simps]
def uniqueUpToIso {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) : s ≅ t 
goal: (P.uniqueUpToIso Q).inv = P.liftConeMorphism t

full_name: CategoryTheory.Limits.IsLimit.hom_isIso
code: /-- Any cone morphism between limit cones is an isomorphism. -/
theorem hom_isIso {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) (f : s ⟶ t) : IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso
code: /-- Limits of `F` are unique up to isomorphism. -/
def conePointUniqueUpToIso {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) : s.pt ≅ t.pt 
goal: s.pt ≅ t.pt

full_name: CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_hom_comp
code: @[reassoc (attr := simp)]
theorem conePointUniqueUpToIso_hom_comp {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) (j : J) :
    (conePointUniqueUpToIso P Q).hom ≫ t.π.app j = s.π.app j 
goal: (P.conePointUniqueUpToIso Q).hom ≫ t.π.app j = s.π.app j

full_name: CategoryTheory.Limits.IsLimit.conePointUniqueUpToIso_inv_comp
code: @[reassoc (attr := simp)]
theorem conePointUniqueUpToIso_inv_comp {s t : Cone F} (P : IsLimit s) (Q : IsLimit t) (j : J) :
    (conePointUniqueUpToIso P Q).inv ≫ s.π.app j = t.π.app j 
goal: (P.conePointUniqueUpToIso Q).inv ≫ s.π.app j = t.π.app j

full_name: CategoryTheory.Limits.IsLimit.lift_comp_conePointUniqueUpToIso_hom
code: @[reassoc (attr := simp)]
theorem lift_comp_conePointUniqueUpToIso_hom {r s t : Cone F} (P : IsLimit s) (Q : IsLimit t) :
    P.lift r ≫ (conePointUniqueUpToIso P Q).hom = Q.lift r 
goal: P.lift r ≫ (P.conePointUniqueUpToIso Q).hom = Q.lift r

full_name: CategoryTheory.Limits.IsLimit.lift_comp_conePointUniqueUpToIso_inv
code: @[reassoc (attr := simp)]
theorem lift_comp_conePointUniqueUpToIso_inv {r s t : Cone F} (P : IsLimit s) (Q : IsLimit t) :
    Q.lift r ≫ (conePointUniqueUpToIso P Q).inv = P.lift r 
goal: Q.lift r ≫ (P.conePointUniqueUpToIso Q).inv = P.lift r

full_name: CategoryTheory.Limits.IsLimit.ofIsoLimit
code: /-- Transport evidence that a cone is a limit cone across an isomorphism of cones. -/
def ofIsoLimit {r t : Cone F} (P : IsLimit r) (i : r ≅ t) : IsLimit t 
goal: CategoryTheory.Limits.IsLimit t

full_name: CategoryTheory.Limits.IsLimit.ofIsoLimit_lift
code: @[simp]
theorem ofIsoLimit_lift {r t : Cone F} (P : IsLimit r) (i : r ≅ t) (s) :
    (P.ofIsoLimit i).lift s = P.lift s ≫ i.hom.hom 
goal: (P.ofIsoLimit i).lift s = P.lift s ≫ i.hom.hom

full_name: CategoryTheory.Limits.IsLimit.equivIsoLimit
code: /-- Isomorphism of cones preserves whether or not they are limiting cones. -/
def equivIsoLimit {r t : Cone F} (i : r ≅ t) : IsLimit r ≃ IsLimit t 
goal: CategoryTheory.Limits.IsLimit r ≃ CategoryTheory.Limits.IsLimit t

full_name: CategoryTheory.Limits.IsLimit.equivIsoLimit_apply
code: @[simp]
theorem equivIsoLimit_apply {r t : Cone F} (i : r ≅ t) (P : IsLimit r) :
    equivIsoLimit i P = P.ofIsoLimit i 
goal: (CategoryTheory.Limits.IsLimit.equivIsoLimit i) P = P.ofIsoLimit i

full_name: CategoryTheory.Limits.IsLimit.equivIsoLimit_symm_apply
code: @[simp]
theorem equivIsoLimit_symm_apply {r t : Cone F} (i : r ≅ t) (P : IsLimit t) :
    (equivIsoLimit i).symm P = P.ofIsoLimit i.symm 
goal: (CategoryTheory.Limits.IsLimit.equivIsoLimit i).symm P = P.ofIsoLimit i.symm

full_name: CategoryTheory.Limits.IsLimit.ofPointIso
code: /-- If the canonical morphism from a cone point to a limiting cone point is an iso, then the
first cone was limiting also.
-/
def ofPointIso {r t : Cone F} (P : IsLimit r) [i : IsIso (P.lift t)] : IsLimit t 
goal: CategoryTheory.Limits.IsLimit t

full_name: CategoryTheory.Limits.IsLimit.hom_lift
code: theorem hom_lift (h : IsLimit t) {W : C} (m : W ⟶ t.pt) :
    m = h.lift { pt := W, π := { app := fun b => m ≫ t.π.app b } } 
goal: m = h.lift { pt := W, π := { app := fun b => m ≫ t.π.app b, naturality := ⋯ } }

full_name: CategoryTheory.Limits.IsLimit.hom_ext
code: /-- Two morphisms into a limit are equal if their compositions with
  each cone morphism are equal. -/
theorem hom_ext (h : IsLimit t) {W : C} {f f' : W ⟶ t.pt}
    (w : ∀ j, f ≫ t.π.app j = f' ≫ t.π.app j) :
    f = f' 
goal: f = f'

full_name: CategoryTheory.Limits.IsLimit.ofRightAdjoint
code: /-- Given a right adjoint functor between categories of cones,
the image of a limit cone is a limit cone.
-/
def ofRightAdjoint {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D} {left : Cone F ⥤ Cone G}
    {right : Cone G ⥤ Cone F}
    (adj : left ⊣ right) {c : Cone G} (t : IsLimit c) : IsLimit (right.obj c) 
goal: CategoryTheory.Limits.IsLimit (right.obj c)

full_name: CategoryTheory.Limits.IsLimit.ofConeEquiv
code: /-- Given two functors which have equivalent categories of cones, we can transport a limiting cone
across the equivalence.
-/
def ofConeEquiv {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D} (h : Cone G ≌ Cone F) {c : Cone G} :
    IsLimit (h.functor.obj c) ≃ IsLimit c 
goal: CategoryTheory.Limits.IsLimit (h.functor.obj c) ≃ CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.IsLimit.ofConeEquiv_apply_desc
code: @[simp]
theorem ofConeEquiv_apply_desc {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D} (h : Cone G ≌ Cone F)
    {c : Cone G} (P : IsLimit (h.functor.obj c)) (s) :
    (ofConeEquiv h P).lift s =
      ((h.unitIso.hom.app s).hom ≫ (h.inverse.map (P.liftConeMorphism (h.functor.obj s))).hom) ≫
        (h.unitIso.inv.app c).hom 
goal: ((CategoryTheory.Limits.IsLimit.ofConeEquiv h) P).lift s =
  ((h.unitIso.hom.app s).hom ≫ (h.inverse.map (P.liftConeMorphism (h.functor.obj s))).hom) ≫ (h.unitIso.inv.app c).hom

full_name: CategoryTheory.Limits.IsLimit.ofConeEquiv_symm_apply_desc
code: @[simp]
theorem ofConeEquiv_symm_apply_desc {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D}
    (h : Cone G ≌ Cone F) {c : Cone G} (P : IsLimit c) (s) :
    ((ofConeEquiv h).symm P).lift s =
      (h.counitIso.inv.app s).hom ≫ (h.functor.map (P.liftConeMorphism (h.inverse.obj s))).hom 
goal: ((CategoryTheory.Limits.IsLimit.ofConeEquiv h).symm P).lift s =
  (h.counitIso.inv.app s).hom ≫ (h.functor.map (P.liftConeMorphism (h.inverse.obj s))).hom

full_name: CategoryTheory.Limits.IsLimit.postcomposeHomEquiv
code: /--
A cone postcomposed with a natural isomorphism is a limit cone if and only if the original cone is.
-/
def postcomposeHomEquiv {F G : J ⥤ C} (α : F ≅ G) (c : Cone F) :
    IsLimit ((Cones.postcompose α.hom).obj c) ≃ IsLimit c 
goal: CategoryTheory.Limits.IsLimit ((CategoryTheory.Limits.Cones.postcompose α.hom).obj c) ≃ CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.IsLimit.postcomposeInvEquiv
code: /-- A cone postcomposed with the inverse of a natural isomorphism is a limit cone if and only if
the original cone is.
-/
def postcomposeInvEquiv {F G : J ⥤ C} (α : F ≅ G) (c : Cone G) :
    IsLimit ((Cones.postcompose α.inv).obj c) ≃ IsLimit c 
goal: CategoryTheory.Limits.IsLimit ((CategoryTheory.Limits.Cones.postcompose α.inv).obj c) ≃ CategoryTheory.Limits.IsLimit c

full_name: CategoryTheory.Limits.IsLimit.equivOfNatIsoOfIso
code: /-- 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`.
-/
def equivOfNatIsoOfIso {F G : J ⥤ C} (α : F ≅ G) (c : Cone F) (d : Cone G)
    (w : (Cones.postcompose α.hom).obj c ≅ d) : IsLimit c ≃ IsLimit d 
goal: CategoryTheory.Limits.IsLimit c ≃ CategoryTheory.Limits.IsLimit d

full_name: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso
code: /-- The cone points of two limit cones for naturally isomorphic functors
are themselves isomorphic.
-/
@[simps]
def conePointsIsoOfNatIso {F G : J ⥤ C} {s : Cone F} {t : Cone G} (P : IsLimit s) (Q : IsLimit t)
    (w : F ≅ G) : s.pt ≅ t.pt 
goal: s.pt ≅ t.pt

full_name: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv
code: /-- The cone points of two limit cones for naturally isomorphic functors
are themselves isomorphic.
-/
@[simps]
def conePointsIsoOfNatIso {F G : J ⥤ C} {s : Cone F} {t : Cone G} (P : IsLimit s) (Q : IsLimit t)
    (w : F ≅ G) : s.pt ≅ t.pt 
goal: (P.conePointsIsoOfNatIso Q w).inv = CategoryTheory.Limits.IsLimit.map t P w.inv

full_name: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom
code: /-- The cone points of two limit cones for naturally isomorphic functors
are themselves isomorphic.
-/
@[simps]
def conePointsIsoOfNatIso {F G : J ⥤ C} {s : Cone F} {t : Cone G} (P : IsLimit s) (Q : IsLimit t)
    (w : F ≅ G) : s.pt ≅ t.pt 
goal: (P.conePointsIsoOfNatIso Q w).hom = CategoryTheory.Limits.IsLimit.map s Q w.hom

full_name: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_hom_comp
code: @[reassoc]
theorem conePointsIsoOfNatIso_hom_comp {F G : J ⥤ C} {s : Cone F} {t : Cone G} (P : IsLimit s)
    (Q : IsLimit t) (w : F ≅ G) (j : J) :
    (conePointsIsoOfNatIso P Q w).hom ≫ t.π.app j = s.π.app j ≫ w.hom.app j 
goal: (P.conePointsIsoOfNatIso Q w).hom ≫ t.π.app j = s.π.app j ≫ w.hom.app j

full_name: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv_comp
code: @[reassoc]
theorem conePointsIsoOfNatIso_inv_comp {F G : J ⥤ C} {s : Cone F} {t : Cone G} (P : IsLimit s)
    (Q : IsLimit t) (w : F ≅ G) (j : J) :
    (conePointsIsoOfNatIso P Q w).inv ≫ s.π.app j = t.π.app j ≫ w.inv.app j 
goal: (P.conePointsIsoOfNatIso Q w).inv ≫ s.π.app j = t.π.app j ≫ w.inv.app j

full_name: CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_hom
code: @[reassoc]
theorem lift_comp_conePointsIsoOfNatIso_hom {F G : J ⥤ C} {r s : Cone F} {t : Cone G}
    (P : IsLimit s) (Q : IsLimit t) (w : F ≅ G) :
    P.lift r ≫ (conePointsIsoOfNatIso P Q w).hom = Q.map r w.hom 
goal: P.lift r ≫ (P.conePointsIsoOfNatIso Q w).hom = CategoryTheory.Limits.IsLimit.map r Q w.hom

full_name: CategoryTheory.Limits.IsLimit.lift_comp_conePointsIsoOfNatIso_inv
code: @[reassoc]
theorem lift_comp_conePointsIsoOfNatIso_inv {F G : J ⥤ C} {r s : Cone G} {t : Cone F}
    (P : IsLimit t) (Q : IsLimit s) (w : F ≅ G) :
    Q.lift r ≫ (conePointsIsoOfNatIso P Q w).inv = P.map r w.inv 
goal: Q.lift r ≫ (P.conePointsIsoOfNatIso Q w).inv = CategoryTheory.Limits.IsLimit.map r P w.inv

full_name: CategoryTheory.Limits.IsLimit.whiskerEquivalence
code: /-- If `s : Cone F` is a limit cone, so is `s` whiskered by an equivalence `e`.
-/
def whiskerEquivalence {s : Cone F} (P : IsLimit s) (e : K ≌ J) : IsLimit (s.whisker e.functor) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Cone.whisker e.functor s)

full_name: CategoryTheory.Limits.IsLimit.ofWhiskerEquivalence
code: /-- If `s : Cone F` whiskered by an equivalence `e` is a limit cone, so is `s`.
-/
def ofWhiskerEquivalence {s : Cone F} (e : K ≌ J) (P : IsLimit (s.whisker e.functor)) : IsLimit s 
goal: CategoryTheory.Limits.IsLimit s

full_name: CategoryTheory.Limits.IsLimit.whiskerEquivalenceEquiv
code: /-- Given an equivalence of diagrams `e`, `s` is a limit cone iff `s.whisker e.functor` is.
-/
def whiskerEquivalenceEquiv {s : Cone F} (e : K ≌ J) : IsLimit s ≃ IsLimit (s.whisker e.functor) 
goal: CategoryTheory.Limits.IsLimit s ≃ CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.Cone.whisker e.functor s)

full_name: CategoryTheory.Limits.IsLimit.extendIso
code: /-- A limit cone extended by an isomorphism is a limit cone. -/
def extendIso {s : Cone F} {X : C} (i : X ⟶ s.pt) [IsIso i] (hs : IsLimit s) :
    IsLimit (s.extend i) 
goal: CategoryTheory.Limits.IsLimit (s.extend i)

full_name: CategoryTheory.Limits.IsLimit.ofExtendIso
code: /-- A cone is a limit cone if its extension by an isomorphism is. -/
def ofExtendIso {s : Cone F} {X : C} (i : X ⟶ s.pt) [IsIso i] (hs : IsLimit (s.extend i)) :
    IsLimit s 
goal: CategoryTheory.Limits.IsLimit s

full_name: CategoryTheory.Limits.IsLimit.extendIsoEquiv
code: /-- A cone is a limit cone iff its extension by an isomorphism is. -/
def extendIsoEquiv {s : Cone F} {X : C} (i : X ⟶ s.pt) [IsIso i] :
    IsLimit s ≃ IsLimit (s.extend i) 
goal: CategoryTheory.Limits.IsLimit s ≃ CategoryTheory.Limits.IsLimit (s.extend i)

full_name: CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence_inv
code: /-- 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).
-/
@[simps]
def conePointsIsoOfEquivalence {F : J ⥤ C} {s : Cone F} {G : K ⥤ C} {t : Cone G} (P : IsLimit s)
    (Q : IsLimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F) : s.pt ≅ t.pt 
goal: (P.conePointsIsoOfEquivalence Q e w).inv =
  P.lift ((CategoryTheory.Limits.Cones.equivalenceOfReindexing e w).functor.obj t)

full_name: CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence_hom
code: /-- 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).
-/
@[simps]
def conePointsIsoOfEquivalence {F : J ⥤ C} {s : Cone F} {G : K ⥤ C} {t : Cone G} (P : IsLimit s)
    (Q : IsLimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F) : s.pt ≅ t.pt 
goal: (P.conePointsIsoOfEquivalence Q e w).hom =
  Q.lift
    ((CategoryTheory.Limits.Cones.equivalenceOfReindexing e.symm
            ((CategoryTheory.isoWhiskerLeft e.inverse w).symm ≪≫ e.invFunIdAssoc G)).functor.obj
      s)

full_name: CategoryTheory.Limits.IsLimit.conePointsIsoOfEquivalence
code: /-- 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).
-/
@[simps]
def conePointsIsoOfEquivalence {F : J ⥤ C} {s : Cone F} {G : K ⥤ C} {t : Cone G} (P : IsLimit s)
    (Q : IsLimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F) : s.pt ≅ t.pt 
goal: s.pt ≅ t.pt

full_name: CategoryTheory.Limits.IsLimit.homIso
code: /-- The universal property of a limit cone: a map `W ⟶ X` is the same as
  a cone on `F` with cone point `W`. -/
def homIso (h : IsLimit t) (W : C) : ULift.{u₁} (W ⟶ t.pt : Type v₃) ≅ (const J).obj W ⟶ F 
goal: ULift.{u₁, v₃} (W ⟶ t.pt) ≅ (CategoryTheory.Functor.const J).obj W ⟶ F

full_name: CategoryTheory.Limits.IsLimit.homIso_hom
code: @[simp]
theorem homIso_hom (h : IsLimit t) {W : C} (f : ULift.{u₁} (W ⟶ t.pt)) :
    (IsLimit.homIso h W).hom f = (t.extend f.down).π 
goal: (h.homIso W).hom f = (t.extend f.down).π

full_name: CategoryTheory.Limits.IsLimit.natIso
code: /-- The limit of `F` represents the functor taking `W` to
  the set of cones on `F` with cone point `W`. -/
def natIso (h : IsLimit t) : yoneda.obj t.pt ⋙ uliftFunctor.{u₁} ≅ F.cones 
goal: CategoryTheory.yoneda.obj t.pt ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cones

full_name: CategoryTheory.Limits.IsLimit.homIso'
code: /-- Another, more explicit, formulation of the universal property of a limit cone.
See also `homIso`. -/
def homIso' (h : IsLimit t) (W : C) :
    ULift.{u₁} (W ⟶ t.pt : Type v₃) ≅
      { p : ∀ j, W ⟶ F.obj j // ∀ {j j'} (f : j ⟶ j'), p j ≫ F.map f = p j' } 
goal: ULift.{u₁, v₃} (W ⟶ t.pt) ≅ { p // ∀ {j j' : J} (f : j ⟶ j'), p j ≫ F.map f = p j' }

full_name: CategoryTheory.Limits.IsLimit.ofFaithful
code: /-- 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. -/
def ofFaithful {t : Cone F} {D : Type u₄} [Category.{v₄} D] (G : C ⥤ D) [G.Faithful]
    (ht : IsLimit (mapCone G t)) (lift : ∀ s : Cone F, s.pt ⟶ t.pt)
    (h : ∀ s, G.map (lift s) = ht.lift (mapCone G s)) : IsLimit t 
goal: CategoryTheory.Limits.IsLimit t

full_name: CategoryTheory.Limits.IsLimit.mapConeEquiv
code: /-- If `F` and `G` are naturally isomorphic, then `F.mapCone c` being a limit implies
`G.mapCone c` is also a limit.
-/
def mapConeEquiv {D : Type u₄} [Category.{v₄} D] {K : J ⥤ C} {F G : C ⥤ D} (h : F ≅ G) {c : Cone K}
    (t : IsLimit (mapCone F c)) : IsLimit (mapCone G c) 
goal: CategoryTheory.Limits.IsLimit (G.mapCone c)

full_name: CategoryTheory.Limits.IsLimit.isoUniqueConeMorphism
code: /-- A cone is a limit cone exactly if
there is a unique cone morphism from any other cone.
-/
def isoUniqueConeMorphism {t : Cone F} : IsLimit t ≅ ∀ s, Unique (s ⟶ t) 
goal: CategoryTheory.Limits.IsLimit t ≅ (s : CategoryTheory.Limits.Cone F) → Unique (s ⟶ t)

full_name: CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom
code: /-- If `F.cones` is represented by `X`, each morphism `f : Y ⟶ X` gives a cone with cone point
`Y`. -/
def coneOfHom {Y : C} (f : Y ⟶ X) : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone
code: /-- If `F.cones` is represented by `X`, each cone `s` gives a morphism `s.pt ⟶ X`. -/
def homOfCone (s : Cone F) : s.pt ⟶ X 
goal: s.pt ⟶ X

full_name: CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom_homOfCone
code: @[simp]
theorem coneOfHom_homOfCone (s : Cone F) : coneOfHom h (homOfCone h s) = s 
goal: CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom h (CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone h s) = s

full_name: CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone_coneOfHom
code: @[simp]
theorem homOfCone_coneOfHom {Y : C} (f : Y ⟶ X) : homOfCone h (coneOfHom h f) = f 
goal: CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone h (CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom h f) = f

full_name: CategoryTheory.Limits.IsLimit.OfNatIso.limitCone
code: /-- If `F.cones` is represented by `X`, the cone corresponding to the identity morphism on `X`
will be a limit cone. -/
def limitCone : Cone F 
goal: CategoryTheory.Limits.Cone F

full_name: CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom_fac
code: /-- If `F.cones` is represented by `X`, the cone corresponding to a morphism `f : Y ⟶ X` is
the limit cone extended by `f`. -/
theorem coneOfHom_fac {Y : C} (f : Y ⟶ X) : coneOfHom h f = (limitCone h).extend f 
goal: CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom h f = (CategoryTheory.Limits.IsLimit.OfNatIso.limitCone h).extend f

full_name: CategoryTheory.Limits.IsLimit.OfNatIso.cone_fac
code: /-- If `F.cones` is represented by `X`, any cone is the extension of the limit cone by the
corresponding morphism. -/
theorem cone_fac (s : Cone F) : (limitCone h).extend (homOfCone h s) = s 
goal: (CategoryTheory.Limits.IsLimit.OfNatIso.limitCone h).extend (CategoryTheory.Limits.IsLimit.OfNatIso.homOfCone h s) = s

full_name: CategoryTheory.Limits.IsLimit.ofNatIso
code: /-- If `F.cones` is representable, then the cone corresponding to the identity morphism on
the representing object is a limit cone.
-/
def ofNatIso {X : C} (h : yoneda.obj X ⋙ uliftFunctor.{u₁} ≅ F.cones) : IsLimit (limitCone h) 
goal: CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.IsLimit.OfNatIso.limitCone h)

full_name: CategoryTheory.Limits.IsColimit.uniq
code: /-- 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>.
-/
-- Porting note(#5171): removed @[nolint has_nonempty_instance]
structure IsColimit (t : Cocone F) where
  /-- `t.pt` maps to all other cocone covertices -/
  desc : ∀ s : Cocone F, t.pt ⟶ s.pt
  /-- The map `desc` makes the diagram with the natural transformations commute -/
  fac : ∀ (s : Cocone F) (j : J), t.ι.app j ≫ desc s = s.ι.app j := by aesop_cat
  /-- `desc` is the unique such map -/
  uniq :
    ∀ (s : Cocone F) (m : t.pt ⟶ s.pt) (_ : ∀ j : J, t.ι.app j ≫ m = s.ι.app j), m = desc s := by
    aesop_cat
goal: (∀ (j : J), t.ι.app j ≫ m = s.ι.app j) → m = self.desc s

full_name: CategoryTheory.Limits.IsColimit.fac
code: /-- 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>.
-/
-- Porting note(#5171): removed @[nolint has_nonempty_instance]
structure IsColimit (t : Cocone F) where
  /-- `t.pt` maps to all other cocone covertices -/
  desc : ∀ s : Cocone F, t.pt ⟶ s.pt
  /-- The map `desc` makes the diagram with the natural transformations commute -/
  fac : ∀ (s : Cocone F) (j : J), t.ι.app j ≫ desc s = s.ι.app j := by aesop_cat
  /-- `desc` is the unique such map -/
  uniq :
    ∀ (s : Cocone F) (m : t.pt ⟶ s.pt) (_ : ∀ j : J, t.ι.app j ≫ m = s.ι.app j), m = desc s := by
    aesop_cat
goal: t.ι.app j ≫ self.desc s = s.ι.app j

full_name: CategoryTheory.Limits.IsColimit.desc
code: /-- 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>.
-/
-- Porting note(#5171): removed @[nolint has_nonempty_instance]
structure IsColimit (t : Cocone F) where
  /-- `t.pt` maps to all other cocone covertices -/
  desc : ∀ s : Cocone F, t.pt ⟶ s.pt
  /-- The map `desc` makes the diagram with the natural transformations commute -/
  fac : ∀ (s : Cocone F) (j : J), t.ι.app j ≫ desc s = s.ι.app j := by aesop_cat
  /-- `desc` is the unique such map -/
  uniq :
    ∀ (s : Cocone F) (m : t.pt ⟶ s.pt) (_ : ∀ j : J, t.ι.app j ≫ m = s.ι.app j), m = desc s := by
    aesop_cat
goal: t.pt ⟶ s.pt

full_name: CategoryTheory.Limits.IsColimit
code: /-- 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>.
-/
-- Porting note(#5171): removed @[nolint has_nonempty_instance]
structure IsColimit (t : Cocone F) where
  /-- `t.pt` maps to all other cocone covertices -/
  desc : ∀ s : Cocone F, t.pt ⟶ s.pt
  /-- The map `desc` makes the diagram with the natural transformations commute -/
  fac : ∀ (s : Cocone F) (j : J), t.ι.app j ≫ desc s = s.ι.app j := by aesop_cat
  /-- `desc` is the unique such map -/
  uniq :
    ∀ (s : Cocone F) (m : t.pt ⟶ s.pt) (_ : ∀ j : J, t.ι.app j ≫ m = s.ι.app j), m = desc s := by
    aesop_cat
goal: Type (max (max u₁ u₃) v₃)

full_name: CategoryTheory.Limits.IsColimit.subsingleton
code: instance subsingleton {t : Cocone F} : Subsingleton (IsColimit t) 
goal: Subsingleton (CategoryTheory.Limits.IsColimit t)

full_name: CategoryTheory.Limits.IsColimit.map
code: /-- 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`. -/
def map {F G : J ⥤ C} {s : Cocone F} (P : IsColimit s) (t : Cocone G) (α : F ⟶ G) : s.pt ⟶ t.pt 
goal: s.pt ⟶ t.pt

full_name: CategoryTheory.Limits.IsColimit.ι_map
code: @[reassoc (attr := simp)]
theorem ι_map {F G : J ⥤ C} {c : Cocone F} (hc : IsColimit c) (d : Cocone G) (α : F ⟶ G) (j : J) :
    c.ι.app j ≫ IsColimit.map hc d α = α.app j ≫ d.ι.app j 
goal: c.ι.app j ≫ hc.map d α = α.app j ≫ d.ι.app j

full_name: CategoryTheory.Limits.IsColimit.desc_self
code: @[simp]
theorem desc_self {t : Cocone F} (h : IsColimit t) : h.desc t = 𝟙 t.pt 
goal: h.desc t = 𝟙 t.pt

full_name: CategoryTheory.Limits.IsColimit.descCoconeMorphism_hom
code: /-- The universal morphism from a colimit cocone to any other cocone. -/
@[simps]
def descCoconeMorphism {t : Cocone F} (h : IsColimit t) (s : Cocone F) : t ⟶ s 
goal: (h.descCoconeMorphism s).hom = h.desc s

full_name: CategoryTheory.Limits.IsColimit.descCoconeMorphism
code: /-- The universal morphism from a colimit cocone to any other cocone. -/
@[simps]
def descCoconeMorphism {t : Cocone F} (h : IsColimit t) (s : Cocone F) : t ⟶ s 
goal: t ⟶ s

full_name: CategoryTheory.Limits.IsColimit.uniq_cocone_morphism
code: theorem uniq_cocone_morphism {s t : Cocone F} (h : IsColimit t) {f f' : t ⟶ s} : f = f' 
goal: f = f'

full_name: CategoryTheory.Limits.IsColimit.existsUnique
code: /-- Restating the definition of a colimit cocone in terms of the ∃! operator. -/
theorem existsUnique {t : Cocone F} (h : IsColimit t) (s : Cocone F) :
    ∃! d : t.pt ⟶ s.pt, ∀ j, t.ι.app j ≫ d = s.ι.app j 
goal: ∃! d, ∀ (j : J), t.ι.app j ≫ d = s.ι.app j

full_name: CategoryTheory.Limits.IsColimit.ofExistsUnique
code: /-- Noncomputably make a colimit cocone from the existence of unique factorizations. -/
def ofExistsUnique {t : Cocone F}
    (ht : ∀ s : Cocone F, ∃! d : t.pt ⟶ s.pt, ∀ j, t.ι.app j ≫ d = s.ι.app j) : IsColimit t 
goal: CategoryTheory.Limits.IsColimit t

full_name: CategoryTheory.Limits.IsColimit.mkCoconeMorphism
code: /-- Alternative constructor for `IsColimit`,
providing a morphism of cocones rather than a morphism between the cocone points
and separately the factorisation condition.
-/
@[simps]
def mkCoconeMorphism {t : Cocone F} (desc : ∀ s : Cocone F, t ⟶ s)
    (uniq' : ∀ (s : Cocone F) (m : t ⟶ s), m = desc s) : IsColimit t 
goal: CategoryTheory.Limits.IsColimit t

full_name: CategoryTheory.Limits.IsColimit.mkCoconeMorphism_desc
code: /-- Alternative constructor for `IsColimit`,
providing a morphism of cocones rather than a morphism between the cocone points
and separately the factorisation condition.
-/
@[simps]
def mkCoconeMorphism {t : Cocone F} (desc : ∀ s : Cocone F, t ⟶ s)
    (uniq' : ∀ (s : Cocone F) (m : t ⟶ s), m = desc s) : IsColimit t 
goal: (CategoryTheory.Limits.IsColimit.mkCoconeMorphism desc uniq').desc s = (desc s).hom

full_name: CategoryTheory.Limits.IsColimit.uniqueUpToIso
code: /-- Colimit cocones on `F` are unique up to isomorphism. -/
@[simps]
def uniqueUpToIso {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) : s ≅ t 
goal: s ≅ t

full_name: CategoryTheory.Limits.IsColimit.uniqueUpToIso_inv
code: /-- Colimit cocones on `F` are unique up to isomorphism. -/
@[simps]
def uniqueUpToIso {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) : s ≅ t 
goal: (P.uniqueUpToIso Q).inv = Q.descCoconeMorphism s

full_name: CategoryTheory.Limits.IsColimit.uniqueUpToIso_hom
code: /-- Colimit cocones on `F` are unique up to isomorphism. -/
@[simps]
def uniqueUpToIso {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) : s ≅ t 
goal: (P.uniqueUpToIso Q).hom = P.descCoconeMorphism t

full_name: CategoryTheory.Limits.IsColimit.hom_isIso
code: /-- Any cocone morphism between colimit cocones is an isomorphism. -/
theorem hom_isIso {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) (f : s ⟶ t) : IsIso f 
goal: CategoryTheory.IsIso f

full_name: CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso
code: /-- Colimits of `F` are unique up to isomorphism. -/
def coconePointUniqueUpToIso {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) : s.pt ≅ t.pt 
goal: s.pt ≅ t.pt

full_name: CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_hom
code: @[reassoc (attr := simp)]
theorem comp_coconePointUniqueUpToIso_hom {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t)
    (j : J) : s.ι.app j ≫ (coconePointUniqueUpToIso P Q).hom = t.ι.app j 
goal: s.ι.app j ≫ (P.coconePointUniqueUpToIso Q).hom = t.ι.app j

full_name: CategoryTheory.Limits.IsColimit.comp_coconePointUniqueUpToIso_inv
code: @[reassoc (attr := simp)]
theorem comp_coconePointUniqueUpToIso_inv {s t : Cocone F} (P : IsColimit s) (Q : IsColimit t)
    (j : J) : t.ι.app j ≫ (coconePointUniqueUpToIso P Q).inv = s.ι.app j 
goal: t.ι.app j ≫ (P.coconePointUniqueUpToIso Q).inv = s.ι.app j

full_name: CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_hom_desc
code: @[reassoc (attr := simp)]
theorem coconePointUniqueUpToIso_hom_desc {r s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) :
    (coconePointUniqueUpToIso P Q).hom ≫ Q.desc r = P.desc r 
goal: (P.coconePointUniqueUpToIso Q).hom ≫ Q.desc r = P.desc r

full_name: CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_inv_desc
code: @[reassoc (attr := simp)]
theorem coconePointUniqueUpToIso_inv_desc {r s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) :
    (coconePointUniqueUpToIso P Q).inv ≫ P.desc r = Q.desc r 
goal: (P.coconePointUniqueUpToIso Q).inv ≫ P.desc r = Q.desc r

full_name: CategoryTheory.Limits.IsColimit.ofIsoColimit
code: /-- Transport evidence that a cocone is a colimit cocone across an isomorphism of cocones. -/
def ofIsoColimit {r t : Cocone F} (P : IsColimit r) (i : r ≅ t) : IsColimit t 
goal: CategoryTheory.Limits.IsColimit t

full_name: CategoryTheory.Limits.IsColimit.ofIsoColimit_desc
code: @[simp]
theorem ofIsoColimit_desc {r t : Cocone F} (P : IsColimit r) (i : r ≅ t) (s) :
    (P.ofIsoColimit i).desc s = i.inv.hom ≫ P.desc s 
goal: (P.ofIsoColimit i).desc s = i.inv.hom ≫ P.desc s

full_name: CategoryTheory.Limits.IsColimit.equivIsoColimit
code: /-- Isomorphism of cocones preserves whether or not they are colimiting cocones. -/
def equivIsoColimit {r t : Cocone F} (i : r ≅ t) : IsColimit r ≃ IsColimit t 
goal: CategoryTheory.Limits.IsColimit r ≃ CategoryTheory.Limits.IsColimit t

full_name: CategoryTheory.Limits.IsColimit.equivIsoColimit_apply
code: @[simp]
theorem equivIsoColimit_apply {r t : Cocone F} (i : r ≅ t) (P : IsColimit r) :
    equivIsoColimit i P = P.ofIsoColimit i 
goal: (CategoryTheory.Limits.IsColimit.equivIsoColimit i) P = P.ofIsoColimit i

full_name: CategoryTheory.Limits.IsColimit.equivIsoColimit_symm_apply
code: @[simp]
theorem equivIsoColimit_symm_apply {r t : Cocone F} (i : r ≅ t) (P : IsColimit t) :
    (equivIsoColimit i).symm P = P.ofIsoColimit i.symm 
goal: (CategoryTheory.Limits.IsColimit.equivIsoColimit i).symm P = P.ofIsoColimit i.symm

full_name: CategoryTheory.Limits.IsColimit.ofPointIso
code: /-- If the canonical morphism to a cocone point from a colimiting cocone point is an iso, then the
first cocone was colimiting also.
-/
def ofPointIso {r t : Cocone F} (P : IsColimit r) [i : IsIso (P.desc t)] : IsColimit t 
goal: CategoryTheory.Limits.IsColimit t

full_name: CategoryTheory.Limits.IsColimit.hom_desc
code: theorem hom_desc (h : IsColimit t) {W : C} (m : t.pt ⟶ W) :
    m =
      h.desc
        { pt := W
          ι :=
            { app := fun b => t.ι.app b ≫ m
              naturality := by intros; erw [← assoc, t.ι.naturality, comp_id, comp_id] } } 
goal: m = h.desc { pt := W, ι := { app := fun b => t.ι.app b ≫ m, naturality := ⋯ } }

full_name: CategoryTheory.Limits.IsColimit.hom_ext
code: /-- Two morphisms out of a colimit are equal if their compositions with
  each cocone morphism are equal. -/
theorem hom_ext (h : IsColimit t) {W : C} {f f' : t.pt ⟶ W}
    (w : ∀ j, t.ι.app j ≫ f = t.ι.app j ≫ f') : f = f' 
goal: f = f'

full_name: CategoryTheory.Limits.IsColimit.ofLeftAdjoint
code: /-- Given a left adjoint functor between categories of cocones,
the image of a colimit cocone is a colimit cocone.
-/
def ofLeftAdjoint {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D} {left : Cocone G ⥤ Cocone F}
    {right : Cocone F ⥤ Cocone G} (adj : left ⊣ right) {c : Cocone G} (t : IsColimit c) :
    IsColimit (left.obj c) 
goal: CategoryTheory.Limits.IsColimit (left.obj c)

full_name: CategoryTheory.Limits.IsColimit.ofCoconeEquiv
code: /-- Given two functors which have equivalent categories of cocones,
we can transport a colimiting cocone across the equivalence.
-/
def ofCoconeEquiv {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D} (h : Cocone G ≌ Cocone F)
    {c : Cocone G} : IsColimit (h.functor.obj c) ≃ IsColimit c 
goal: CategoryTheory.Limits.IsColimit (h.functor.obj c) ≃ CategoryTheory.Limits.IsColimit c

full_name: CategoryTheory.Limits.IsColimit.ofCoconeEquiv_apply_desc
code: @[simp]
theorem ofCoconeEquiv_apply_desc {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D}
    (h : Cocone G ≌ Cocone F) {c : Cocone G} (P : IsColimit (h.functor.obj c)) (s) :
    (ofCoconeEquiv h P).desc s =
      (h.unit.app c).hom ≫
        (h.inverse.map (P.descCoconeMorphism (h.functor.obj s))).hom ≫ (h.unitInv.app s).hom 
goal: ((CategoryTheory.Limits.IsColimit.ofCoconeEquiv h) P).desc s =
  (h.unit.app c).hom ≫ (h.inverse.map (P.descCoconeMorphism (h.functor.obj s))).hom ≫ (h.unitInv.app s).hom

full_name: CategoryTheory.Limits.IsColimit.ofCoconeEquiv_symm_apply_desc
code: @[simp]
theorem ofCoconeEquiv_symm_apply_desc {D : Type u₄} [Category.{v₄} D] {G : K ⥤ D}
    (h : Cocone G ≌ Cocone F) {c : Cocone G} (P : IsColimit c) (s) :
    ((ofCoconeEquiv h).symm P).desc s =
      (h.functor.map (P.descCoconeMorphism (h.inverse.obj s))).hom ≫ (h.counit.app s).hom 
goal: ((CategoryTheory.Limits.IsColimit.ofCoconeEquiv h).symm P).desc s =
  (h.functor.map (P.descCoconeMorphism (h.inverse.obj s))).hom ≫ (h.counit.app s).hom

full_name: CategoryTheory.Limits.IsColimit.precomposeHomEquiv
code: /-- A cocone precomposed with a natural isomorphism is a colimit cocone
if and only if the original cocone is.
-/
def precomposeHomEquiv {F G : J ⥤ C} (α : F ≅ G) (c : Cocone G) :
    IsColimit ((Cocones.precompose α.hom).obj c) ≃ IsColimit c 
goal: CategoryTheory.Limits.IsColimit ((CategoryTheory.Limits.Cocones.precompose α.hom).obj c) ≃
  CategoryTheory.Limits.IsColimit c

full_name: CategoryTheory.Limits.IsColimit.precomposeInvEquiv
code: /-- A cocone precomposed with the inverse of a natural isomorphism is a colimit cocone
if and only if the original cocone is.
-/
def precomposeInvEquiv {F G : J ⥤ C} (α : F ≅ G) (c : Cocone F) :
    IsColimit ((Cocones.precompose α.inv).obj c) ≃ IsColimit c 
goal: CategoryTheory.Limits.IsColimit ((CategoryTheory.Limits.Cocones.precompose α.inv).obj c) ≃
  CategoryTheory.Limits.IsColimit c

full_name: CategoryTheory.Limits.IsColimit.equivOfNatIsoOfIso
code: /-- 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`.
-/
def equivOfNatIsoOfIso {F G : J ⥤ C} (α : F ≅ G) (c : Cocone F) (d : Cocone G)
    (w : (Cocones.precompose α.inv).obj c ≅ d) : IsColimit c ≃ IsColimit d 
goal: CategoryTheory.Limits.IsColimit c ≃ CategoryTheory.Limits.IsColimit d

full_name: CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso
code: /-- The cocone points of two colimit cocones for naturally isomorphic functors
are themselves isomorphic.
-/
@[simps]
def coconePointsIsoOfNatIso {F G : J ⥤ C} {s : Cocone F} {t : Cocone G} (P : IsColimit s)
    (Q : IsColimit t) (w : F ≅ G) : s.pt ≅ t.pt 
goal: s.pt ≅ t.pt

full_name: CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_hom
code: /-- The cocone points of two colimit cocones for naturally isomorphic functors
are themselves isomorphic.
-/
@[simps]
def coconePointsIsoOfNatIso {F G : J ⥤ C} {s : Cocone F} {t : Cocone G} (P : IsColimit s)
    (Q : IsColimit t) (w : F ≅ G) : s.pt ≅ t.pt 
goal: (P.coconePointsIsoOfNatIso Q w).hom = P.map t w.hom

full_name: CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_inv
code: /-- The cocone points of two colimit cocones for naturally isomorphic functors
are themselves isomorphic.
-/
@[simps]
def coconePointsIsoOfNatIso {F G : J ⥤ C} {s : Cocone F} {t : Cocone G} (P : IsColimit s)
    (Q : IsColimit t) (w : F ≅ G) : s.pt ≅ t.pt 
goal: (P.coconePointsIsoOfNatIso Q w).inv = Q.map s w.inv

full_name: CategoryTheory.Limits.IsColimit.comp_coconePointsIsoOfNatIso_hom
code: @[reassoc]
theorem comp_coconePointsIsoOfNatIso_hom {F G : J ⥤ C} {s : Cocone F} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (w : F ≅ G) (j : J) :
    s.ι.app j ≫ (coconePointsIsoOfNatIso P Q w).hom = w.hom.app j ≫ t.ι.app j 
goal: s.ι.app j ≫ (P.coconePointsIsoOfNatIso Q w).hom = w.hom.app j ≫ t.ι.app j

full_name: CategoryTheory.Limits.IsColimit.comp_coconePointsIsoOfNatIso_inv
code: @[reassoc]
theorem comp_coconePointsIsoOfNatIso_inv {F G : J ⥤ C} {s : Cocone F} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (w : F ≅ G) (j : J) :
    t.ι.app j ≫ (coconePointsIsoOfNatIso P Q w).inv = w.inv.app j ≫ s.ι.app j 
goal: t.ι.app j ≫ (P.coconePointsIsoOfNatIso Q w).inv = w.inv.app j ≫ s.ι.app j

full_name: CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_hom_desc
code: @[reassoc]
theorem coconePointsIsoOfNatIso_hom_desc {F G : J ⥤ C} {s : Cocone F} {r t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (w : F ≅ G) :
    (coconePointsIsoOfNatIso P Q w).hom ≫ Q.desc r = P.map _ w.hom 
goal: (P.coconePointsIsoOfNatIso Q w).hom ≫ Q.desc r = P.map r w.hom

full_name: CategoryTheory.Limits.IsColimit.coconePointsIsoOfNatIso_inv_desc
code: @[reassoc]
theorem coconePointsIsoOfNatIso_inv_desc {F G : J ⥤ C} {s : Cocone G} {r t : Cocone F}
    (P : IsColimit t) (Q : IsColimit s) (w : F ≅ G) :
    (coconePointsIsoOfNatIso P Q w).inv ≫ P.desc r = Q.map _ w.inv 
goal: (P.coconePointsIsoOfNatIso Q w).inv ≫ P.desc r = Q.map r w.inv

full_name: CategoryTheory.Limits.IsColimit.whiskerEquivalence
code: /-- If `s : Cocone F` is a colimit cocone, so is `s` whiskered by an equivalence `e`.
-/
def whiskerEquivalence {s : Cocone F} (P : IsColimit s) (e : K ≌ J) :
    IsColimit (s.whisker e.functor) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cocone.whisker e.functor s)

full_name: CategoryTheory.Limits.IsColimit.ofWhiskerEquivalence
code: /-- If `s : Cocone F` whiskered by an equivalence `e` is a colimit cocone, so is `s`.
-/
def ofWhiskerEquivalence {s : Cocone F} (e : K ≌ J) (P : IsColimit (s.whisker e.functor)) :
    IsColimit s 
goal: CategoryTheory.Limits.IsColimit s

full_name: CategoryTheory.Limits.IsColimit.whiskerEquivalenceEquiv
code: /-- Given an equivalence of diagrams `e`, `s` is a colimit cocone iff `s.whisker e.functor` is.
-/
def whiskerEquivalenceEquiv {s : Cocone F} (e : K ≌ J) :
    IsColimit s ≃ IsColimit (s.whisker e.functor) 
goal: CategoryTheory.Limits.IsColimit s ≃ CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cocone.whisker e.functor s)

full_name: CategoryTheory.Limits.IsColimit.extendIso
code: /-- A colimit cocone extended by an isomorphism is a colimit cocone. -/
def extendIso {s : Cocone F} {X : C} (i : s.pt ⟶ X) [IsIso i] (hs : IsColimit s) :
    IsColimit (s.extend i) 
goal: CategoryTheory.Limits.IsColimit (s.extend i)

full_name: CategoryTheory.Limits.IsColimit.ofExtendIso
code: /-- A cocone is a colimit cocone if its extension by an isomorphism is. -/
def ofExtendIso {s : Cocone F} {X : C} (i : s.pt ⟶ X) [IsIso i] (hs : IsColimit (s.extend i)) :
    IsColimit s 
goal: CategoryTheory.Limits.IsColimit s

full_name: CategoryTheory.Limits.IsColimit.extendIsoEquiv
code: /-- A cocone is a colimit cocone iff its extension by an isomorphism is. -/
def extendIsoEquiv {s : Cocone F} {X : C} (i : s.pt ⟶ X) [IsIso i] :
    IsColimit s ≃ IsColimit (s.extend i) 
goal: CategoryTheory.Limits.IsColimit s ≃ CategoryTheory.Limits.IsColimit (s.extend i)

full_name: CategoryTheory.Limits.IsColimit.coconePointsIsoOfEquivalence_inv
code: /-- 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).
-/
@[simps]
def coconePointsIsoOfEquivalence {F : J ⥤ C} {s : Cocone F} {G : K ⥤ C} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F) : s.pt ≅ t.pt 
goal: (P.coconePointsIsoOfEquivalence Q e w).inv =
  Q.desc
    ((CategoryTheory.Limits.Cocones.equivalenceOfReindexing e.symm
            ((CategoryTheory.isoWhiskerLeft e.inverse w).symm ≪≫ e.invFunIdAssoc G)).functor.obj
      s)

full_name: CategoryTheory.Limits.IsColimit.coconePointsIsoOfEquivalence_hom
code: /-- 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).
-/
@[simps]
def coconePointsIsoOfEquivalence {F : J ⥤ C} {s : Cocone F} {G : K ⥤ C} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F) : s.pt ≅ t.pt 
goal: (P.coconePointsIsoOfEquivalence Q e w).hom =
  P.desc ((CategoryTheory.Limits.Cocones.equivalenceOfReindexing e w).functor.obj t)

full_name: CategoryTheory.Limits.IsColimit.coconePointsIsoOfEquivalence
code: /-- 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).
-/
@[simps]
def coconePointsIsoOfEquivalence {F : J ⥤ C} {s : Cocone F} {G : K ⥤ C} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F) : s.pt ≅ t.pt 
goal: s.pt ≅ t.pt

full_name: CategoryTheory.Limits.IsColimit.homEquiv
code: /-- The universal property of a colimit cocone: a map `X ⟶ W` is the same as
  a cocone on `F` with cone point `W`. -/
def homEquiv (h : IsColimit t) (W : C) : (t.pt ⟶ W) ≃ (F ⟶ (const J).obj W) 
goal: (t.pt ⟶ W) ≃ (F ⟶ (CategoryTheory.Functor.const J).obj W)

full_name: CategoryTheory.Limits.IsColimit.homEquiv_apply
code: @[simp]
lemma homEquiv_apply (h : IsColimit t) {W : C} (f : t.pt ⟶ W) :
    h.homEquiv W f = (t.extend f).ι 
goal: (h.homEquiv W) f = (t.extend f).ι

full_name: CategoryTheory.Limits.IsColimit.homIso
code: /-- The universal property of a colimit cocone: a map `X ⟶ W` is the same as
  a cocone on `F` with cone point `W`. -/
def homIso (h : IsColimit t) (W : C) : ULift.{u₁} (t.pt ⟶ W : Type v₃) ≅ F ⟶ (const J).obj W 
goal: ULift.{u₁, v₃} (t.pt ⟶ W) ≅ F ⟶ (CategoryTheory.Functor.const J).obj W

full_name: CategoryTheory.Limits.IsColimit.homIso_hom
code: @[simp]
theorem homIso_hom (h : IsColimit t) {W : C} (f : ULift (t.pt ⟶ W)) :
    (IsColimit.homIso h W).hom f = (t.extend f.down).ι 
goal: (h.homIso W).hom f = (t.extend f.down).ι

full_name: CategoryTheory.Limits.IsColimit.natIso
code: /-- The colimit of `F` represents the functor taking `W` to
  the set of cocones on `F` with cone point `W`. -/
def natIso (h : IsColimit t) : coyoneda.obj (op t.pt) ⋙ uliftFunctor.{u₁} ≅ F.cocones 
goal: CategoryTheory.coyoneda.obj (Opposite.op t.pt) ⋙ CategoryTheory.uliftFunctor.{u₁, v₃} ≅ F.cocones

full_name: CategoryTheory.Limits.IsColimit.homIso'
code: /-- Another, more explicit, formulation of the universal property of a colimit cocone.
See also `homIso`. -/
def homIso' (h : IsColimit t) (W : C) :
    ULift.{u₁} (t.pt ⟶ W : Type v₃) ≅
      { p : ∀ j, F.obj j ⟶ W // ∀ {j j' : J} (f : j ⟶ j'), F.map f ≫ p j' = p j } 
goal: ULift.{u₁, v₃} (t.pt ⟶ W) ≅ { p // ∀ {j j' : J} (f : j ⟶ j'), F.map f ≫ p j' = p j }

full_name: CategoryTheory.Limits.IsColimit.ofFaithful
code: /-- 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. -/
def ofFaithful {t : Cocone F} {D : Type u₄} [Category.{v₄} D] (G : C ⥤ D) [G.Faithful]
    (ht : IsColimit (mapCocone G t)) (desc : ∀ s : Cocone F, t.pt ⟶ s.pt)
    (h : ∀ s, G.map (desc s) = ht.desc (mapCocone G s)) : IsColimit t 
goal: CategoryTheory.Limits.IsColimit t

full_name: CategoryTheory.Limits.IsColimit.mapCoconeEquiv
code: /-- If `F` and `G` are naturally isomorphic, then `F.mapCocone c` being a colimit implies
`G.mapCocone c` is also a colimit.
-/
def mapCoconeEquiv {D : Type u₄} [Category.{v₄} D] {K : J ⥤ C} {F G : C ⥤ D} (h : F ≅ G)
    {c : Cocone K} (t : IsColimit (mapCocone F c)) : IsColimit (mapCocone G c) 
goal: CategoryTheory.Limits.IsColimit (G.mapCocone c)

full_name: CategoryTheory.Limits.IsColimit.isoUniqueCoconeMorphism
code: /-- A cocone is a colimit cocone exactly if
there is a unique cocone morphism from any other cocone.
-/
def isoUniqueCoconeMorphism {t : Cocone F} : IsColimit t ≅ ∀ s, Unique (t ⟶ s) 
goal: CategoryTheory.Limits.IsColimit t ≅ (s : CategoryTheory.Limits.Cocone F) → Unique (t ⟶ s)

full_name: CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom
code: /-- If `F.cocones` is corepresented by `X`, each morphism `f : X ⟶ Y` gives a cocone with cone
point `Y`. -/
def coconeOfHom {Y : C} (f : X ⟶ Y) : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone
code: /-- If `F.cocones` is corepresented by `X`, each cocone `s` gives a morphism `X ⟶ s.pt`. -/
def homOfCocone (s : Cocone F) : X ⟶ s.pt 
goal: X ⟶ s.pt

full_name: CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom_homOfCocone
code: @[simp]
theorem coconeOfHom_homOfCocone (s : Cocone F) : coconeOfHom h (homOfCocone h s) = s 
goal: CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom h (CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone h s) = s

full_name: CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone_cooneOfHom
code: @[simp]
theorem homOfCocone_cooneOfHom {Y : C} (f : X ⟶ Y) : homOfCocone h (coconeOfHom h f) = f 
goal: CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone h (CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom h f) = f

full_name: CategoryTheory.Limits.IsColimit.OfNatIso.colimitCocone
code: /-- If `F.cocones` is corepresented by `X`, the cocone corresponding to the identity morphism on `X`
will be a colimit cocone. -/
def colimitCocone : Cocone F 
goal: CategoryTheory.Limits.Cocone F

full_name: CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom_fac
code: /-- If `F.cocones` is corepresented by `X`, the cocone corresponding to a morphism `f : Y ⟶ X` is
the colimit cocone extended by `f`. -/
theorem coconeOfHom_fac {Y : C} (f : X ⟶ Y) : coconeOfHom h f = (colimitCocone h).extend f 
goal: CategoryTheory.Limits.IsColimit.OfNatIso.coconeOfHom h f =
  (CategoryTheory.Limits.IsColimit.OfNatIso.colimitCocone h).extend f

full_name: CategoryTheory.Limits.IsColimit.OfNatIso.cocone_fac
code: /-- If `F.cocones` is corepresented by `X`, any cocone is the extension of the colimit cocone by the
corresponding morphism. -/
theorem cocone_fac (s : Cocone F) : (colimitCocone h).extend (homOfCocone h s) = s 
goal: (CategoryTheory.Limits.IsColimit.OfNatIso.colimitCocone h).extend
    (CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone h s) =
  s

full_name: CategoryTheory.Limits.IsColimit.ofNatIso
code: /-- If `F.cocones` is corepresentable, then the cocone corresponding to the identity morphism on
the representing object is a colimit cocone.
-/
def ofNatIso {X : C} (h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁} ≅ F.cocones) :
    IsColimit (colimitCocone h) 
goal: CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.IsColimit.OfNatIso.colimitCocone h)