[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cone F
t : (k : K) → IsLimit (((evaluation K C).obj k).mapCone c)
s : Cone F
X Y : K
f : X ⟶ Y
j : J
⊢ (s.pt.map f ≫ (fun k => IsLimit.lift (t k) { pt := s.pt.obj k, π := whiskerRight s.π ((evaluation K C).obj k) }) Y) ≫
      NatTrans.app (((evaluation K C).obj Y).mapCone c).π j =
    ((fun k => IsLimit.lift (t k) { pt := s.pt.obj k, π := whiskerRight s.π ((evaluation K C).obj k) }) X ≫
        c.pt.map f) ≫
      NatTrans.app (((evaluation K C).obj Y).mapCone c).π j
[PROOFSTEP]
rw [assoc, (t Y).fac _ j]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cone F
t : (k : K) → IsLimit (((evaluation K C).obj k).mapCone c)
s : Cone F
X Y : K
f : X ⟶ Y
j : J
⊢ s.pt.map f ≫ NatTrans.app { pt := s.pt.obj Y, π := whiskerRight s.π ((evaluation K C).obj Y) }.π j =
    ((fun k => IsLimit.lift (t k) { pt := s.pt.obj k, π := whiskerRight s.π ((evaluation K C).obj k) }) X ≫
        c.pt.map f) ≫
      NatTrans.app (((evaluation K C).obj Y).mapCone c).π j
[PROOFSTEP]
simpa using ((t X).fac_assoc ⟨s.pt.obj X, whiskerRight s.π ((evaluation K C).obj X)⟩ j _).symm
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cone F
t : (k : K) → IsLimit (((evaluation K C).obj k).mapCone c)
s : Cone F
j : J
⊢ (fun s =>
          NatTrans.mk fun k => IsLimit.lift (t k) { pt := s.pt.obj k, π := whiskerRight s.π ((evaluation K C).obj k) })
        s ≫
      NatTrans.app c.π j =
    NatTrans.app s.π j
[PROOFSTEP]
ext k
[GOAL]
case w.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cone F
t : (k : K) → IsLimit (((evaluation K C).obj k).mapCone c)
s : Cone F
j : J
k : K
⊢ NatTrans.app
      ((fun s =>
            NatTrans.mk fun k =>
              IsLimit.lift (t k) { pt := s.pt.obj k, π := whiskerRight s.π ((evaluation K C).obj k) })
          s ≫
        NatTrans.app c.π j)
      k =
    NatTrans.app (NatTrans.app s.π j) k
[PROOFSTEP]
exact (t k).fac _ j
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cone F
t : (k : K) → IsLimit (((evaluation K C).obj k).mapCone c)
s : Cone F
m : s.pt ⟶ c.pt
w : ∀ (j : J), m ≫ NatTrans.app c.π j = NatTrans.app s.π j
⊢ m =
    (fun s =>
        NatTrans.mk fun k => IsLimit.lift (t k) { pt := s.pt.obj k, π := whiskerRight s.π ((evaluation K C).obj k) })
      s
[PROOFSTEP]
ext x
[GOAL]
case w.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cone F
t : (k : K) → IsLimit (((evaluation K C).obj k).mapCone c)
s : Cone F
m : s.pt ⟶ c.pt
w : ∀ (j : J), m ≫ NatTrans.app c.π j = NatTrans.app s.π j
x : K
⊢ NatTrans.app m x =
    NatTrans.app
      ((fun s =>
          NatTrans.mk fun k => IsLimit.lift (t k) { pt := s.pt.obj k, π := whiskerRight s.π ((evaluation K C).obj k) })
        s)
      x
[PROOFSTEP]
exact
  (t x).hom_ext fun j =>
    (congr_app (w j) x).trans ((t x).fac ⟨s.pt.obj _, whiskerRight s.π ((evaluation K C).obj _)⟩ j).symm
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → LimitCone ((Functor.flip F).obj k)
k : K
j : J
⊢ { obj := fun k => (c k).cone.pt,
            map := fun {k₁ k₂} f =>
              IsLimit.lift (c k₂).isLimit { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ (Functor.flip F).map f } }.map
        (𝟙 k) ≫
      NatTrans.app (c k).cone.π j =
    𝟙
        ({ obj := fun k => (c k).cone.pt,
              map := fun {k₁ k₂} f =>
                IsLimit.lift (c k₂).isLimit { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ (Functor.flip F).map f } }.obj
          k) ≫
      NatTrans.app (c k).cone.π j
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → LimitCone ((Functor.flip F).obj k)
k : K
j : J
⊢ IsLimit.lift (c k).isLimit { pt := (c k).cone.pt, π := (c k).cone.π ≫ (Functor.flip F).map (𝟙 k) } ≫
      NatTrans.app (c k).cone.π j =
    𝟙 (c k).cone.pt ≫ NatTrans.app (c k).cone.π j
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → LimitCone ((Functor.flip F).obj k)
k₁ k₂ k₃ : K
f₁ : k₁ ⟶ k₂
f₂ : k₂ ⟶ k₃
j : J
⊢ { obj := fun k => (c k).cone.pt,
            map := fun {k₁ k₂} f =>
              IsLimit.lift (c k₂).isLimit { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ (Functor.flip F).map f } }.map
        (f₁ ≫ f₂) ≫
      NatTrans.app (c k₃).cone.π j =
    ({ obj := fun k => (c k).cone.pt,
              map := fun {k₁ k₂} f =>
                IsLimit.lift (c k₂).isLimit { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ (Functor.flip F).map f } }.map
          f₁ ≫
        { obj := fun k => (c k).cone.pt,
              map := fun {k₁ k₂} f =>
                IsLimit.lift (c k₂).isLimit { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ (Functor.flip F).map f } }.map
          f₂) ≫
      NatTrans.app (c k₃).cone.π j
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → LimitCone ((Functor.flip F).obj k)
j₁ j₂ : J
g : j₁ ⟶ j₂
⊢ ((const J).obj
            (Functor.mk
              { obj := fun k => (c k).cone.pt,
                map := fun {k₁ k₂} f =>
                  IsLimit.lift (c k₂).isLimit
                    { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ (Functor.flip F).map f } })).map
        g ≫
      (fun j => NatTrans.mk fun k => NatTrans.app (c k).cone.π j) j₂ =
    (fun j => NatTrans.mk fun k => NatTrans.app (c k).cone.π j) j₁ ≫ F.map g
[PROOFSTEP]
ext k
[GOAL]
case w.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → LimitCone ((Functor.flip F).obj k)
j₁ j₂ : J
g : j₁ ⟶ j₂
k : K
⊢ NatTrans.app
      (((const J).obj
              (Functor.mk
                { obj := fun k => (c k).cone.pt,
                  map := fun {k₁ k₂} f =>
                    IsLimit.lift (c k₂).isLimit
                      { pt := (c k₁).cone.pt, π := (c k₁).cone.π ≫ (Functor.flip F).map f } })).map
          g ≫
        (fun j => NatTrans.mk fun k => NatTrans.app (c k).cone.π j) j₂)
      k =
    NatTrans.app ((fun j => NatTrans.mk fun k => NatTrans.app (c k).cone.π j) j₁ ≫ F.map g) k
[PROOFSTEP]
exact (c k).cone.π.naturality g
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cocone F
t : (k : K) → IsColimit (((evaluation K C).obj k).mapCocone c)
s : Cocone F
X Y : K
f : X ⟶ Y
j : J
⊢ NatTrans.app (((evaluation K C).obj X).mapCocone c).ι j ≫
      c.pt.map f ≫
        (fun k => IsColimit.desc (t k) { pt := s.pt.obj k, ι := whiskerRight s.ι ((evaluation K C).obj k) }) Y =
    NatTrans.app (((evaluation K C).obj X).mapCocone c).ι j ≫
      (fun k => IsColimit.desc (t k) { pt := s.pt.obj k, ι := whiskerRight s.ι ((evaluation K C).obj k) }) X ≫
        s.pt.map f
[PROOFSTEP]
rw [(t X).fac_assoc _ j]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cocone F
t : (k : K) → IsColimit (((evaluation K C).obj k).mapCocone c)
s : Cocone F
X Y : K
f : X ⟶ Y
j : J
⊢ NatTrans.app (((evaluation K C).obj X).mapCocone c).ι j ≫
      c.pt.map f ≫
        (fun k => IsColimit.desc (t k) { pt := s.pt.obj k, ι := whiskerRight s.ι ((evaluation K C).obj k) }) Y =
    NatTrans.app { pt := s.pt.obj X, ι := whiskerRight s.ι ((evaluation K C).obj X) }.ι j ≫ s.pt.map f
[PROOFSTEP]
erw [← (c.ι.app j).naturality_assoc f]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cocone F
t : (k : K) → IsColimit (((evaluation K C).obj k).mapCocone c)
s : Cocone F
X Y : K
f : X ⟶ Y
j : J
⊢ (F.obj j).map f ≫
      NatTrans.app (NatTrans.app c.ι j) Y ≫
        (fun k => IsColimit.desc (t k) { pt := s.pt.obj k, ι := whiskerRight s.ι ((evaluation K C).obj k) }) Y =
    NatTrans.app { pt := s.pt.obj X, ι := whiskerRight s.ι ((evaluation K C).obj X) }.ι j ≫ s.pt.map f
[PROOFSTEP]
erw [(t Y).fac ⟨s.pt.obj _, whiskerRight s.ι _⟩ j]
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cocone F
t : (k : K) → IsColimit (((evaluation K C).obj k).mapCocone c)
s : Cocone F
X Y : K
f : X ⟶ Y
j : J
⊢ (F.obj j).map f ≫ NatTrans.app { pt := s.pt.obj Y, ι := whiskerRight s.ι ((evaluation K C).obj Y) }.ι j =
    NatTrans.app { pt := s.pt.obj X, ι := whiskerRight s.ι ((evaluation K C).obj X) }.ι j ≫ s.pt.map f
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cocone F
t : (k : K) → IsColimit (((evaluation K C).obj k).mapCocone c)
s : Cocone F
X Y : K
f : X ⟶ Y
j : J
⊢ (F.obj j).map f ≫ NatTrans.app (NatTrans.app s.ι j) Y = NatTrans.app (NatTrans.app s.ι j) X ≫ s.pt.map f
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cocone F
t : (k : K) → IsColimit (((evaluation K C).obj k).mapCocone c)
s : Cocone F
j : J
⊢ NatTrans.app c.ι j ≫
      (fun s =>
          NatTrans.mk fun k =>
            IsColimit.desc (t k) { pt := s.pt.obj k, ι := whiskerRight s.ι ((evaluation K C).obj k) })
        s =
    NatTrans.app s.ι j
[PROOFSTEP]
ext k
[GOAL]
case w.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cocone F
t : (k : K) → IsColimit (((evaluation K C).obj k).mapCocone c)
s : Cocone F
j : J
k : K
⊢ NatTrans.app
      (NatTrans.app c.ι j ≫
        (fun s =>
            NatTrans.mk fun k =>
              IsColimit.desc (t k) { pt := s.pt.obj k, ι := whiskerRight s.ι ((evaluation K C).obj k) })
          s)
      k =
    NatTrans.app (NatTrans.app s.ι j) k
[PROOFSTEP]
exact (t k).fac _ j
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cocone F
t : (k : K) → IsColimit (((evaluation K C).obj k).mapCocone c)
s : Cocone F
m : c.pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app c.ι j ≫ m = NatTrans.app s.ι j
⊢ m =
    (fun s =>
        NatTrans.mk fun k => IsColimit.desc (t k) { pt := s.pt.obj k, ι := whiskerRight s.ι ((evaluation K C).obj k) })
      s
[PROOFSTEP]
ext x
[GOAL]
case w.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : Cocone F
t : (k : K) → IsColimit (((evaluation K C).obj k).mapCocone c)
s : Cocone F
m : c.pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app c.ι j ≫ m = NatTrans.app s.ι j
x : K
⊢ NatTrans.app m x =
    NatTrans.app
      ((fun s =>
          NatTrans.mk fun k =>
            IsColimit.desc (t k) { pt := s.pt.obj k, ι := whiskerRight s.ι ((evaluation K C).obj k) })
        s)
      x
[PROOFSTEP]
exact
  (t x).hom_ext fun j =>
    (congr_app (w j) x).trans ((t x).fac ⟨s.pt.obj _, whiskerRight s.ι ((evaluation K C).obj _)⟩ j).symm
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone ((Functor.flip F).obj k)
k : K
j : J
⊢ NatTrans.app (c k).cocone.ι j ≫
      { obj := fun k => (c k).cocone.pt,
            map := fun {k₁ k₂} f =>
              IsColimit.desc (c k₁).isColimit
                { pt := (c k₂).cocone.pt, ι := (Functor.flip F).map f ≫ (c k₂).cocone.ι } }.map
        (𝟙 k) =
    NatTrans.app (c k).cocone.ι j ≫
      𝟙
        ({ obj := fun k => (c k).cocone.pt,
              map := fun {k₁ k₂} f =>
                IsColimit.desc (c k₁).isColimit
                  { pt := (c k₂).cocone.pt, ι := (Functor.flip F).map f ≫ (c k₂).cocone.ι } }.obj
          k)
[PROOFSTEP]
dsimp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone ((Functor.flip F).obj k)
k : K
j : J
⊢ NatTrans.app (c k).cocone.ι j ≫
      IsColimit.desc (c k).isColimit { pt := (c k).cocone.pt, ι := (Functor.flip F).map (𝟙 k) ≫ (c k).cocone.ι } =
    NatTrans.app (c k).cocone.ι j ≫ 𝟙 (c k).cocone.pt
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone ((Functor.flip F).obj k)
k₁ k₂ k₃ : K
f₁ : k₁ ⟶ k₂
f₂ : k₂ ⟶ k₃
j : J
⊢ NatTrans.app (c k₁).cocone.ι j ≫
      { obj := fun k => (c k).cocone.pt,
            map := fun {k₁ k₂} f =>
              IsColimit.desc (c k₁).isColimit
                { pt := (c k₂).cocone.pt, ι := (Functor.flip F).map f ≫ (c k₂).cocone.ι } }.map
        (f₁ ≫ f₂) =
    NatTrans.app (c k₁).cocone.ι j ≫
      { obj := fun k => (c k).cocone.pt,
              map := fun {k₁ k₂} f =>
                IsColimit.desc (c k₁).isColimit
                  { pt := (c k₂).cocone.pt, ι := (Functor.flip F).map f ≫ (c k₂).cocone.ι } }.map
          f₁ ≫
        { obj := fun k => (c k).cocone.pt,
              map := fun {k₁ k₂} f =>
                IsColimit.desc (c k₁).isColimit
                  { pt := (c k₂).cocone.pt, ι := (Functor.flip F).map f ≫ (c k₂).cocone.ι } }.map
          f₂
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone ((Functor.flip F).obj k)
j₁ j₂ : J
g : j₁ ⟶ j₂
⊢ F.map g ≫ (fun j => NatTrans.mk fun k => NatTrans.app (c k).cocone.ι j) j₂ =
    (fun j => NatTrans.mk fun k => NatTrans.app (c k).cocone.ι j) j₁ ≫
      ((const J).obj
            (Functor.mk
              { obj := fun k => (c k).cocone.pt,
                map := fun {k₁ k₂} f =>
                  IsColimit.desc (c k₁).isColimit
                    { pt := (c k₂).cocone.pt, ι := (Functor.flip F).map f ≫ (c k₂).cocone.ι } })).map
        g
[PROOFSTEP]
ext k
[GOAL]
case w.h
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : J ⥤ K ⥤ C
c : (k : K) → ColimitCocone ((Functor.flip F).obj k)
j₁ j₂ : J
g : j₁ ⟶ j₂
k : K
⊢ NatTrans.app (F.map g ≫ (fun j => NatTrans.mk fun k => NatTrans.app (c k).cocone.ι j) j₂) k =
    NatTrans.app
      ((fun j => NatTrans.mk fun k => NatTrans.app (c k).cocone.ι j) j₁ ≫
        ((const J).obj
              (Functor.mk
                { obj := fun k => (c k).cocone.pt,
                  map := fun {k₁ k₂} f =>
                    IsColimit.desc (c k₁).isColimit
                      { pt := (c k₂).cocone.pt, ι := (Functor.flip F).map f ≫ (c k₂).cocone.ι } })).map
          g)
      k
[PROOFSTEP]
exact (c k).cocone.ι.naturality g
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
k : K
F : J ⥤ K ⥤ C
⊢ PreservesLimit F ((evaluation K C).obj k)
[PROOFSTEP]
let X : (k : K) → LimitCone (Prefunctor.obj (Functor.flip F).toPrefunctor k) := fun k =>
  getLimitCone (Prefunctor.obj (Functor.flip F).toPrefunctor k)
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
k : K
F : J ⥤ K ⥤ C
X : (k : K) → LimitCone ((Functor.flip F).obj k) := fun k => getLimitCone ((Functor.flip F).obj k)
⊢ PreservesLimit F ((evaluation K C).obj k)
[PROOFSTEP]
exact
  preservesLimitOfPreservesLimitCone (combinedIsLimit _ _) <|
    IsLimit.ofIsoLimit (limit.isLimit _) (evaluateCombinedCones F X k).symm
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (limitObjIsoLimitCompEvaluation F k).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j = NatTrans.app (limit.π F j) k
[PROOFSTEP]
dsimp [limitObjIsoLimitCompEvaluation]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (preservesLimitIso ((evaluation K C).obj k) F).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j =
    NatTrans.app (limit.π F j) k
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (limitObjIsoLimitCompEvaluation F k).inv ≫ NatTrans.app (limit.π F j) k = limit.π (F ⋙ (evaluation K C).obj k) j
[PROOFSTEP]
dsimp [limitObjIsoLimitCompEvaluation]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ (preservesLimitIso ((evaluation K C).obj k) F).inv ≫ NatTrans.app (limit.π F j) k =
    limit.π (F ⋙ (evaluation K C).obj k) j
[PROOFSTEP]
rw [Iso.inv_comp_eq]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ NatTrans.app (limit.π F j) k =
    (preservesLimitIso ((evaluation K C).obj k) F).hom ≫ limit.π (F ⋙ (evaluation K C).obj k) j
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
⊢ (limit F).map f ≫ (limitObjIsoLimitCompEvaluation F j).hom =
    (limitObjIsoLimitCompEvaluation F i).hom ≫ limMap (whiskerLeft F ((evaluation K C).map f))
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
j✝ : J
⊢ ((limit F).map f ≫ (limitObjIsoLimitCompEvaluation F j).hom) ≫ limit.π (F ⋙ (evaluation K C).obj j) j✝ =
    ((limitObjIsoLimitCompEvaluation F i).hom ≫ limMap (whiskerLeft F ((evaluation K C).map f))) ≫
      limit.π (F ⋙ (evaluation K C).obj j) j✝
[PROOFSTEP]
dsimp
[GOAL]
case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
j✝ : J
⊢ ((limit F).map f ≫ (limitObjIsoLimitCompEvaluation F j).hom) ≫ limit.π (F ⋙ (evaluation K C).obj j) j✝ =
    ((limitObjIsoLimitCompEvaluation F i).hom ≫ limMap (whiskerLeft F ((evaluation K C).map f))) ≫
      limit.π (F ⋙ (evaluation K C).obj j) j✝
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimitsOfShape J C
i j : K
F : J ⥤ K ⥤ C
f : i ⟶ j
⊢ (limitObjIsoLimitCompEvaluation F i).inv ≫ (limit F).map f =
    limMap (whiskerLeft F ((evaluation K C).map f)) ≫ (limitObjIsoLimitCompEvaluation F j).inv
[PROOFSTEP]
rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv, limit_map_limitObjIsoLimitCompEvaluation_hom]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ NatTrans.app (limit.π H j) k = g ≫ NatTrans.app (limit.π H j) k
⊢ f = g
[PROOFSTEP]
apply (cancel_mono (limitObjIsoLimitCompEvaluation H k).hom).1
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ NatTrans.app (limit.π H j) k = g ≫ NatTrans.app (limit.π H j) k
⊢ f ≫ (limitObjIsoLimitCompEvaluation H k).hom = g ≫ (limitObjIsoLimitCompEvaluation H k).hom
[PROOFSTEP]
ext j
[GOAL]
case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasLimitsOfShape J C
k : K
W : C
f g : W ⟶ (limit H).obj k
w : ∀ (j : J), f ≫ NatTrans.app (limit.π H j) k = g ≫ NatTrans.app (limit.π H j) k
j : J
⊢ (f ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j =
    (g ≫ (limitObjIsoLimitCompEvaluation H k).hom) ≫ limit.π (H ⋙ (evaluation K C).obj k) j
[PROOFSTEP]
simpa using w j
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
k : K
F : J ⥤ K ⥤ C
⊢ PreservesColimit F ((evaluation K C).obj k)
[PROOFSTEP]
let X : (k : K) → ColimitCocone (Prefunctor.obj (Functor.flip F).toPrefunctor k) := fun k =>
  getColimitCocone (Prefunctor.obj (Functor.flip F).toPrefunctor k)
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
k : K
F : J ⥤ K ⥤ C
X : (k : K) → ColimitCocone ((Functor.flip F).obj k) := fun k => getColimitCocone ((Functor.flip F).obj k)
⊢ PreservesColimit F ((evaluation K C).obj k)
[PROOFSTEP]
refine
  preservesColimitOfPreservesColimitCocone (combinedIsColimit _ _) <|
    IsColimit.ofIsoColimit (colimit.isColimit _) (evaluateCombinedCocones F X k).symm
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ colimit.ι (F ⋙ (evaluation K C).obj k) j ≫ (colimitObjIsoColimitCompEvaluation F k).inv =
    NatTrans.app (colimit.ι F j) k
[PROOFSTEP]
dsimp [colimitObjIsoColimitCompEvaluation]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ colimit.ι (F ⋙ (evaluation K C).obj k) j ≫ (preservesColimitIso ((evaluation K C).obj k) F).inv =
    NatTrans.app (colimit.ι F j) k
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ NatTrans.app (colimit.ι F j) k ≫ (colimitObjIsoColimitCompEvaluation F k).hom =
    colimit.ι (F ⋙ (evaluation K C).obj k) j
[PROOFSTEP]
dsimp [colimitObjIsoColimitCompEvaluation]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ NatTrans.app (colimit.ι F j) k ≫ (preservesColimitIso ((evaluation K C).obj k) F).hom =
    colimit.ι (F ⋙ (evaluation K C).obj k) j
[PROOFSTEP]
rw [← Iso.eq_comp_inv]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
j : J
k : K
⊢ NatTrans.app (colimit.ι F j) k =
    colimit.ι (F ⋙ (evaluation K C).obj k) j ≫ (preservesColimitIso ((evaluation K C).obj k) F).inv
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
i j : K
f : i ⟶ j
⊢ (colimitObjIsoColimitCompEvaluation F i).inv ≫ (colimit F).map f =
    colimMap (whiskerLeft F ((evaluation K C).map f)) ≫ (colimitObjIsoColimitCompEvaluation F j).inv
[PROOFSTEP]
ext
[GOAL]
case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
i j : K
f : i ⟶ j
j✝ : J
⊢ colimit.ι (F ⋙ (evaluation K C).obj i) j✝ ≫ (colimitObjIsoColimitCompEvaluation F i).inv ≫ (colimit F).map f =
    colimit.ι (F ⋙ (evaluation K C).obj i) j✝ ≫
      colimMap (whiskerLeft F ((evaluation K C).map f)) ≫ (colimitObjIsoColimitCompEvaluation F j).inv
[PROOFSTEP]
dsimp
[GOAL]
case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
i j : K
f : i ⟶ j
j✝ : J
⊢ colimit.ι (F ⋙ (evaluation K C).obj i) j✝ ≫ (colimitObjIsoColimitCompEvaluation F i).inv ≫ (colimit F).map f =
    colimit.ι (F ⋙ (evaluation K C).obj i) j✝ ≫
      colimMap (whiskerLeft F ((evaluation K C).map f)) ≫ (colimitObjIsoColimitCompEvaluation F j).inv
[PROOFSTEP]
simp
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimitsOfShape J C
F : J ⥤ K ⥤ C
i j : K
f : i ⟶ j
⊢ (colimit F).map f ≫ (colimitObjIsoColimitCompEvaluation F j).hom =
    (colimitObjIsoColimitCompEvaluation F i).hom ≫ colimMap (whiskerLeft F ((evaluation K C).map f))
[PROOFSTEP]
rw [← Iso.inv_comp_eq, ← Category.assoc, ← Iso.eq_comp_inv, colimitObjIsoColimitCompEvaluation_inv_colimit_map]
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasColimitsOfShape J C
k : K
W : C
f g : (colimit H).obj k ⟶ W
w : ∀ (j : J), NatTrans.app (colimit.ι H j) k ≫ f = NatTrans.app (colimit.ι H j) k ≫ g
⊢ f = g
[PROOFSTEP]
apply (cancel_epi (colimitObjIsoColimitCompEvaluation H k).inv).1
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasColimitsOfShape J C
k : K
W : C
f g : (colimit H).obj k ⟶ W
w : ∀ (j : J), NatTrans.app (colimit.ι H j) k ≫ f = NatTrans.app (colimit.ι H j) k ≫ g
⊢ (colimitObjIsoColimitCompEvaluation H k).inv ≫ f = (colimitObjIsoColimitCompEvaluation H k).inv ≫ g
[PROOFSTEP]
ext j
[GOAL]
case w
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
H : J ⥤ K ⥤ C
inst✝ : HasColimitsOfShape J C
k : K
W : C
f g : (colimit H).obj k ⟶ W
w : ∀ (j : J), NatTrans.app (colimit.ι H j) k ≫ f = NatTrans.app (colimit.ι H j) k ≫ g
j : J
⊢ colimit.ι (H ⋙ (evaluation K C).obj k) j ≫ (colimitObjIsoColimitCompEvaluation H k).inv ≫ f =
    colimit.ι (H ⋙ (evaluation K C).obj k) j ≫ (colimitObjIsoColimitCompEvaluation H k).inv ≫ g
[PROOFSTEP]
simpa using w j
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J✝ : Type u₁
inst✝² : Category.{v₁, u₁} J✝
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimits C
k : K
J : Type v
𝒥 : Category.{v, v} J
⊢ PreservesLimitsOfShape J ((evaluation K C).obj k)
[PROOFSTEP]
skip
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J✝ : Type u₁
inst✝² : Category.{v₁, u₁} J✝
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasLimits C
k : K
J : Type v
𝒥 : Category.{v, v} J
⊢ PreservesLimitsOfShape J ((evaluation K C).obj k)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : D ⥤ K ⥤ C
G : J ⥤ D
H : (k : K) → PreservesLimit G (F ⋙ (evaluation K C).obj k)
c : Cone G
hc : IsLimit c
⊢ IsLimit (F.mapCone c)
[PROOFSTEP]
apply evaluationJointlyReflectsLimits
[GOAL]
case t
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : D ⥤ K ⥤ C
G : J ⥤ D
H : (k : K) → PreservesLimit G (F ⋙ (evaluation K C).obj k)
c : Cone G
hc : IsLimit c
⊢ (k : K) → IsLimit (((evaluation K C).obj k).mapCone (F.mapCone c))
[PROOFSTEP]
intro X
[GOAL]
case t
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : D ⥤ K ⥤ C
G : J ⥤ D
H : (k : K) → PreservesLimit G (F ⋙ (evaluation K C).obj k)
c : Cone G
hc : IsLimit c
X : K
⊢ IsLimit (((evaluation K C).obj X).mapCone (F.mapCone c))
[PROOFSTEP]
haveI := H X
[GOAL]
case t
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : D ⥤ K ⥤ C
G : J ⥤ D
H : (k : K) → PreservesLimit G (F ⋙ (evaluation K C).obj k)
c : Cone G
hc : IsLimit c
X : K
this : PreservesLimit G (F ⋙ (evaluation K C).obj X)
⊢ IsLimit (((evaluation K C).obj X).mapCone (F.mapCone c))
[PROOFSTEP]
change IsLimit ((F ⋙ (evaluation K C).obj X).mapCone c)
[GOAL]
case t
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : D ⥤ K ⥤ C
G : J ⥤ D
H : (k : K) → PreservesLimit G (F ⋙ (evaluation K C).obj k)
c : Cone G
hc : IsLimit c
X : K
this : PreservesLimit G (F ⋙ (evaluation K C).obj X)
⊢ IsLimit ((F ⋙ (evaluation K C).obj X).mapCone c)
[PROOFSTEP]
exact PreservesLimit.preserves hc
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimits C
k : K
⊢ {J : Type v} → [inst : Category.{v, v} J] → PreservesColimitsOfShape J ((evaluation K C).obj k)
[PROOFSTEP]
skip
[GOAL]
C : Type u
inst✝⁴ : Category.{v, u} C
D : Type u'
inst✝³ : Category.{v', u'} D
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
inst✝ : HasColimits C
k : K
⊢ {J : Type v} → [inst : Category.{v, v} J] → PreservesColimitsOfShape J ((evaluation K C).obj k)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : D ⥤ K ⥤ C
G : J ⥤ D
H : (k : K) → PreservesColimit G (F ⋙ (evaluation K C).obj k)
c : Cocone G
hc : IsColimit c
⊢ IsColimit (F.mapCocone c)
[PROOFSTEP]
apply evaluationJointlyReflectsColimits
[GOAL]
case t
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : D ⥤ K ⥤ C
G : J ⥤ D
H : (k : K) → PreservesColimit G (F ⋙ (evaluation K C).obj k)
c : Cocone G
hc : IsColimit c
⊢ (k : K) → IsColimit (((evaluation K C).obj k).mapCocone (F.mapCocone c))
[PROOFSTEP]
intro X
[GOAL]
case t
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : D ⥤ K ⥤ C
G : J ⥤ D
H : (k : K) → PreservesColimit G (F ⋙ (evaluation K C).obj k)
c : Cocone G
hc : IsColimit c
X : K
⊢ IsColimit (((evaluation K C).obj X).mapCocone (F.mapCocone c))
[PROOFSTEP]
haveI := H X
[GOAL]
case t
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : D ⥤ K ⥤ C
G : J ⥤ D
H : (k : K) → PreservesColimit G (F ⋙ (evaluation K C).obj k)
c : Cocone G
hc : IsColimit c
X : K
this : PreservesColimit G (F ⋙ (evaluation K C).obj X)
⊢ IsColimit (((evaluation K C).obj X).mapCocone (F.mapCocone c))
[PROOFSTEP]
change IsColimit ((F ⋙ (evaluation K C).obj X).mapCocone c)
[GOAL]
case t
C : Type u
inst✝³ : Category.{v, u} C
D : Type u'
inst✝² : Category.{v', u'} D
J : Type u₁
inst✝¹ : Category.{v₁, u₁} J
K : Type u₂
inst✝ : Category.{v₂, u₂} K
F : D ⥤ K ⥤ C
G : J ⥤ D
H : (k : K) → PreservesColimit G (F ⋙ (evaluation K C).obj k)
c : Cocone G
hc : IsColimit c
X : K
this : PreservesColimit G (F ⋙ (evaluation K C).obj X)
⊢ IsColimit ((F ⋙ (evaluation K C).obj X).mapCocone c)
[PROOFSTEP]
exact PreservesColimit.preserves hc