[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
⊢ ∀ (a b : IsLimit t), a = b
[PROOFSTEP]
intro P Q
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
P Q : IsLimit t
⊢ P = Q
[PROOFSTEP]
cases P
[GOAL]
case mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
Q : IsLimit t
lift✝ : (s : Cone F) → s.pt ⟶ t.pt
fac✝ : ∀ (s : Cone F) (j : J), lift✝ s ≫ NatTrans.app t.π j = NatTrans.app s.π j
uniq✝ : ∀ (s : Cone F) (m : s.pt ⟶ t.pt), (∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j) → m = lift✝ s
⊢ mk lift✝ = Q
[PROOFSTEP]
cases Q
[GOAL]
case mk.mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
lift✝¹ : (s : Cone F) → s.pt ⟶ t.pt
fac✝¹ : ∀ (s : Cone F) (j : J), lift✝¹ s ≫ NatTrans.app t.π j = NatTrans.app s.π j
uniq✝¹ : ∀ (s : Cone F) (m : s.pt ⟶ t.pt), (∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j) → m = lift✝¹ s
lift✝ : (s : Cone F) → s.pt ⟶ t.pt
fac✝ : ∀ (s : Cone F) (j : J), lift✝ s ≫ NatTrans.app t.π j = NatTrans.app s.π j
uniq✝ : ∀ (s : Cone F) (m : s.pt ⟶ t.pt), (∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j) → m = lift✝ s
⊢ mk lift✝¹ = mk lift✝
[PROOFSTEP]
congr
[GOAL]
case mk.mk.e_lift
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
lift✝¹ : (s : Cone F) → s.pt ⟶ t.pt
fac✝¹ : ∀ (s : Cone F) (j : J), lift✝¹ s ≫ NatTrans.app t.π j = NatTrans.app s.π j
uniq✝¹ : ∀ (s : Cone F) (m : s.pt ⟶ t.pt), (∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j) → m = lift✝¹ s
lift✝ : (s : Cone F) → s.pt ⟶ t.pt
fac✝ : ∀ (s : Cone F) (j : J), lift✝ s ≫ NatTrans.app t.π j = NatTrans.app s.π j
uniq✝ : ∀ (s : Cone F) (m : s.pt ⟶ t.pt), (∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j) → m = lift✝ s
⊢ lift✝¹ = lift✝
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cone F
h : IsLimit t
f f' : s ⟶ t
⊢ ∀ {g : s ⟶ t}, g = liftConeMorphism h s
[PROOFSTEP]
intro g
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cone F
h : IsLimit t
f f' g : s ⟶ t
⊢ g = liftConeMorphism h s
[PROOFSTEP]
apply ConeMorphism.ext
[GOAL]
case w
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cone F
h : IsLimit t
f f' g : s ⟶ t
⊢ g.Hom = (liftConeMorphism h s).Hom
[PROOFSTEP]
exact h.uniq _ _ g.w
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
ht : ∀ (s : Cone F), ∃! l, ∀ (j : J), l ≫ NatTrans.app t.π j = NatTrans.app s.π j
⊢ IsLimit t
[PROOFSTEP]
choose s hs hs' using ht
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
s : (s : Cone F) → s.pt ⟶ t.pt
hs : ∀ (s_1 : Cone F), (fun l => ∀ (j : J), l ≫ NatTrans.app t.π j = NatTrans.app s_1.π j) (s s_1)
hs' :
  ∀ (s_1 : Cone F) (y : s_1.pt ⟶ t.pt),
    (fun l => ∀ (j : J), l ≫ NatTrans.app t.π j = NatTrans.app s_1.π j) y → y = s s_1
⊢ IsLimit t
[PROOFSTEP]
exact ⟨s, hs, hs'⟩
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
lift : (s : Cone F) → s ⟶ t
uniq : ∀ (s : Cone F) (m : s ⟶ t), m = lift s
s : Cone F
m : s.pt ⟶ t.pt
w : ∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j
⊢ ConeMorphism.mk m = lift s
[PROOFSTEP]
apply uniq
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r s t : Cone F
P : IsLimit s
Q : IsLimit t
⊢ ∀ (j : J), (lift P r ≫ (conePointUniqueUpToIso P Q).hom) ≫ NatTrans.app t.π j = NatTrans.app r.π j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r s t : Cone F
P : IsLimit s
Q : IsLimit t
⊢ ∀ (j : J), (lift Q r ≫ (conePointUniqueUpToIso P Q).inv) ≫ NatTrans.app s.π j = NatTrans.app r.π j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cone F
P : IsLimit r
i : r ≅ t
s : Cone F
m : s ⟶ t
⊢ m = (fun s => liftConeMorphism P s ≫ i.hom) s
[PROOFSTEP]
rw [← i.comp_inv_eq]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cone F
P : IsLimit r
i : r ≅ t
s : Cone F
m : s ⟶ t
⊢ m ≫ i.inv = liftConeMorphism P s
[PROOFSTEP]
apply P.uniq_cone_morphism
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cone F
i : r ≅ t
⊢ Function.LeftInverse (fun h => ofIsoLimit h i.symm) fun h => ofIsoLimit h i
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cone F
i : r ≅ t
⊢ Function.RightInverse (fun h => ofIsoLimit h i.symm) fun h => ofIsoLimit h i
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cone F
P : IsLimit r
i : IsIso (lift P t)
⊢ r ≅ t
[PROOFSTEP]
haveI : IsIso (P.liftConeMorphism t).Hom := i
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cone F
P : IsLimit r
i : IsIso (lift P t)
this : IsIso (liftConeMorphism P t).Hom
⊢ r ≅ t
[PROOFSTEP]
haveI : IsIso (P.liftConeMorphism t) := Cones.cone_iso_of_hom_iso _
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cone F
P : IsLimit r
i : IsIso (lift P t)
this✝ : IsIso (liftConeMorphism P t).Hom
this : IsIso (liftConeMorphism P t)
⊢ r ≅ t
[PROOFSTEP]
symm
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cone F
P : IsLimit r
i : IsIso (lift P t)
this✝ : IsIso (liftConeMorphism P t).Hom
this : IsIso (liftConeMorphism P t)
⊢ t ≅ r
[PROOFSTEP]
apply asIso (P.liftConeMorphism t)
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ NatTrans.app t.π j = f' ≫ NatTrans.app t.π j
⊢ f = f'
[PROOFSTEP]
rw [h.hom_lift f, h.hom_lift f']
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ NatTrans.app t.π j = f' ≫ NatTrans.app t.π j
⊢ lift h { pt := W, π := NatTrans.mk fun b => f ≫ NatTrans.app t.π b } =
    lift h { pt := W, π := NatTrans.mk fun b => f' ≫ NatTrans.app t.π b }
[PROOFSTEP]
congr
[GOAL]
case h.e_8.h.e_π.e_app
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f f' : W ⟶ t.pt
w : ∀ (j : J), f ≫ NatTrans.app t.π j = f' ≫ NatTrans.app t.π j
⊢ (fun b => f ≫ NatTrans.app t.π b) = fun b => f' ≫ NatTrans.app t.π b
[PROOFSTEP]
exact funext w
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
D : Type u₄
inst✝ : Category.{v₄, u₄} D
G : K ⥤ D
h : Cone G ≌ Cone F
c : Cone G
⊢ Function.LeftInverse (ofRightAdjoint h.functor) fun P =>
    ofIsoLimit (ofRightAdjoint h.inverse P) (h.unitIso.symm.app c)
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
D : Type u₄
inst✝ : Category.{v₄, u₄} D
G : K ⥤ D
h : Cone G ≌ Cone F
c : Cone G
⊢ Function.RightInverse (ofRightAdjoint h.functor) fun P =>
    ofIsoLimit (ofRightAdjoint h.inverse P) (h.unitIso.symm.app c)
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
⊢ ∀ (j : J), (map s Q w.hom ≫ map t P w.inv) ≫ NatTrans.app s.π j = 𝟙 s.pt ≫ NatTrans.app s.π j
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
⊢ ∀ (j : J), (map t P w.inv ≫ map s Q w.hom) ≫ NatTrans.app t.π j = 𝟙 t.pt ≫ NatTrans.app t.π j
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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 ≫ NatTrans.app t.π j = NatTrans.app s.π j ≫ NatTrans.app w.hom j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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 ≫ NatTrans.app s.π j = NatTrans.app t.π j ≫ NatTrans.app w.inv j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
r s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
⊢ ∀ (j : J), (lift P r ≫ (conePointsIsoOfNatIso P Q w).hom) ≫ NatTrans.app t.π j = map r Q w.hom ≫ NatTrans.app t.π j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
r s : Cone G
t : Cone F
P : IsLimit t
Q : IsLimit s
w : F ≅ G
⊢ ∀ (j : J), (lift Q r ≫ (conePointsIsoOfNatIso P Q w).inv) ≫ NatTrans.app t.π j = map r P w.inv ≫ NatTrans.app t.π j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t s : Cone F
e : K ≌ J
⊢ Function.LeftInverse (ofWhiskerEquivalence e) fun h => whiskerEquivalence h e
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t s : Cone F
e : K ≌ J
⊢ Function.RightInverse (ofWhiskerEquivalence e) fun h => whiskerEquivalence h e
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
⊢ lift Q ((Cones.equivalenceOfReindexing (Equivalence.symm e) w').functor.obj s) ≫
      lift P ((Cones.equivalenceOfReindexing e w).functor.obj t) =
    𝟙 s.pt
[PROOFSTEP]
apply hom_ext P
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
⊢ ∀ (j : J),
    (lift Q ((Cones.equivalenceOfReindexing (Equivalence.symm e) w').functor.obj s) ≫
          lift P ((Cones.equivalenceOfReindexing e w).functor.obj t)) ≫
        NatTrans.app s.π j =
      𝟙 s.pt ≫ NatTrans.app s.π j
[PROOFSTEP]
intro j
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
⊢ (lift Q ((Cones.equivalenceOfReindexing (Equivalence.symm e) w').functor.obj s) ≫
        lift P ((Cones.equivalenceOfReindexing e w).functor.obj t)) ≫
      NatTrans.app s.π j =
    𝟙 s.pt ≫ NatTrans.app s.π j
[PROOFSTEP]
dsimp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
⊢ (lift Q ((Cones.postcompose (whiskerLeft e.inverse w.inv ≫ (invFunIdAssoc e G).hom)).obj (Cone.whisker e.inverse s)) ≫
        lift P ((Cones.postcompose w.hom).obj (Cone.whisker e.functor t))) ≫
      NatTrans.app s.π j =
    𝟙 s.pt ≫ NatTrans.app s.π j
[PROOFSTEP]
simp only [Limits.Cone.whisker_π, Limits.Cones.postcompose_obj_π, fac, whiskerLeft_app, assoc, id_comp,
  invFunIdAssoc_hom_app, fac_assoc, NatTrans.comp_app]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
⊢ NatTrans.app s.π (e.inverse.obj (e.functor.obj j)) ≫
      NatTrans.app w.inv (e.inverse.obj (e.functor.obj j)) ≫
        G.map (NatTrans.app (counit e) (e.functor.obj j)) ≫ NatTrans.app w.hom j =
    NatTrans.app s.π j
[PROOFSTEP]
rw [counit_app_functor, ← Functor.comp_map]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
⊢ NatTrans.app s.π (e.inverse.obj (e.functor.obj j)) ≫
      NatTrans.app w.inv (e.inverse.obj (e.functor.obj j)) ≫
        (e.functor ⋙ G).map (NatTrans.app (unitInv e) j) ≫ NatTrans.app w.hom j =
    NatTrans.app s.π j
[PROOFSTEP]
have l : NatTrans.app w.hom j = NatTrans.app w.hom (Prefunctor.obj (𝟭 J).toPrefunctor j) := by dsimp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
⊢ NatTrans.app w.hom j = NatTrans.app w.hom ((𝟭 J).obj j)
[PROOFSTEP]
dsimp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
l : NatTrans.app w.hom j = NatTrans.app w.hom ((𝟭 J).obj j)
⊢ NatTrans.app s.π (e.inverse.obj (e.functor.obj j)) ≫
      NatTrans.app w.inv (e.inverse.obj (e.functor.obj j)) ≫
        (e.functor ⋙ G).map (NatTrans.app (unitInv e) j) ≫ NatTrans.app w.hom j =
    NatTrans.app s.π j
[PROOFSTEP]
rw [l, w.hom.naturality]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
l : NatTrans.app w.hom j = NatTrans.app w.hom ((𝟭 J).obj j)
⊢ NatTrans.app s.π (e.inverse.obj (e.functor.obj j)) ≫
      NatTrans.app w.inv (e.inverse.obj (e.functor.obj j)) ≫
        NatTrans.app w.hom ((e.functor ⋙ e.inverse).obj j) ≫ F.map (NatTrans.app (unitInv e) j) =
    NatTrans.app s.π j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
⊢ lift P ((Cones.equivalenceOfReindexing e w).functor.obj t) ≫
      lift Q ((Cones.equivalenceOfReindexing (Equivalence.symm e) w').functor.obj s) =
    𝟙 t.pt
[PROOFSTEP]
apply hom_ext Q
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
⊢ ∀ (j : K),
    (lift P ((Cones.equivalenceOfReindexing e w).functor.obj t) ≫
          lift Q ((Cones.equivalenceOfReindexing (Equivalence.symm e) w').functor.obj s)) ≫
        NatTrans.app t.π j =
      𝟙 t.pt ≫ NatTrans.app t.π j
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
⊢ ((fun f => (Cone.extend t f.down).π) ≫ fun π => { down := lift h { pt := W, π := π } }) = 𝟙 (ULift (W ⟶ t.pt))
[PROOFSTEP]
funext f
[GOAL]
case h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f : ULift (W ⟶ t.pt)
⊢ ((fun f => (Cone.extend t f.down).π) ≫ fun π => { down := lift h { pt := W, π := π } }) f = 𝟙 (ULift (W ⟶ t.pt)) f
[PROOFSTEP]
apply ULift.ext
[GOAL]
case h.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f : ULift (W ⟶ t.pt)
⊢ (((fun f => (Cone.extend t f.down).π) ≫ fun π => { down := lift h { pt := W, π := π } }) f).down =
    (𝟙 (ULift (W ⟶ t.pt)) f).down
[PROOFSTEP]
apply h.hom_ext
[GOAL]
case h.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f : ULift (W ⟶ t.pt)
⊢ ∀ (j : J),
    (((fun f => (Cone.extend t f.down).π) ≫ fun π => { down := lift h { pt := W, π := π } }) f).down ≫
        NatTrans.app t.π j =
      (𝟙 (ULift (W ⟶ t.pt)) f).down ≫ NatTrans.app t.π j
[PROOFSTEP]
intro j
[GOAL]
case h.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
f : ULift (W ⟶ t.pt)
j : J
⊢ (((fun f => (Cone.extend t f.down).π) ≫ fun π => { down := lift h { pt := W, π := π } }) f).down ≫
      NatTrans.app t.π j =
    (𝟙 (ULift (W ⟶ t.pt)) f).down ≫ NatTrans.app t.π j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
π : (const J).obj W ⟶ F
j✝ j'✝ : J
f : j✝ ⟶ j'✝
⊢ (fun j => NatTrans.app π j) j✝ ≫ F.map f = (fun j => NatTrans.app π j) j'✝
[PROOFSTEP]
convert ← (π.naturality f).symm
[GOAL]
case h.e'_3.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
π : (const J).obj W ⟶ F
j✝ j'✝ : J
f : j✝ ⟶ j'✝
e_1✝ : (((const J).obj W).obj j✝ ⟶ F.obj j'✝) = (W ⟶ F.obj j'✝)
⊢ ((const J).obj W).map f ≫ NatTrans.app π j'✝ = (fun j => NatTrans.app π j) j'✝
[PROOFSTEP]
apply id_comp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
p : { p // ∀ {j j' : J} (f : j ⟶ j'), p j ≫ F.map f = p j' }
j j' : J
f : j ⟶ j'
⊢ ((const J).obj W).map f ≫ (fun j => ↑p j) j' = (fun j => ↑p j) j ≫ F.map f
[PROOFSTEP]
dsimp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
p : { p // ∀ {j j' : J} (f : j ⟶ j'), p j ≫ F.map f = p j' }
j j' : J
f : j ⟶ j'
⊢ 𝟙 W ≫ ↑p j' = ↑p j ≫ F.map f
[PROOFSTEP]
rw [id_comp]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
h : IsLimit t
W : C
p : { p // ∀ {j j' : J} (f : j ⟶ j'), p j ≫ F.map f = p j' }
j j' : J
f : j ⟶ j'
⊢ ↑p j' = ↑p j ≫ F.map f
[PROOFSTEP]
exact (p.2 f).symm
[GOAL]
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsLimit (G.mapCone t)
lift : (s : Cone F) → s.pt ⟶ t.pt
h : ∀ (s : Cone F), G.map (lift s) = CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s)
s : Cone F
j : J
⊢ lift s ≫ NatTrans.app t.π j = NatTrans.app s.π j
[PROOFSTEP]
apply G.map_injective
[GOAL]
case a
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsLimit (G.mapCone t)
lift : (s : Cone F) → s.pt ⟶ t.pt
h : ∀ (s : Cone F), G.map (lift s) = CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s)
s : Cone F
j : J
⊢ G.map (lift s ≫ NatTrans.app t.π j) = G.map (NatTrans.app s.π j)
[PROOFSTEP]
rw [G.map_comp, h]
[GOAL]
case a
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsLimit (G.mapCone t)
lift : (s : Cone F) → s.pt ⟶ t.pt
h : ∀ (s : Cone F), G.map (lift s) = CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s)
s : Cone F
j : J
⊢ CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s) ≫ G.map (NatTrans.app t.π j) = G.map (NatTrans.app s.π j)
[PROOFSTEP]
apply ht.fac
[GOAL]
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsLimit (G.mapCone t)
lift : (s : Cone F) → s.pt ⟶ t.pt
h : ∀ (s : Cone F), G.map (lift s) = CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s)
s : Cone F
m : s.pt ⟶ t.pt
w : ∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j
⊢ m = lift s
[PROOFSTEP]
apply G.map_injective
[GOAL]
case a
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsLimit (G.mapCone t)
lift : (s : Cone F) → s.pt ⟶ t.pt
h : ∀ (s : Cone F), G.map (lift s) = CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s)
s : Cone F
m : s.pt ⟶ t.pt
w : ∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j
⊢ G.map m = G.map (lift s)
[PROOFSTEP]
rw [h]
[GOAL]
case a
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsLimit (G.mapCone t)
lift : (s : Cone F) → s.pt ⟶ t.pt
h : ∀ (s : Cone F), G.map (lift s) = CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s)
s : Cone F
m : s.pt ⟶ t.pt
w : ∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j
⊢ G.map m = CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s)
[PROOFSTEP]
refine' ht.uniq (mapCone G s) _ fun j => _
[GOAL]
case a
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsLimit (G.mapCone t)
lift : (s : Cone F) → s.pt ⟶ t.pt
h : ∀ (s : Cone F), G.map (lift s) = CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s)
s : Cone F
m : s.pt ⟶ t.pt
w : ∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j
j : J
⊢ G.map m ≫ NatTrans.app (G.mapCone t).π j = NatTrans.app (G.mapCone s).π j
[PROOFSTEP]
convert ← congrArg (fun f => G.map f) (w j)
[GOAL]
case h.e'_2.h
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsLimit (G.mapCone t)
lift : (s : Cone F) → s.pt ⟶ t.pt
h : ∀ (s : Cone F), G.map (lift s) = CategoryTheory.Limits.IsLimit.lift ht (G.mapCone s)
s : Cone F
m : s.pt ⟶ t.pt
w : ∀ (j : J), m ≫ NatTrans.app t.π j = NatTrans.app s.π j
j : J
e_1✝ : (G.obj s.pt ⟶ G.obj (F.obj j)) = ((G.mapCone s).pt ⟶ (F ⋙ G).obj j)
⊢ G.map (m ≫ NatTrans.app t.π j) = G.map m ≫ NatTrans.app (G.mapCone t).π j
[PROOFSTEP]
apply G.map_comp
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝² : Category.{v₂, u₂} K✝
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
D : Type u₄
inst✝ : Category.{v₄, u₄} D
K : J ⥤ C
F G : C ⥤ D
h : F ≅ G
c : Cone K
t : IsLimit (F.mapCone c)
⊢ IsLimit (G.mapCone c)
[PROOFSTEP]
apply postcomposeInvEquiv (isoWhiskerLeft K h : _) (mapCone G c) _
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝² : Category.{v₂, u₂} K✝
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
D : Type u₄
inst✝ : Category.{v₄, u₄} D
K : J ⥤ C
F G : C ⥤ D
h : F ≅ G
c : Cone K
t : IsLimit (F.mapCone c)
⊢ IsLimit ((Cones.postcompose (isoWhiskerLeft K h).inv).obj (G.mapCone c))
[PROOFSTEP]
apply t.ofIsoLimit (postcomposeWhiskerLeftMapCone h.symm c).symm
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
⊢ coneOfHom h (homOfCone h s) = s
[PROOFSTEP]
dsimp [coneOfHom, homOfCone]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
⊢ { pt := s.pt, π := NatTrans.app h.hom (op s.pt) { down := (NatTrans.app h.inv (op s.pt) s.π).down } } = s
[PROOFSTEP]
match s with
| .mk s_pt s_π =>
  congr; dsimp
  convert congrFun (congrFun (congrArg NatTrans.app h.inv_hom_id) (op s_pt)) s_π using 1
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
s_pt : C
s_π : (const J).obj s_pt ⟶ F
⊢ { pt := { pt := s_pt, π := s_π }.pt,
      π :=
        NatTrans.app h.hom (op { pt := s_pt, π := s_π }.pt)
          { down := (NatTrans.app h.inv (op { pt := s_pt, π := s_π }.pt) { pt := s_pt, π := s_π }.π).down } } =
    { pt := s_pt, π := s_π }
[PROOFSTEP]
congr
[GOAL]
case e_π
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
s_pt : C
s_π : (const J).obj s_pt ⟶ F
⊢ NatTrans.app h.hom (op { pt := s_pt, π := s_π }.pt)
      { down := (NatTrans.app h.inv (op { pt := s_pt, π := s_π }.pt) { pt := s_pt, π := s_π }.π).down } =
    s_π
[PROOFSTEP]
dsimp
[GOAL]
case e_π
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
s_pt : C
s_π : (const J).obj s_pt ⟶ F
⊢ NatTrans.app h.hom (op s_pt) { down := (NatTrans.app h.inv (op s_pt) s_π).down } = s_π
[PROOFSTEP]
convert congrFun (congrFun (congrArg NatTrans.app h.inv_hom_id) (op s_pt)) s_π using 1
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
Y : C
f : Y ⟶ X
⊢ coneOfHom h f = Cone.extend (limitCone h) f
[PROOFSTEP]
dsimp [coneOfHom, limitCone, Cone.extend]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
Y : C
f : Y ⟶ X
⊢ { pt := Y, π := NatTrans.app h.hom (op Y) { down := f } } =
    { pt := Y, π := (const J).map f ≫ NatTrans.app h.hom (op X) { down := 𝟙 X } }
[PROOFSTEP]
congr with j
[GOAL]
case e_π.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
Y : C
f : Y ⟶ X
j : J
⊢ NatTrans.app (NatTrans.app h.hom (op Y) { down := f }) j =
    NatTrans.app ((const J).map f ≫ NatTrans.app h.hom (op X) { down := 𝟙 X }) j
[PROOFSTEP]
have t := congrFun (h.hom.naturality f.op) ⟨𝟙 X⟩
[GOAL]
case e_π.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t✝ : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
Y : C
f : Y ⟶ X
j : J
t :
  ((yoneda.obj X ⋙ uliftFunctor.{u₁, v₃}).map f.op ≫ NatTrans.app h.hom (op Y)) { down := 𝟙 X } =
    (NatTrans.app h.hom (op X) ≫ (Functor.cones F).map f.op) { down := 𝟙 X }
⊢ NatTrans.app (NatTrans.app h.hom (op Y) { down := f }) j =
    NatTrans.app ((const J).map f ≫ NatTrans.app h.hom (op X) { down := 𝟙 X }) j
[PROOFSTEP]
dsimp at t 
[GOAL]
case e_π.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t✝ : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
Y : C
f : Y ⟶ X
j : J
t :
  NatTrans.app h.hom (op Y) { down := f ≫ 𝟙 X } = (Functor.cones F).map f.op (NatTrans.app h.hom (op X) { down := 𝟙 X })
⊢ NatTrans.app (NatTrans.app h.hom (op Y) { down := f }) j =
    NatTrans.app ((const J).map f ≫ NatTrans.app h.hom (op X) { down := 𝟙 X }) j
[PROOFSTEP]
simp only [comp_id] at t 
[GOAL]
case e_π.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t✝ : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
Y : C
f : Y ⟶ X
j : J
t : NatTrans.app h.hom (op Y) { down := f } = (Functor.cones F).map f.op (NatTrans.app h.hom (op X) { down := 𝟙 X })
⊢ NatTrans.app (NatTrans.app h.hom (op Y) { down := f }) j =
    NatTrans.app ((const J).map f ≫ NatTrans.app h.hom (op X) { down := 𝟙 X }) j
[PROOFSTEP]
rw [congrFun (congrArg NatTrans.app t) j]
[GOAL]
case e_π.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t✝ : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
Y : C
f : Y ⟶ X
j : J
t : NatTrans.app h.hom (op Y) { down := f } = (Functor.cones F).map f.op (NatTrans.app h.hom (op X) { down := 𝟙 X })
⊢ NatTrans.app ((Functor.cones F).map f.op (NatTrans.app h.hom (op X) { down := 𝟙 X })) j =
    NatTrans.app ((const J).map f ≫ NatTrans.app h.hom (op X) { down := 𝟙 X }) j
[PROOFSTEP]
rfl
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
⊢ Cone.extend (limitCone h) (homOfCone h s) = s
[PROOFSTEP]
rw [← coneOfHom_homOfCone h s]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
⊢ Cone.extend (limitCone h) (homOfCone h (coneOfHom h (homOfCone h s))) = coneOfHom h (homOfCone h s)
[PROOFSTEP]
conv_lhs => simp only [homOfCone_coneOfHom]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
| Cone.extend (limitCone h) (homOfCone h (coneOfHom h (homOfCone h s)))
[PROOFSTEP]
simp only [homOfCone_coneOfHom]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
| Cone.extend (limitCone h) (homOfCone h (coneOfHom h (homOfCone h s)))
[PROOFSTEP]
simp only [homOfCone_coneOfHom]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
| Cone.extend (limitCone h) (homOfCone h (coneOfHom h (homOfCone h s)))
[PROOFSTEP]
simp only [homOfCone_coneOfHom]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
⊢ Cone.extend (limitCone h) (homOfCone h s) = coneOfHom h (homOfCone h s)
[PROOFSTEP]
apply (coneOfHom_fac _ _).symm
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
j : J
⊢ (fun s => homOfCone h s) s ≫ NatTrans.app (limitCone h).π j = NatTrans.app s.π j
[PROOFSTEP]
have h := cone_fac h s
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h✝ : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
j : J
h : Cone.extend (limitCone h✝) (homOfCone h✝ s) = s
⊢ (fun s => homOfCone h✝ s) s ≫ NatTrans.app (limitCone h✝).π j = NatTrans.app s.π j
[PROOFSTEP]
cases s
[GOAL]
case mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h✝ : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
j : J
pt✝ : C
π✝ : (const J).obj pt✝ ⟶ F
h : Cone.extend (limitCone h✝) (homOfCone h✝ { pt := pt✝, π := π✝ }) = { pt := pt✝, π := π✝ }
⊢ (fun s => homOfCone h✝ s) { pt := pt✝, π := π✝ } ≫ NatTrans.app (limitCone h✝).π j =
    NatTrans.app { pt := pt✝, π := π✝ }.π j
[PROOFSTEP]
injection h with h₁ h₂
[GOAL]
case mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
j : J
pt✝ : C
π✝ : (const J).obj pt✝ ⟶ F
h₁ : { pt := pt✝, π := π✝ }.pt = pt✝
h₂ :
  NatTrans.app (Cone.extensions (limitCone h)) (op { pt := pt✝, π := π✝ }.pt)
      { down := homOfCone h { pt := pt✝, π := π✝ } } =
    π✝
⊢ (fun s => homOfCone h s) { pt := pt✝, π := π✝ } ≫ NatTrans.app (limitCone h).π j =
    NatTrans.app { pt := pt✝, π := π✝ }.π j
[PROOFSTEP]
simp only [heq_iff_eq] at h₂ 
[GOAL]
case mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
j : J
pt✝ : C
π✝ : (const J).obj pt✝ ⟶ F
h₁ : { pt := pt✝, π := π✝ }.pt = pt✝
h₂ : NatTrans.app (Cone.extensions (limitCone h)) (op pt✝) { down := homOfCone h { pt := pt✝, π := π✝ } } = π✝
⊢ (fun s => homOfCone h s) { pt := pt✝, π := π✝ } ≫ NatTrans.app (limitCone h).π j =
    NatTrans.app { pt := pt✝, π := π✝ }.π j
[PROOFSTEP]
conv_rhs => rw [← h₂]; rfl
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
j : J
pt✝ : C
π✝ : (const J).obj pt✝ ⟶ F
h₁ : { pt := pt✝, π := π✝ }.pt = pt✝
h₂ : NatTrans.app (Cone.extensions (limitCone h)) (op pt✝) { down := homOfCone h { pt := pt✝, π := π✝ } } = π✝
| NatTrans.app { pt := pt✝, π := π✝ }.π j
[PROOFSTEP]
rw [← h₂]; rfl
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
j : J
pt✝ : C
π✝ : (const J).obj pt✝ ⟶ F
h₁ : { pt := pt✝, π := π✝ }.pt = pt✝
h₂ : NatTrans.app (Cone.extensions (limitCone h)) (op pt✝) { down := homOfCone h { pt := pt✝, π := π✝ } } = π✝
| NatTrans.app { pt := pt✝, π := π✝ }.π j
[PROOFSTEP]
rw [← h₂]; rfl
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
j : J
pt✝ : C
π✝ : (const J).obj pt✝ ⟶ F
h₁ : { pt := pt✝, π := π✝ }.pt = pt✝
h₂ : NatTrans.app (Cone.extensions (limitCone h)) (op pt✝) { down := homOfCone h { pt := pt✝, π := π✝ } } = π✝
| NatTrans.app { pt := pt✝, π := π✝ }.π j
[PROOFSTEP]
rw [← h₂]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
j : J
pt✝ : C
π✝ : (const J).obj pt✝ ⟶ F
h₁ : { pt := pt✝, π := π✝ }.pt = pt✝
h₂ : NatTrans.app (Cone.extensions (limitCone h)) (op pt✝) { down := homOfCone h { pt := pt✝, π := π✝ } } = π✝
| NatTrans.app
    { pt := pt✝,
        π := NatTrans.app (Cone.extensions (limitCone h)) (op pt✝) { down := homOfCone h { pt := pt✝, π := π✝ } } }.π
    j
[PROOFSTEP]
rfl
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
m : s.pt ⟶ (limitCone h).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone h).π j = NatTrans.app s.π j
⊢ m = (fun s => homOfCone h s) s
[PROOFSTEP]
rw [← homOfCone_coneOfHom h m]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
m : s.pt ⟶ (limitCone h).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone h).π j = NatTrans.app s.π j
⊢ homOfCone h (coneOfHom h m) = (fun s => homOfCone h s) s
[PROOFSTEP]
congr
[GOAL]
case h.e_8.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
m : s.pt ⟶ (limitCone h).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone h).π j = NatTrans.app s.π j
⊢ coneOfHom h m = s
[PROOFSTEP]
rw [coneOfHom_fac]
[GOAL]
case h.e_8.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
m : s.pt ⟶ (limitCone h).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone h).π j = NatTrans.app s.π j
⊢ Cone.extend (limitCone h) m = s
[PROOFSTEP]
dsimp [Cone.extend]
[GOAL]
case h.e_8.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
s : Cone F
m : s.pt ⟶ (limitCone h).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone h).π j = NatTrans.app s.π j
⊢ { pt := s.pt, π := (const J).map m ≫ (limitCone h).π } = s
[PROOFSTEP]
cases s
[GOAL]
case h.e_8.h.mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
pt✝ : C
π✝ : (const J).obj pt✝ ⟶ F
m : { pt := pt✝, π := π✝ }.pt ⟶ (limitCone h).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone h).π j = NatTrans.app { pt := pt✝, π := π✝ }.π j
⊢ { pt := { pt := pt✝, π := π✝ }.pt, π := (const J).map m ≫ (limitCone h).π } = { pt := pt✝, π := π✝ }
[PROOFSTEP]
congr with j
[GOAL]
case h.e_8.h.mk.e_π.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cone F
X : C
h : yoneda.obj X ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cones F
pt✝ : C
π✝ : (const J).obj pt✝ ⟶ F
m : { pt := pt✝, π := π✝ }.pt ⟶ (limitCone h).pt
w : ∀ (j : J), m ≫ NatTrans.app (limitCone h).π j = NatTrans.app { pt := pt✝, π := π✝ }.π j
j : J
⊢ NatTrans.app ((const J).map m ≫ (limitCone h).π) j = NatTrans.app π✝ j
[PROOFSTEP]
exact w j
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
⊢ ∀ (a b : IsColimit t), a = b
[PROOFSTEP]
intro P Q
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
P Q : IsColimit t
⊢ P = Q
[PROOFSTEP]
cases P
[GOAL]
case mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
Q : IsColimit t
desc✝ : (s : Cocone F) → t.pt ⟶ s.pt
fac✝ : ∀ (s : Cocone F) (j : J), NatTrans.app t.ι j ≫ desc✝ s = NatTrans.app s.ι j
uniq✝ : ∀ (s : Cocone F) (m : t.pt ⟶ s.pt), (∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j) → m = desc✝ s
⊢ mk desc✝ = Q
[PROOFSTEP]
cases Q
[GOAL]
case mk.mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
desc✝¹ : (s : Cocone F) → t.pt ⟶ s.pt
fac✝¹ : ∀ (s : Cocone F) (j : J), NatTrans.app t.ι j ≫ desc✝¹ s = NatTrans.app s.ι j
uniq✝¹ : ∀ (s : Cocone F) (m : t.pt ⟶ s.pt), (∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j) → m = desc✝¹ s
desc✝ : (s : Cocone F) → t.pt ⟶ s.pt
fac✝ : ∀ (s : Cocone F) (j : J), NatTrans.app t.ι j ≫ desc✝ s = NatTrans.app s.ι j
uniq✝ : ∀ (s : Cocone F) (m : t.pt ⟶ s.pt), (∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j) → m = desc✝ s
⊢ mk desc✝¹ = mk desc✝
[PROOFSTEP]
congr
[GOAL]
case mk.mk.e_desc
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
desc✝¹ : (s : Cocone F) → t.pt ⟶ s.pt
fac✝¹ : ∀ (s : Cocone F) (j : J), NatTrans.app t.ι j ≫ desc✝¹ s = NatTrans.app s.ι j
uniq✝¹ : ∀ (s : Cocone F) (m : t.pt ⟶ s.pt), (∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j) → m = desc✝¹ s
desc✝ : (s : Cocone F) → t.pt ⟶ s.pt
fac✝ : ∀ (s : Cocone F) (j : J), NatTrans.app t.ι j ≫ desc✝ s = NatTrans.app s.ι j
uniq✝ : ∀ (s : Cocone F) (m : t.pt ⟶ s.pt), (∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j) → m = desc✝ s
⊢ desc✝¹ = desc✝
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cocone F
h : IsColimit t
f f' : t ⟶ s
⊢ ∀ {g : t ⟶ s}, g = descCoconeMorphism h s
[PROOFSTEP]
intro g
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cocone F
h : IsColimit t
f f' g : t ⟶ s
⊢ g = descCoconeMorphism h s
[PROOFSTEP]
aesop_cat_nonterminal
[GOAL]
case w
J : Type u₁
inst : Category.{v₁, u₁} J
K : Type u₂
inst_1 : Category.{v₂, u₂} K
C : Type u₃
inst_2 : Category.{v₃, u₃} C
F : J ⥤ C
s t : Cocone F
h : IsColimit t
f f' g : t ⟶ s
⊢ g.Hom = desc h s
[PROOFSTEP]
exact h.uniq _ _ g.w
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
ht : ∀ (s : Cocone F), ∃! d, ∀ (j : J), NatTrans.app t.ι j ≫ d = NatTrans.app s.ι j
⊢ IsColimit t
[PROOFSTEP]
choose s hs hs' using ht
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
s : (s : Cocone F) → t.pt ⟶ s.pt
hs : ∀ (s_1 : Cocone F), (fun d => ∀ (j : J), NatTrans.app t.ι j ≫ d = NatTrans.app s_1.ι j) (s s_1)
hs' :
  ∀ (s_1 : Cocone F) (y : t.pt ⟶ s_1.pt),
    (fun d => ∀ (j : J), NatTrans.app t.ι j ≫ d = NatTrans.app s_1.ι j) y → y = s s_1
⊢ IsColimit t
[PROOFSTEP]
exact ⟨s, hs, hs'⟩
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
desc : (s : Cocone F) → t ⟶ s
uniq' : ∀ (s : Cocone F) (m : t ⟶ s), m = desc s
s : Cocone F
m : t.pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j
⊢ CoconeMorphism.mk m = desc s
[PROOFSTEP]
apply uniq'
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r s t : Cocone F
P : IsColimit s
Q : IsColimit t
⊢ ∀ (j : J), NatTrans.app s.ι j ≫ (coconePointUniqueUpToIso P Q).hom ≫ desc Q r = NatTrans.app r.ι j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r s t : Cocone F
P : IsColimit s
Q : IsColimit t
⊢ ∀ (j : J), NatTrans.app t.ι j ≫ (coconePointUniqueUpToIso P Q).inv ≫ desc P r = NatTrans.app r.ι j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cocone F
P : IsColimit r
i : r ≅ t
s : Cocone F
m : t ⟶ s
⊢ m = (fun s => i.inv ≫ descCoconeMorphism P s) s
[PROOFSTEP]
rw [i.eq_inv_comp]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cocone F
P : IsColimit r
i : r ≅ t
s : Cocone F
m : t ⟶ s
⊢ i.hom ≫ m = descCoconeMorphism P s
[PROOFSTEP]
apply P.uniq_cocone_morphism
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cocone F
i : r ≅ t
⊢ Function.LeftInverse (fun h => ofIsoColimit h i.symm) fun h => ofIsoColimit h i
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cocone F
i : r ≅ t
⊢ Function.RightInverse (fun h => ofIsoColimit h i.symm) fun h => ofIsoColimit h i
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cocone F
P : IsColimit r
i : IsIso (desc P t)
⊢ r ≅ t
[PROOFSTEP]
haveI : IsIso (P.descCoconeMorphism t).Hom := i
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cocone F
P : IsColimit r
i : IsIso (desc P t)
this : IsIso (descCoconeMorphism P t).Hom
⊢ r ≅ t
[PROOFSTEP]
haveI : IsIso (P.descCoconeMorphism t) := Cocones.cocone_iso_of_hom_iso _
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
r t : Cocone F
P : IsColimit r
i : IsIso (desc P t)
this✝ : IsIso (descCoconeMorphism P t).Hom
this : IsIso (descCoconeMorphism P t)
⊢ r ≅ t
[PROOFSTEP]
apply asIso (P.descCoconeMorphism t)
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
m : t.pt ⟶ W
⊢ ∀ ⦃X Y : J⦄ (f : X ⟶ Y),
    F.map f ≫ (fun b => NatTrans.app t.ι b ≫ m) Y = (fun b => NatTrans.app t.ι b ≫ m) X ≫ ((const J).obj W).map f
[PROOFSTEP]
intros
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
m : t.pt ⟶ W
X✝ Y✝ : J
f✝ : X✝ ⟶ Y✝
⊢ F.map f✝ ≫ (fun b => NatTrans.app t.ι b ≫ m) Y✝ = (fun b => NatTrans.app t.ι b ≫ m) X✝ ≫ ((const J).obj W).map f✝
[PROOFSTEP]
erw [← assoc, t.ι.naturality, comp_id, comp_id]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
f f' : t.pt ⟶ W
w : ∀ (j : J), NatTrans.app t.ι j ≫ f = NatTrans.app t.ι j ≫ f'
⊢ f = f'
[PROOFSTEP]
rw [h.hom_desc f, h.hom_desc f']
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
f f' : t.pt ⟶ W
w : ∀ (j : J), NatTrans.app t.ι j ≫ f = NatTrans.app t.ι j ≫ f'
⊢ desc h { pt := W, ι := NatTrans.mk fun b => NatTrans.app t.ι b ≫ f } =
    desc h { pt := W, ι := NatTrans.mk fun b => NatTrans.app t.ι b ≫ f' }
[PROOFSTEP]
congr
[GOAL]
case h.e_8.h.e_ι.e_app
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
f f' : t.pt ⟶ W
w : ∀ (j : J), NatTrans.app t.ι j ≫ f = NatTrans.app t.ι j ≫ f'
⊢ (fun b => NatTrans.app t.ι b ≫ f) = fun b => NatTrans.app t.ι b ≫ f'
[PROOFSTEP]
exact funext w
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
D : Type u₄
inst✝ : Category.{v₄, u₄} D
G : K ⥤ D
h : Cocone G ≌ Cocone F
c : Cocone G
⊢ Function.LeftInverse (ofLeftAdjoint h.functor) fun P =>
    ofIsoColimit (ofLeftAdjoint h.inverse P) (h.unitIso.symm.app c)
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
D : Type u₄
inst✝ : Category.{v₄, u₄} D
G : K ⥤ D
h : Cocone G ≌ Cocone F
c : Cocone G
⊢ Function.RightInverse (ofLeftAdjoint h.functor) fun P =>
    ofIsoColimit (ofLeftAdjoint h.inverse P) (h.unitIso.symm.app c)
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
⊢ ∀ (j : J), NatTrans.app s.ι j ≫ map P t w.hom ≫ map Q s w.inv = NatTrans.app s.ι j ≫ 𝟙 s.pt
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
⊢ ∀ (j : J), NatTrans.app t.ι j ≫ map Q s w.inv ≫ map P t w.hom = NatTrans.app t.ι j ≫ 𝟙 t.pt
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
j : J
⊢ NatTrans.app s.ι j ≫ (coconePointsIsoOfNatIso P Q w).hom = NatTrans.app w.hom j ≫ NatTrans.app t.ι j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
j : J
⊢ NatTrans.app t.ι j ≫ (coconePointsIsoOfNatIso P Q w).inv = NatTrans.app w.inv j ≫ NatTrans.app s.ι j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone F
r t : Cocone G
P : IsColimit s
Q : IsColimit t
w : F ≅ G
⊢ ∀ (j : J), NatTrans.app s.ι j ≫ (coconePointsIsoOfNatIso P Q w).hom ≫ desc Q r = NatTrans.app s.ι j ≫ map P r w.hom
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
F G : J ⥤ C
s : Cocone G
r t : Cocone F
P : IsColimit t
Q : IsColimit s
w : F ≅ G
⊢ ∀ (j : J), NatTrans.app s.ι j ≫ (coconePointsIsoOfNatIso P Q w).inv ≫ desc P r = NatTrans.app s.ι j ≫ map Q r w.inv
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t s : Cocone F
e : K ≌ J
⊢ Function.LeftInverse (ofWhiskerEquivalence e) fun h => whiskerEquivalence h e
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t s : Cocone F
e : K ≌ J
⊢ Function.RightInverse (ofWhiskerEquivalence e) fun h => whiskerEquivalence h e
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
⊢ desc P ((Cocones.equivalenceOfReindexing e w).functor.obj t) ≫
      desc Q ((Cocones.equivalenceOfReindexing (Equivalence.symm e) w').functor.obj s) =
    𝟙 s.pt
[PROOFSTEP]
apply hom_ext P
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
⊢ ∀ (j : J),
    NatTrans.app s.ι j ≫
        desc P ((Cocones.equivalenceOfReindexing e w).functor.obj t) ≫
          desc Q ((Cocones.equivalenceOfReindexing (Equivalence.symm e) w').functor.obj s) =
      NatTrans.app s.ι j ≫ 𝟙 s.pt
[PROOFSTEP]
intro j
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
⊢ NatTrans.app s.ι j ≫
      desc P ((Cocones.equivalenceOfReindexing e w).functor.obj t) ≫
        desc Q ((Cocones.equivalenceOfReindexing (Equivalence.symm e) w').functor.obj s) =
    NatTrans.app s.ι j ≫ 𝟙 s.pt
[PROOFSTEP]
dsimp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
⊢ NatTrans.app s.ι j ≫
      desc P ((Cocones.precompose w.inv).obj (Cocone.whisker e.functor t)) ≫
        desc Q
          ((Cocones.precompose ((invFunIdAssoc e G).inv ≫ whiskerLeft e.inverse w.hom)).obj
            (Cocone.whisker e.inverse s)) =
    NatTrans.app s.ι j ≫ 𝟙 s.pt
[PROOFSTEP]
simp only [Limits.Cocone.whisker_ι, fac, invFunIdAssoc_inv_app, whiskerLeft_app, assoc, comp_id,
  Limits.Cocones.precompose_obj_ι, fac_assoc, NatTrans.comp_app]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
⊢ NatTrans.app w.inv j ≫
      G.map (NatTrans.app (counitInv e) (e.functor.obj j)) ≫
        NatTrans.app w.hom (e.inverse.obj (e.functor.obj j)) ≫ NatTrans.app s.ι (e.inverse.obj (e.functor.obj j)) =
    NatTrans.app s.ι j
[PROOFSTEP]
rw [counitInv_app_functor, ← Functor.comp_map, ← w.inv.naturality_assoc]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
⊢ F.map (NatTrans.app (unit e) j) ≫
      NatTrans.app w.inv ((e.functor ⋙ e.inverse).obj j) ≫
        NatTrans.app w.hom (e.inverse.obj (e.functor.obj j)) ≫ NatTrans.app s.ι (e.inverse.obj (e.functor.obj j)) =
    NatTrans.app s.ι j
[PROOFSTEP]
dsimp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
j : J
⊢ F.map (NatTrans.app (unit e) j) ≫
      NatTrans.app w.inv (e.inverse.obj (e.functor.obj j)) ≫
        NatTrans.app w.hom (e.inverse.obj (e.functor.obj j)) ≫ NatTrans.app s.ι (e.inverse.obj (e.functor.obj j)) =
    NatTrans.app s.ι j
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
⊢ desc Q ((Cocones.equivalenceOfReindexing (Equivalence.symm e) w').functor.obj s) ≫
      desc P ((Cocones.equivalenceOfReindexing e w).functor.obj t) =
    𝟙 t.pt
[PROOFSTEP]
apply hom_ext Q
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
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
w' : e.inverse ⋙ F ≅ G := (isoWhiskerLeft e.inverse w).symm ≪≫ invFunIdAssoc e G
⊢ ∀ (j : K),
    NatTrans.app t.ι j ≫
        desc Q ((Cocones.equivalenceOfReindexing (Equivalence.symm e) w').functor.obj s) ≫
          desc P ((Cocones.equivalenceOfReindexing e w).functor.obj t) =
      NatTrans.app t.ι j ≫ 𝟙 t.pt
[PROOFSTEP]
aesop_cat
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
⊢ ((fun f => (Cocone.extend t f.down).ι) ≫ fun ι => { down := desc h { pt := W, ι := ι } }) = 𝟙 (ULift (t.pt ⟶ W))
[PROOFSTEP]
funext f
[GOAL]
case h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
f : ULift (t.pt ⟶ W)
⊢ ((fun f => (Cocone.extend t f.down).ι) ≫ fun ι => { down := desc h { pt := W, ι := ι } }) f = 𝟙 (ULift (t.pt ⟶ W)) f
[PROOFSTEP]
apply ULift.ext
[GOAL]
case h.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
f : ULift (t.pt ⟶ W)
⊢ (((fun f => (Cocone.extend t f.down).ι) ≫ fun ι => { down := desc h { pt := W, ι := ι } }) f).down =
    (𝟙 (ULift (t.pt ⟶ W)) f).down
[PROOFSTEP]
apply h.hom_ext
[GOAL]
case h.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
f : ULift (t.pt ⟶ W)
⊢ ∀ (j : J),
    NatTrans.app t.ι j ≫
        (((fun f => (Cocone.extend t f.down).ι) ≫ fun ι => { down := desc h { pt := W, ι := ι } }) f).down =
      NatTrans.app t.ι j ≫ (𝟙 (ULift (t.pt ⟶ W)) f).down
[PROOFSTEP]
intro j
[GOAL]
case h.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
f : ULift (t.pt ⟶ W)
j : J
⊢ NatTrans.app t.ι j ≫
      (((fun f => (Cocone.extend t f.down).ι) ≫ fun ι => { down := desc h { pt := W, ι := ι } }) f).down =
    NatTrans.app t.ι j ≫ (𝟙 (ULift (t.pt ⟶ W)) f).down
[PROOFSTEP]
simp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
ι : F ⟶ (const J).obj W
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ (fun j => NatTrans.app ι j) j' = (fun j => NatTrans.app ι j) j
[PROOFSTEP]
convert ← ι.naturality f
[GOAL]
case h.e'_3.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
ι : F ⟶ (const J).obj W
j j' : J
f : j ⟶ j'
e_1✝ : (F.obj j ⟶ ((const J).obj W).obj j') = (F.obj j ⟶ W)
⊢ NatTrans.app ι j ≫ ((const J).obj W).map f = (fun j => NatTrans.app ι j) j
[PROOFSTEP]
apply comp_id
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
p : { p // ∀ {j j' : J} (f : j ⟶ j'), F.map f ≫ p j' = p j }
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ (fun j => ↑p j) j' = (fun j => ↑p j) j ≫ ((const J).obj W).map f
[PROOFSTEP]
dsimp
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
p : { p // ∀ {j j' : J} (f : j ⟶ j'), F.map f ≫ p j' = p j }
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ ↑p j' = ↑p j ≫ 𝟙 W
[PROOFSTEP]
rw [comp_id]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
h : IsColimit t
W : C
p : { p // ∀ {j j' : J} (f : j ⟶ j'), F.map f ≫ p j' = p j }
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ ↑p j' = ↑p j
[PROOFSTEP]
exact p.2 f
[GOAL]
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cocone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsColimit (G.mapCocone t)
desc : (s : Cocone F) → t.pt ⟶ s.pt
h : ∀ (s : Cocone F), G.map (desc s) = CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s)
s : Cocone F
j : J
⊢ NatTrans.app t.ι j ≫ desc s = NatTrans.app s.ι j
[PROOFSTEP]
apply G.map_injective
[GOAL]
case a
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cocone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsColimit (G.mapCocone t)
desc : (s : Cocone F) → t.pt ⟶ s.pt
h : ∀ (s : Cocone F), G.map (desc s) = CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s)
s : Cocone F
j : J
⊢ G.map (NatTrans.app t.ι j ≫ desc s) = G.map (NatTrans.app s.ι j)
[PROOFSTEP]
rw [G.map_comp, h]
[GOAL]
case a
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cocone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsColimit (G.mapCocone t)
desc : (s : Cocone F) → t.pt ⟶ s.pt
h : ∀ (s : Cocone F), G.map (desc s) = CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s)
s : Cocone F
j : J
⊢ G.map (NatTrans.app t.ι j) ≫ CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s) = G.map (NatTrans.app s.ι j)
[PROOFSTEP]
apply ht.fac
[GOAL]
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cocone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsColimit (G.mapCocone t)
desc : (s : Cocone F) → t.pt ⟶ s.pt
h : ∀ (s : Cocone F), G.map (desc s) = CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s)
s : Cocone F
m : t.pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j
⊢ m = desc s
[PROOFSTEP]
apply G.map_injective
[GOAL]
case a
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cocone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsColimit (G.mapCocone t)
desc : (s : Cocone F) → t.pt ⟶ s.pt
h : ∀ (s : Cocone F), G.map (desc s) = CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s)
s : Cocone F
m : t.pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j
⊢ G.map m = G.map (desc s)
[PROOFSTEP]
rw [h]
[GOAL]
case a
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cocone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsColimit (G.mapCocone t)
desc : (s : Cocone F) → t.pt ⟶ s.pt
h : ∀ (s : Cocone F), G.map (desc s) = CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s)
s : Cocone F
m : t.pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j
⊢ G.map m = CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s)
[PROOFSTEP]
refine' ht.uniq (mapCocone G s) _ fun j => _
[GOAL]
case a
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cocone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsColimit (G.mapCocone t)
desc : (s : Cocone F) → t.pt ⟶ s.pt
h : ∀ (s : Cocone F), G.map (desc s) = CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s)
s : Cocone F
m : t.pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j
j : J
⊢ NatTrans.app (G.mapCocone t).ι j ≫ G.map m = NatTrans.app (G.mapCocone s).ι j
[PROOFSTEP]
convert ← congrArg (fun f => G.map f) (w j)
[GOAL]
case h.e'_2.h
J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u₃
inst✝² : Category.{v₃, u₃} C
F : J ⥤ C
t✝ t : Cocone F
D : Type u₄
inst✝¹ : Category.{v₄, u₄} D
G : C ⥤ D
inst✝ : Faithful G
ht : IsColimit (G.mapCocone t)
desc : (s : Cocone F) → t.pt ⟶ s.pt
h : ∀ (s : Cocone F), G.map (desc s) = CategoryTheory.Limits.IsColimit.desc ht (G.mapCocone s)
s : Cocone F
m : t.pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app t.ι j ≫ m = NatTrans.app s.ι j
j : J
e_1✝ : (G.obj (F.obj j) ⟶ G.obj s.pt) = ((F ⋙ G).obj j ⟶ (G.mapCocone s).pt)
⊢ G.map (NatTrans.app t.ι j ≫ m) = NatTrans.app (G.mapCocone t).ι j ≫ G.map m
[PROOFSTEP]
apply G.map_comp
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝² : Category.{v₂, u₂} K✝
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
D : Type u₄
inst✝ : Category.{v₄, u₄} D
K : J ⥤ C
F G : C ⥤ D
h : F ≅ G
c : Cocone K
t : IsColimit (F.mapCocone c)
⊢ IsColimit (G.mapCocone c)
[PROOFSTEP]
apply IsColimit.ofIsoColimit _ (precomposeWhiskerLeftMapCocone h c)
[GOAL]
J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K✝ : Type u₂
inst✝² : Category.{v₂, u₂} K✝
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cocone F✝
D : Type u₄
inst✝ : Category.{v₄, u₄} D
K : J ⥤ C
F G : C ⥤ D
h : F ≅ G
c : Cocone K
t : IsColimit (F.mapCocone c)
⊢ IsColimit ((Cocones.precompose (whiskerLeft K h.inv)).obj (F.mapCocone c))
[PROOFSTEP]
apply (precomposeInvEquiv (isoWhiskerLeft K h : _) _).symm t
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
⊢ coconeOfHom h (homOfCocone h s) = s
[PROOFSTEP]
dsimp [coconeOfHom, homOfCocone]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
⊢ { pt := s.pt, ι := NatTrans.app h.hom s.pt { down := (NatTrans.app h.inv s.pt s.ι).down } } = s
[PROOFSTEP]
have ⟨s_pt, s_ι⟩ := s
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
s_pt : C
s_ι : F ⟶ (const J).obj s_pt
⊢ { pt := { pt := s_pt, ι := s_ι }.pt,
      ι :=
        NatTrans.app h.hom { pt := s_pt, ι := s_ι }.pt
          { down := (NatTrans.app h.inv { pt := s_pt, ι := s_ι }.pt { pt := s_pt, ι := s_ι }.ι).down } } =
    { pt := s_pt, ι := s_ι }
[PROOFSTEP]
congr
[GOAL]
case e_ι
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
s_pt : C
s_ι : F ⟶ (const J).obj s_pt
⊢ NatTrans.app h.hom { pt := s_pt, ι := s_ι }.pt
      { down := (NatTrans.app h.inv { pt := s_pt, ι := s_ι }.pt { pt := s_pt, ι := s_ι }.ι).down } =
    s_ι
[PROOFSTEP]
dsimp
[GOAL]
case e_ι
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
s_pt : C
s_ι : F ⟶ (const J).obj s_pt
⊢ NatTrans.app h.hom s_pt { down := (NatTrans.app h.inv s_pt s_ι).down } = s_ι
[PROOFSTEP]
convert congrFun (congrFun (congrArg NatTrans.app h.inv_hom_id) s_pt) s_ι using 1
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
Y : C
f : X ⟶ Y
⊢ coconeOfHom h f = Cocone.extend (colimitCocone h) f
[PROOFSTEP]
dsimp [coconeOfHom, colimitCocone, Cocone.extend]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
Y : C
f : X ⟶ Y
⊢ { pt := Y, ι := NatTrans.app h.hom Y { down := f } } =
    { pt := Y, ι := NatTrans.app h.hom X { down := 𝟙 X } ≫ (const J).map f }
[PROOFSTEP]
congr with j
[GOAL]
case e_ι.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
Y : C
f : X ⟶ Y
j : J
⊢ NatTrans.app (NatTrans.app h.hom Y { down := f }) j =
    NatTrans.app (NatTrans.app h.hom X { down := 𝟙 X } ≫ (const J).map f) j
[PROOFSTEP]
have t := congrFun (h.hom.naturality f) ⟨𝟙 X⟩
[GOAL]
case e_ι.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t✝ : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
Y : C
f : X ⟶ Y
j : J
t :
  ((coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃}).map f ≫ NatTrans.app h.hom Y) { down := 𝟙 X } =
    (NatTrans.app h.hom X ≫ (Functor.cocones F).map f) { down := 𝟙 X }
⊢ NatTrans.app (NatTrans.app h.hom Y { down := f }) j =
    NatTrans.app (NatTrans.app h.hom X { down := 𝟙 X } ≫ (const J).map f) j
[PROOFSTEP]
dsimp at t 
[GOAL]
case e_ι.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t✝ : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
Y : C
f : X ⟶ Y
j : J
t : NatTrans.app h.hom Y { down := 𝟙 X ≫ f } = (Functor.cocones F).map f (NatTrans.app h.hom X { down := 𝟙 X })
⊢ NatTrans.app (NatTrans.app h.hom Y { down := f }) j =
    NatTrans.app (NatTrans.app h.hom X { down := 𝟙 X } ≫ (const J).map f) j
[PROOFSTEP]
simp only [id_comp] at t 
[GOAL]
case e_ι.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t✝ : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
Y : C
f : X ⟶ Y
j : J
t : NatTrans.app h.hom Y { down := f } = (Functor.cocones F).map f (NatTrans.app h.hom X { down := 𝟙 X })
⊢ NatTrans.app (NatTrans.app h.hom Y { down := f }) j =
    NatTrans.app (NatTrans.app h.hom X { down := 𝟙 X } ≫ (const J).map f) j
[PROOFSTEP]
rw [congrFun (congrArg NatTrans.app t) j]
[GOAL]
case e_ι.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t✝ : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
Y : C
f : X ⟶ Y
j : J
t : NatTrans.app h.hom Y { down := f } = (Functor.cocones F).map f (NatTrans.app h.hom X { down := 𝟙 X })
⊢ NatTrans.app ((Functor.cocones F).map f (NatTrans.app h.hom X { down := 𝟙 X })) j =
    NatTrans.app (NatTrans.app h.hom X { down := 𝟙 X } ≫ (const J).map f) j
[PROOFSTEP]
rfl
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
⊢ Cocone.extend (colimitCocone h) (homOfCocone h s) = s
[PROOFSTEP]
rw [← coconeOfHom_homOfCocone h s]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
⊢ Cocone.extend (colimitCocone h) (homOfCocone h (coconeOfHom h (homOfCocone h s))) = coconeOfHom h (homOfCocone h s)
[PROOFSTEP]
conv_lhs => simp only [homOfCocone_cooneOfHom]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
| Cocone.extend (colimitCocone h) (homOfCocone h (coconeOfHom h (homOfCocone h s)))
[PROOFSTEP]
simp only [homOfCocone_cooneOfHom]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
| Cocone.extend (colimitCocone h) (homOfCocone h (coconeOfHom h (homOfCocone h s)))
[PROOFSTEP]
simp only [homOfCocone_cooneOfHom]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
| Cocone.extend (colimitCocone h) (homOfCocone h (coconeOfHom h (homOfCocone h s)))
[PROOFSTEP]
simp only [homOfCocone_cooneOfHom]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
⊢ Cocone.extend (colimitCocone h) (homOfCocone h s) = coconeOfHom h (homOfCocone h s)
[PROOFSTEP]
apply (coconeOfHom_fac _ _).symm
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
j : J
⊢ NatTrans.app (colimitCocone h).ι j ≫ (fun s => homOfCocone h s) s = NatTrans.app s.ι j
[PROOFSTEP]
have h := cocone_fac h s
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h✝ : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
j : J
h : Cocone.extend (colimitCocone h✝) (homOfCocone h✝ s) = s
⊢ NatTrans.app (colimitCocone h✝).ι j ≫ (fun s => homOfCocone h✝ s) s = NatTrans.app s.ι j
[PROOFSTEP]
cases s
[GOAL]
case mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h✝ : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
j : J
pt✝ : C
ι✝ : F ⟶ (const J).obj pt✝
h : Cocone.extend (colimitCocone h✝) (homOfCocone h✝ { pt := pt✝, ι := ι✝ }) = { pt := pt✝, ι := ι✝ }
⊢ NatTrans.app (colimitCocone h✝).ι j ≫ (fun s => homOfCocone h✝ s) { pt := pt✝, ι := ι✝ } =
    NatTrans.app { pt := pt✝, ι := ι✝ }.ι j
[PROOFSTEP]
injection h with h₁ h₂
[GOAL]
case mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
j : J
pt✝ : C
ι✝ : F ⟶ (const J).obj pt✝
h₁ : { pt := pt✝, ι := ι✝ }.pt = pt✝
h₂ :
  NatTrans.app (Cocone.extensions (colimitCocone h)) { pt := pt✝, ι := ι✝ }.pt
      { down := homOfCocone h { pt := pt✝, ι := ι✝ } } =
    ι✝
⊢ NatTrans.app (colimitCocone h).ι j ≫ (fun s => homOfCocone h s) { pt := pt✝, ι := ι✝ } =
    NatTrans.app { pt := pt✝, ι := ι✝ }.ι j
[PROOFSTEP]
simp only [heq_iff_eq] at h₂ 
[GOAL]
case mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
j : J
pt✝ : C
ι✝ : F ⟶ (const J).obj pt✝
h₁ : { pt := pt✝, ι := ι✝ }.pt = pt✝
h₂ : NatTrans.app (Cocone.extensions (colimitCocone h)) pt✝ { down := homOfCocone h { pt := pt✝, ι := ι✝ } } = ι✝
⊢ NatTrans.app (colimitCocone h).ι j ≫ (fun s => homOfCocone h s) { pt := pt✝, ι := ι✝ } =
    NatTrans.app { pt := pt✝, ι := ι✝ }.ι j
[PROOFSTEP]
conv_rhs => rw [← h₂]; rfl
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
j : J
pt✝ : C
ι✝ : F ⟶ (const J).obj pt✝
h₁ : { pt := pt✝, ι := ι✝ }.pt = pt✝
h₂ : NatTrans.app (Cocone.extensions (colimitCocone h)) pt✝ { down := homOfCocone h { pt := pt✝, ι := ι✝ } } = ι✝
| NatTrans.app { pt := pt✝, ι := ι✝ }.ι j
[PROOFSTEP]
rw [← h₂]; rfl
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
j : J
pt✝ : C
ι✝ : F ⟶ (const J).obj pt✝
h₁ : { pt := pt✝, ι := ι✝ }.pt = pt✝
h₂ : NatTrans.app (Cocone.extensions (colimitCocone h)) pt✝ { down := homOfCocone h { pt := pt✝, ι := ι✝ } } = ι✝
| NatTrans.app { pt := pt✝, ι := ι✝ }.ι j
[PROOFSTEP]
rw [← h₂]; rfl
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
j : J
pt✝ : C
ι✝ : F ⟶ (const J).obj pt✝
h₁ : { pt := pt✝, ι := ι✝ }.pt = pt✝
h₂ : NatTrans.app (Cocone.extensions (colimitCocone h)) pt✝ { down := homOfCocone h { pt := pt✝, ι := ι✝ } } = ι✝
| NatTrans.app { pt := pt✝, ι := ι✝ }.ι j
[PROOFSTEP]
rw [← h₂]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
j : J
pt✝ : C
ι✝ : F ⟶ (const J).obj pt✝
h₁ : { pt := pt✝, ι := ι✝ }.pt = pt✝
h₂ : NatTrans.app (Cocone.extensions (colimitCocone h)) pt✝ { down := homOfCocone h { pt := pt✝, ι := ι✝ } } = ι✝
| NatTrans.app
    { pt := pt✝,
        ι := NatTrans.app (Cocone.extensions (colimitCocone h)) pt✝ { down := homOfCocone h { pt := pt✝, ι := ι✝ } } }.ι
    j
[PROOFSTEP]
rfl
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
m : (colimitCocone h).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone h).ι j ≫ m = NatTrans.app s.ι j
⊢ m = (fun s => homOfCocone h s) s
[PROOFSTEP]
rw [← homOfCocone_cooneOfHom h m]
[GOAL]
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
m : (colimitCocone h).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone h).ι j ≫ m = NatTrans.app s.ι j
⊢ homOfCocone h (coconeOfHom h m) = (fun s => homOfCocone h s) s
[PROOFSTEP]
congr
[GOAL]
case h.e_8.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
m : (colimitCocone h).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone h).ι j ≫ m = NatTrans.app s.ι j
⊢ coconeOfHom h m = s
[PROOFSTEP]
rw [coconeOfHom_fac]
[GOAL]
case h.e_8.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
m : (colimitCocone h).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone h).ι j ≫ m = NatTrans.app s.ι j
⊢ Cocone.extend (colimitCocone h) m = s
[PROOFSTEP]
dsimp [Cocone.extend]
[GOAL]
case h.e_8.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
s : Cocone F
m : (colimitCocone h).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone h).ι j ≫ m = NatTrans.app s.ι j
⊢ { pt := s.pt, ι := (colimitCocone h).ι ≫ (const J).map m } = s
[PROOFSTEP]
cases s
[GOAL]
case h.e_8.h.mk
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
pt✝ : C
ι✝ : F ⟶ (const J).obj pt✝
m : (colimitCocone h).pt ⟶ { pt := pt✝, ι := ι✝ }.pt
w : ∀ (j : J), NatTrans.app (colimitCocone h).ι j ≫ m = NatTrans.app { pt := pt✝, ι := ι✝ }.ι j
⊢ { pt := { pt := pt✝, ι := ι✝ }.pt, ι := (colimitCocone h).ι ≫ (const J).map m } = { pt := pt✝, ι := ι✝ }
[PROOFSTEP]
congr with j
[GOAL]
case h.e_8.h.mk.e_ι.w.h
J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F : J ⥤ C
t : Cocone F
X : C
h : coyoneda.obj (op X) ⋙ uliftFunctor.{u₁, v₃} ≅ Functor.cocones F
pt✝ : C
ι✝ : F ⟶ (const J).obj pt✝
m : (colimitCocone h).pt ⟶ { pt := pt✝, ι := ι✝ }.pt
w : ∀ (j : J), NatTrans.app (colimitCocone h).ι j ≫ m = NatTrans.app { pt := pt✝, ι := ι✝ }.ι j
j : J
⊢ NatTrans.app ((colimitCocone h).ι ≫ (const J).map m) j = NatTrans.app ι✝ j
[PROOFSTEP]
exact w j
