[GOAL]
J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j : J
U : Opens ↑↑(F.obj j)
⊢ 𝟙 ↑(F.obj j) = (F.map (𝟙 j)).base
[PROOFSTEP]
simp
[GOAL]
J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j : J
U : Opens ↑↑(F.obj j)
⊢ NatTrans.app (F.map (𝟙 j)).c (op U) =
    NatTrans.app (Pushforward.id (F.obj j).presheaf).inv (op U) ≫
      NatTrans.app (pushforwardEq (_ : 𝟙 ↑(F.obj j) = (F.map (𝟙 j)).base) (F.obj j).presheaf).hom (op U)
[PROOFSTEP]
cases U
[GOAL]
case mk
J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j : J
carrier✝ : Set ↑↑(F.obj j)
is_open'✝ : IsOpen carrier✝
⊢ NatTrans.app (F.map (𝟙 j)).c (op { carrier := carrier✝, is_open' := is_open'✝ }) =
    NatTrans.app (Pushforward.id (F.obj j).presheaf).inv (op { carrier := carrier✝, is_open' := is_open'✝ }) ≫
      NatTrans.app (pushforwardEq (_ : 𝟙 ↑(F.obj j) = (F.map (𝟙 j)).base) (F.obj j).presheaf).hom
        (op { carrier := carrier✝, is_open' := is_open'✝ })
[PROOFSTEP]
simp [PresheafedSpace.congr_app (F.map_id j)]
[GOAL]
J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : Opens ↑↑(F.obj j₃)
⊢ (F.map f).base ≫ (F.map g).base = (F.map (f ≫ g)).base
[PROOFSTEP]
rw [F.map_comp]
[GOAL]
J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : Opens ↑↑(F.obj j₃)
⊢ (F.map f).base ≫ (F.map g).base = (F.map f ≫ F.map g).base
[PROOFSTEP]
rfl
[GOAL]
J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : Opens ↑↑(F.obj j₃)
⊢ NatTrans.app (F.map (f ≫ g)).c (op U) =
    NatTrans.app (F.map g).c (op U) ≫
      NatTrans.app (pushforwardMap (F.map g).base (F.map f).c) (op U) ≫
        NatTrans.app (Pushforward.comp (F.obj j₁).presheaf (F.map f).base (F.map g).base).inv (op U) ≫
          NatTrans.app
            (pushforwardEq (_ : (F.map f).base ≫ (F.map g).base = (F.map (f ≫ g)).base) (F.obj j₁).presheaf).hom (op U)
[PROOFSTEP]
cases U
[GOAL]
case mk
J : Type u'
inst✝¹ : Category.{v', u'} J
C : Type u
inst✝ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
carrier✝ : Set ↑↑(F.obj j₃)
is_open'✝ : IsOpen carrier✝
⊢ NatTrans.app (F.map (f ≫ g)).c (op { carrier := carrier✝, is_open' := is_open'✝ }) =
    NatTrans.app (F.map g).c (op { carrier := carrier✝, is_open' := is_open'✝ }) ≫
      NatTrans.app (pushforwardMap (F.map g).base (F.map f).c) (op { carrier := carrier✝, is_open' := is_open'✝ }) ≫
        NatTrans.app (Pushforward.comp (F.obj j₁).presheaf (F.map f).base (F.map g).base).inv
            (op { carrier := carrier✝, is_open' := is_open'✝ }) ≫
          NatTrans.app
            (pushforwardEq (_ : (F.map f).base ≫ (F.map g).base = (F.map (f ≫ g)).base) (F.obj j₁).presheaf).hom
            (op { carrier := carrier✝, is_open' := is_open'✝ })
[PROOFSTEP]
simp [PresheafedSpace.congr_app (F.map_comp f g)]
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
j k : Jᵒᵖ
f : j ⟶ k
⊢ (Opens.map (F.map f.unop).base).op.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)) =
    op ((Opens.map (colimit.ι F k.unop).base).obj U)
[PROOFSTEP]
rw [← colimit.w F f.unop, comp_base]
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
j k : Jᵒᵖ
f : j ⟶ k
⊢ (Opens.map (F.map f.unop).base).op.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)) =
    op ((Opens.map ((F.map f.unop).base ≫ (colimit.ι F j.unop).base)).obj U)
[PROOFSTEP]
rfl
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
x : Jᵒᵖ
⊢ { obj := fun j => (F.obj j.unop).presheaf.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)),
          map := fun {j k} f =>
            NatTrans.app (F.map f.unop).c (op ((Opens.map (colimit.ι F j.unop).base).obj U)) ≫
              (F.obj k.unop).presheaf.map
                (eqToHom
                  (_ :
                    (Opens.map (F.map f.unop).base).op.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)) =
                      op ((Opens.map (colimit.ι F k.unop).base).obj U))) }.map
      (𝟙 x) =
    𝟙
      ({ obj := fun j => (F.obj j.unop).presheaf.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)),
            map := fun {j k} f =>
              NatTrans.app (F.map f.unop).c (op ((Opens.map (colimit.ι F j.unop).base).obj U)) ≫
                (F.obj k.unop).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map (F.map f.unop).base).op.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)) =
                        op ((Opens.map (colimit.ι F k.unop).base).obj U))) }.obj
        x)
[PROOFSTEP]
dsimp
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
x : Jᵒᵖ
⊢ NatTrans.app (F.map (𝟙 x.unop)).c (op ((Opens.map (colimit.ι F x.unop).base).obj U)) ≫
      (F.obj x.unop).presheaf.map
        (eqToHom
          (_ :
            op ((Opens.map (F.map (𝟙 x.unop)).base).obj ((Opens.map (colimit.ι F x.unop).base).obj U)) =
              op ((Opens.map (colimit.ι F x.unop).base).obj U))) =
    𝟙 ((F.obj x.unop).presheaf.obj (op ((Opens.map (colimit.ι F x.unop).base).obj U)))
[PROOFSTEP]
simp [map_id_c_app, pushforwardObj_obj, op_obj, unop_op, pushforwardEq_hom_app, eqToHom_op, id_eq, eqToHom_map, assoc,
  eqToHom_trans, eqToHom_refl, comp_id, TopCat.Presheaf.Pushforward.id_inv_app']
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
x : Jᵒᵖ
⊢ NatTrans.app (Pushforward.id (F.obj x.unop).presheaf).inv (op ((Opens.map (colimit.ι F x.unop).base).obj U)) =
    𝟙 ((F.obj x.unop).presheaf.obj (op ((Opens.map (colimit.ι F x.unop).base).obj U)))
[PROOFSTEP]
rw [TopCat.Presheaf.Pushforward.id_inv_app']
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
x : Jᵒᵖ
⊢ (F.obj x.unop).presheaf.map
      (𝟙
        (op
          { carrier := ((Opens.map (colimit.ι F x.unop).base).toPrefunctor.1 U).carrier,
            is_open' := (_ : IsOpen ((Opens.map (colimit.ι F x.unop).base).toPrefunctor.1 U).carrier) })) =
    𝟙 ((F.obj x.unop).presheaf.obj (op ((Opens.map (colimit.ι F x.unop).base).obj U)))
[PROOFSTEP]
simp only [Opens.carrier_eq_coe, Opens.mk_coe, map_id]
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
i j k : Jᵒᵖ
f : i ⟶ j
g : j ⟶ k
⊢ { obj := fun j => (F.obj j.unop).presheaf.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)),
          map := fun {j k} f =>
            NatTrans.app (F.map f.unop).c (op ((Opens.map (colimit.ι F j.unop).base).obj U)) ≫
              (F.obj k.unop).presheaf.map
                (eqToHom
                  (_ :
                    (Opens.map (F.map f.unop).base).op.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)) =
                      op ((Opens.map (colimit.ι F k.unop).base).obj U))) }.map
      (f ≫ g) =
    { obj := fun j => (F.obj j.unop).presheaf.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)),
            map := fun {j k} f =>
              NatTrans.app (F.map f.unop).c (op ((Opens.map (colimit.ι F j.unop).base).obj U)) ≫
                (F.obj k.unop).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map (F.map f.unop).base).op.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)) =
                        op ((Opens.map (colimit.ι F k.unop).base).obj U))) }.map
        f ≫
      { obj := fun j => (F.obj j.unop).presheaf.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)),
            map := fun {j k} f =>
              NatTrans.app (F.map f.unop).c (op ((Opens.map (colimit.ι F j.unop).base).obj U)) ≫
                (F.obj k.unop).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map (F.map f.unop).base).op.obj (op ((Opens.map (colimit.ι F j.unop).base).obj U)) =
                        op ((Opens.map (colimit.ι F k.unop).base).obj U))) }.map
        g
[PROOFSTEP]
dsimp
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
i j k : Jᵒᵖ
f : i ⟶ j
g : j ⟶ k
⊢ NatTrans.app (F.map (g.unop ≫ f.unop)).c (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
      (F.obj k.unop).presheaf.map
        (eqToHom
          (_ :
            op ((Opens.map (F.map (g.unop ≫ f.unop)).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
              op ((Opens.map (colimit.ι F k.unop).base).obj U))) =
    (NatTrans.app (F.map f.unop).c (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (F.map f.unop).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F j.unop).base).obj U)))) ≫
      NatTrans.app (F.map g.unop).c (op ((Opens.map (colimit.ι F j.unop).base).obj U)) ≫
        (F.obj k.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (F.map g.unop).base).obj ((Opens.map (colimit.ι F j.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F k.unop).base).obj U)))
[PROOFSTEP]
simp_rw [map_comp_c_app]
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
i j k : Jᵒᵖ
f : i ⟶ j
g : j ⟶ k
⊢ (NatTrans.app (F.map f.unop).c (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
        NatTrans.app (pushforwardMap (F.map f.unop).base (F.map g.unop).c)
            (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
          NatTrans.app (Pushforward.comp (F.obj k.unop).presheaf (F.map g.unop).base (F.map f.unop).base).inv
              (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
            NatTrans.app
              (pushforwardEq (_ : (F.map g.unop).base ≫ (F.map f.unop).base = (F.map (g.unop ≫ f.unop)).base)
                  (F.obj k.unop).presheaf).hom
              (op ((Opens.map (colimit.ι F i.unop).base).obj U))) ≫
      (F.obj k.unop).presheaf.map
        (eqToHom
          (_ :
            op ((Opens.map (F.map (g.unop ≫ f.unop)).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
              op ((Opens.map (colimit.ι F k.unop).base).obj U))) =
    (NatTrans.app (F.map f.unop).c (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (F.map f.unop).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F j.unop).base).obj U)))) ≫
      NatTrans.app (F.map g.unop).c (op ((Opens.map (colimit.ι F j.unop).base).obj U)) ≫
        (F.obj k.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (F.map g.unop).base).obj ((Opens.map (colimit.ι F j.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F k.unop).base).obj U)))
[PROOFSTEP]
simp only [op_obj, unop_op, eqToHom_op, id_eq, id_comp, assoc, eqToHom_trans]
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
i j k : Jᵒᵖ
f : i ⟶ j
g : j ⟶ k
⊢ NatTrans.app (F.map f.unop).c (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
      NatTrans.app (pushforwardMap (F.map f.unop).base (F.map g.unop).c)
          (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
        NatTrans.app (Pushforward.comp (F.obj k.unop).presheaf (F.map g.unop).base (F.map f.unop).base).inv
            (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
          NatTrans.app
              (pushforwardEq (_ : (F.map g.unop).base ≫ (F.map f.unop).base = (F.map (g.unop ≫ f.unop)).base)
                  (F.obj k.unop).presheaf).hom
              (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
            (F.obj k.unop).presheaf.map
              (eqToHom
                (_ :
                  op ((Opens.map (F.map (g.unop ≫ f.unop)).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
                    op ((Opens.map (colimit.ι F k.unop).base).obj U))) =
    NatTrans.app (F.map f.unop).c (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
      (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (F.map f.unop).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F j.unop).base).obj U))) ≫
        NatTrans.app (F.map g.unop).c (op ((Opens.map (colimit.ι F j.unop).base).obj U)) ≫
          (F.obj k.unop).presheaf.map
            (eqToHom
              (_ :
                op ((Opens.map (F.map g.unop).base).obj ((Opens.map (colimit.ι F j.unop).base).obj U)) =
                  op ((Opens.map (colimit.ι F k.unop).base).obj U)))
[PROOFSTEP]
congr 1
[GOAL]
case e_a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
i j k : Jᵒᵖ
f : i ⟶ j
g : j ⟶ k
⊢ NatTrans.app (pushforwardMap (F.map f.unop).base (F.map g.unop).c)
        (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
      NatTrans.app (Pushforward.comp (F.obj k.unop).presheaf (F.map g.unop).base (F.map f.unop).base).inv
          (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
        NatTrans.app
            (pushforwardEq (_ : (F.map g.unop).base ≫ (F.map f.unop).base = (F.map (g.unop ≫ f.unop)).base)
                (F.obj k.unop).presheaf).hom
            (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
          (F.obj k.unop).presheaf.map
            (eqToHom
              (_ :
                op ((Opens.map (F.map (g.unop ≫ f.unop)).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
                  op ((Opens.map (colimit.ι F k.unop).base).obj U))) =
    (F.obj j.unop).presheaf.map
        (eqToHom
          (_ :
            op ((Opens.map (F.map f.unop).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
              op ((Opens.map (colimit.ι F j.unop).base).obj U))) ≫
      NatTrans.app (F.map g.unop).c (op ((Opens.map (colimit.ι F j.unop).base).obj U)) ≫
        (F.obj k.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (F.map g.unop).base).obj ((Opens.map (colimit.ι F j.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F k.unop).base).obj U)))
[PROOFSTEP]
rw [TopCat.Presheaf.Pushforward.comp_inv_app, TopCat.Presheaf.pushforwardEq_hom_app,
  CategoryTheory.NatTrans.naturality_assoc, TopCat.Presheaf.pushforwardMap_app]
[GOAL]
case e_a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
i j k : Jᵒᵖ
f : i ⟶ j
g : j ⟶ k
⊢ NatTrans.app (F.map g.unop).c
        ((Opens.map (F.map f.unop).base).op.obj (op ((Opens.map (colimit.ι F i.unop).base).obj U))) ≫
      𝟙
          (((F.map f.unop).base _* ((F.map g.unop).base _* (F.obj k.unop).presheaf)).obj
            (op ((Opens.map (colimit.ι F i.unop).base).obj U))) ≫
        (F.obj k.unop).presheaf.map
            (_root_.id
              (eqToHom
                  (_ :
                    (Opens.map (F.map (g.unop ≫ f.unop)).base).obj
                        (op ((Opens.map (colimit.ι F i.unop).base).obj U)).unop =
                      (Opens.map ((F.map g.unop).base ≫ (F.map f.unop).base)).obj
                        (op ((Opens.map (colimit.ι F i.unop).base).obj U)).unop)).op) ≫
          (F.obj k.unop).presheaf.map
            (eqToHom
              (_ :
                op ((Opens.map (F.map (g.unop ≫ f.unop)).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
                  op ((Opens.map (colimit.ι F k.unop).base).obj U))) =
    NatTrans.app (F.map g.unop).c
        (op ((Opens.map (F.map f.unop).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U))) ≫
      ((F.map g.unop).base _* (F.obj k.unop).presheaf).map
          (eqToHom
            (_ :
              op ((Opens.map (F.map f.unop).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F j.unop).base).obj U))) ≫
        (F.obj k.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (F.map g.unop).base).obj ((Opens.map (colimit.ι F j.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F k.unop).base).obj U)))
[PROOFSTEP]
congr 1
[GOAL]
case e_a.e_a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(colimit F)
i j k : Jᵒᵖ
f : i ⟶ j
g : j ⟶ k
⊢ 𝟙
        (((F.map f.unop).base _* ((F.map g.unop).base _* (F.obj k.unop).presheaf)).obj
          (op ((Opens.map (colimit.ι F i.unop).base).obj U))) ≫
      (F.obj k.unop).presheaf.map
          (_root_.id
            (eqToHom
                (_ :
                  (Opens.map (F.map (g.unop ≫ f.unop)).base).obj
                      (op ((Opens.map (colimit.ι F i.unop).base).obj U)).unop =
                    (Opens.map ((F.map g.unop).base ≫ (F.map f.unop).base)).obj
                      (op ((Opens.map (colimit.ι F i.unop).base).obj U)).unop)).op) ≫
        (F.obj k.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (F.map (g.unop ≫ f.unop)).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F k.unop).base).obj U))) =
    ((F.map g.unop).base _* (F.obj k.unop).presheaf).map
        (eqToHom
          (_ :
            op ((Opens.map (F.map f.unop).base).obj ((Opens.map (colimit.ι F i.unop).base).obj U)) =
              op ((Opens.map (colimit.ι F j.unop).base).obj U))) ≫
      (F.obj k.unop).presheaf.map
        (eqToHom
          (_ :
            op ((Opens.map (F.map g.unop).base).obj ((Opens.map (colimit.ι F j.unop).base).obj U)) =
              op ((Opens.map (colimit.ι F k.unop).base).obj U)))
[PROOFSTEP]
simp
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
⊢ { obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
          map := fun {j j'} f =>
            (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                  (pushforwardEq (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                      (F.obj j).presheaf).hom).op }.map
      (𝟙 j) =
    𝟙
      ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
            map := fun {j j'} f =>
              (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                  (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                    (pushforwardEq (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                        (F.obj j).presheaf).hom).op }.obj
        j)
[PROOFSTEP]
apply (opEquiv _ _).injective
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
⊢ ↑(opEquiv
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j)
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j))
      ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
            map := fun {j j'} f =>
              (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                  (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                    (pushforwardEq (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                        (F.obj j).presheaf).hom).op }.map
        (𝟙 j)) =
    ↑(opEquiv
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j)
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j))
      (𝟙
        ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
              map := fun {j j'} f =>
                (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                    (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                      (pushforwardEq
                          (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                          (F.obj j).presheaf).hom).op }.obj
          j))
[PROOFSTEP]
refine NatTrans.ext _ _ (funext fun U => ?_)
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j))
        ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
              map := fun {j j'} f =>
                (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                    (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                      (pushforwardEq
                          (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                          (F.obj j).presheaf).hom).op }.map
          (𝟙 j)))
      U =
    NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j))
        (𝟙
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j)))
      U
[PROOFSTEP]
induction U with
| h U =>
  rcases U with ⟨U, hU⟩
  dsimp [comp_obj, forget_obj, Functor.comp_map, forget_map, op_comp, unop_op, pushforwardObj_obj, op_obj,
    Opens.map_obj, opEquiv, Equiv.coe_fn_mk, unop_comp, Quiver.Hom.unop_op, unop_id]
    -- Porting note : some `simp` lemmas are not picked up
  rw [NatTrans.comp_app, pushforwardMap_app, NatTrans.id_app]
  simp only [op_obj, unop_op, Opens.map_obj, map_id_c_app, Opens.map_id_obj', map_id, pushforwardEq_hom_app, eqToHom_op,
    id_eq, eqToHom_map, id_comp, TopCat.Presheaf.Pushforward.id_inv_app']
  rw [NatTrans.comp_app, Pushforward.comp_inv_app, id_comp]
  dsimp
  simp
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j))
        ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
              map := fun {j j'} f =>
                (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                    (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                      (pushforwardEq
                          (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                          (F.obj j).presheaf).hom).op }.map
          (𝟙 j)))
      U =
    NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j))
        (𝟙
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j)))
      U
[PROOFSTEP]
induction U with
| h U =>
  rcases U with ⟨U, hU⟩
  dsimp [comp_obj, forget_obj, Functor.comp_map, forget_map, op_comp, unop_op, pushforwardObj_obj, op_obj,
    Opens.map_obj, opEquiv, Equiv.coe_fn_mk, unop_comp, Quiver.Hom.unop_op, unop_id]
    -- Porting note : some `simp` lemmas are not picked up
  rw [NatTrans.comp_app, pushforwardMap_app, NatTrans.id_app]
  simp only [op_obj, unop_op, Opens.map_obj, map_id_c_app, Opens.map_id_obj', map_id, pushforwardEq_hom_app, eqToHom_op,
    id_eq, eqToHom_map, id_comp, TopCat.Presheaf.Pushforward.id_inv_app']
  rw [NatTrans.comp_app, Pushforward.comp_inv_app, id_comp]
  dsimp
  simp
[GOAL]
case a.h
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
U : Opens ↑(colimit (F ⋙ forget C))
⊢ NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j))
        ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
              map := fun {j j'} f =>
                (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                    (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                      (pushforwardEq
                          (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                          (F.obj j).presheaf).hom).op }.map
          (𝟙 j)))
      (op U) =
    NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j))
        (𝟙
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j)))
      (op U)
[PROOFSTEP]

| h U =>
  rcases U with ⟨U, hU⟩
  dsimp [comp_obj, forget_obj, Functor.comp_map, forget_map, op_comp, unop_op, pushforwardObj_obj, op_obj,
    Opens.map_obj, opEquiv, Equiv.coe_fn_mk, unop_comp, Quiver.Hom.unop_op, unop_id]
    -- Porting note : some `simp` lemmas are not picked up
  rw [NatTrans.comp_app, pushforwardMap_app, NatTrans.id_app]
  simp only [op_obj, unop_op, Opens.map_obj, map_id_c_app, Opens.map_id_obj', map_id, pushforwardEq_hom_app, eqToHom_op,
    id_eq, eqToHom_map, id_comp, TopCat.Presheaf.Pushforward.id_inv_app']
  rw [NatTrans.comp_app, Pushforward.comp_inv_app, id_comp]
  dsimp
  simp
[GOAL]
case a.h
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
U : Opens ↑(colimit (F ⋙ forget C))
⊢ NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j))
        ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
              map := fun {j j'} f =>
                (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                    (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                      (pushforwardEq
                          (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                          (F.obj j).presheaf).hom).op }.map
          (𝟙 j)))
      (op U) =
    NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j))
        (𝟙
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j)))
      (op U)
[PROOFSTEP]
rcases U with ⟨U, hU⟩
[GOAL]
case a.h.mk
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
U : Set ↑(colimit (F ⋙ forget C))
hU : IsOpen U
⊢ NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j))
        ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
              map := fun {j j'} f =>
                (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                    (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                      (pushforwardEq
                          (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                          (F.obj j).presheaf).hom).op }.map
          (𝟙 j)))
      (op { carrier := U, is_open' := hU }) =
    NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j))
        (𝟙
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j)))
      (op { carrier := U, is_open' := hU })
[PROOFSTEP]
dsimp [comp_obj, forget_obj, Functor.comp_map, forget_map, op_comp, unop_op, pushforwardObj_obj, op_obj, Opens.map_obj,
  opEquiv, Equiv.coe_fn_mk, unop_comp, Quiver.Hom.unop_op, unop_id]
  -- Porting note : some `simp` lemmas are not picked up
[GOAL]
case a.h.mk
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
U : Set ↑(colimit (F ⋙ forget C))
hU : IsOpen U
⊢ NatTrans.app
      (pushforwardMap (colimit.ι (F ⋙ forget C) j) (F.map (𝟙 j)).c ≫
        (Pushforward.comp (F.obj j).presheaf (F.map (𝟙 j)).base (colimit.ι (F ⋙ forget C) j)).inv ≫
          (pushforwardEq (_ : (F ⋙ forget C).map (𝟙 j) ≫ colimit.ι (F ⋙ forget C) j = colimit.ι (F ⋙ forget C) j)
              (F.obj j).presheaf).hom)
      (op { carrier := U, is_open' := hU }) =
    NatTrans.app (𝟙 (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf)) (op { carrier := U, is_open' := hU })
[PROOFSTEP]
rw [NatTrans.comp_app, pushforwardMap_app, NatTrans.id_app]
[GOAL]
case a.h.mk
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
U : Set ↑(colimit (F ⋙ forget C))
hU : IsOpen U
⊢ NatTrans.app (F.map (𝟙 j)).c ((Opens.map (colimit.ι (F ⋙ forget C) j)).op.obj (op { carrier := U, is_open' := hU })) ≫
      NatTrans.app
        ((Pushforward.comp (F.obj j).presheaf (F.map (𝟙 j)).base (colimit.ι (F ⋙ forget C) j)).inv ≫
          (pushforwardEq (_ : (F ⋙ forget C).map (𝟙 j) ≫ colimit.ι (F ⋙ forget C) j = colimit.ι (F ⋙ forget C) j)
              (F.obj j).presheaf).hom)
        (op { carrier := U, is_open' := hU }) =
    𝟙 ((colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf).obj (op { carrier := U, is_open' := hU }))
[PROOFSTEP]
simp only [op_obj, unop_op, Opens.map_obj, map_id_c_app, Opens.map_id_obj', map_id, pushforwardEq_hom_app, eqToHom_op,
  id_eq, eqToHom_map, id_comp, TopCat.Presheaf.Pushforward.id_inv_app']
[GOAL]
case a.h.mk
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
U : Set ↑(colimit (F ⋙ forget C))
hU : IsOpen U
⊢ eqToHom
        (_ :
          (F.obj j).presheaf.obj
              (op
                { carrier := ↑(𝟙 ↑(F.obj j)) ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U),
                  is_open' := (_ : IsOpen (↑(𝟙 ↑(F.obj j)) ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U))) }) =
            (F.obj j).presheaf.obj
              (op
                { carrier := ↑(F.map (𝟙 j)).base ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U),
                  is_open' := (_ : IsOpen (↑(F.map (𝟙 j)).base ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U))) })) ≫
      NatTrans.app
        ((Pushforward.comp (F.obj j).presheaf (F.map (𝟙 j)).base (colimit.ι (F ⋙ forget C) j)).inv ≫
          (pushforwardEq (_ : (F ⋙ forget C).map (𝟙 j) ≫ colimit.ι (F ⋙ forget C) j = colimit.ι (F ⋙ forget C) j)
              (F.obj j).presheaf).hom)
        (op { carrier := U, is_open' := hU }) =
    𝟙 ((colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf).obj (op { carrier := U, is_open' := hU }))
[PROOFSTEP]
rw [NatTrans.comp_app, Pushforward.comp_inv_app, id_comp]
[GOAL]
case a.h.mk
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
U : Set ↑(colimit (F ⋙ forget C))
hU : IsOpen U
⊢ eqToHom
        (_ :
          (F.obj j).presheaf.obj
              (op
                { carrier := ↑(𝟙 ↑(F.obj j)) ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U),
                  is_open' := (_ : IsOpen (↑(𝟙 ↑(F.obj j)) ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U))) }) =
            (F.obj j).presheaf.obj
              (op
                { carrier := ↑(F.map (𝟙 j)).base ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U),
                  is_open' := (_ : IsOpen (↑(F.map (𝟙 j)).base ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U))) })) ≫
      NatTrans.app
        (pushforwardEq (_ : (F ⋙ forget C).map (𝟙 j) ≫ colimit.ι (F ⋙ forget C) j = colimit.ι (F ⋙ forget C) j)
            (F.obj j).presheaf).hom
        (op { carrier := U, is_open' := hU }) =
    𝟙 ((colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf).obj (op { carrier := U, is_open' := hU }))
[PROOFSTEP]
dsimp
[GOAL]
case a.h.mk
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j : J
U : Set ↑(colimit (F ⋙ forget C))
hU : IsOpen U
⊢ eqToHom
        (_ :
          (F.obj j).presheaf.obj
              (op
                { carrier := ↑(𝟙 ↑(F.obj j)) ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U),
                  is_open' := (_ : IsOpen (↑(𝟙 ↑(F.obj j)) ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U))) }) =
            (F.obj j).presheaf.obj
              (op
                { carrier := ↑(F.map (𝟙 j)).base ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U),
                  is_open' := (_ : IsOpen (↑(F.map (𝟙 j)).base ⁻¹' (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U))) })) ≫
      NatTrans.app
        (pushforwardEq (_ : (F ⋙ forget C).map (𝟙 j) ≫ colimit.ι (F ⋙ forget C) j = colimit.ι (F ⋙ forget C) j)
            (F.obj j).presheaf).hom
        (op { carrier := U, is_open' := hU }) =
    𝟙
      ((F.obj j).presheaf.obj
        (op
          { carrier := ↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U,
            is_open' := (_ : IsOpen (↑(colimit.ι (F ⋙ forget C) j) ⁻¹' U)) }))
[PROOFSTEP]
simp
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
⊢ { obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
          map := fun {j j'} f =>
            (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                  (pushforwardEq (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                      (F.obj j).presheaf).hom).op }.map
      (f ≫ g) =
    { obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
            map := fun {j j'} f =>
              (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                  (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                    (pushforwardEq (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                        (F.obj j).presheaf).hom).op }.map
        f ≫
      { obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
            map := fun {j j'} f =>
              (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                  (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                    (pushforwardEq (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                        (F.obj j).presheaf).hom).op }.map
        g
[PROOFSTEP]
apply (opEquiv _ _).injective
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
⊢ ↑(opEquiv
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j₁)
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j₃))
      ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
            map := fun {j j'} f =>
              (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                  (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                    (pushforwardEq (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                        (F.obj j).presheaf).hom).op }.map
        (f ≫ g)) =
    ↑(opEquiv
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j₁)
          ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.obj
            j₃))
      ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
              map := fun {j j'} f =>
                (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                    (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                      (pushforwardEq
                          (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                          (F.obj j).presheaf).hom).op }.map
          f ≫
        { obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
              map := fun {j j'} f =>
                (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                    (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                      (pushforwardEq
                          (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                          (F.obj j).presheaf).hom).op }.map
          g)
[PROOFSTEP]
refine NatTrans.ext _ _ (funext fun U => ?_)
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j₁)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j₃))
        ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
              map := fun {j j'} f =>
                (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                    (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                      (pushforwardEq
                          (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                          (F.obj j).presheaf).hom).op }.map
          (f ≫ g)))
      U =
    NatTrans.app
      (↑(opEquiv
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j₁)
            ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                  map := fun {j j'} f =>
                    (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                        (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                          (pushforwardEq
                              (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                              (F.obj j).presheaf).hom).op }.obj
              j₃))
        ({ obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.map
            f ≫
          { obj := fun j => op (colimit.ι (F ⋙ forget C) j _* (F.obj j).presheaf),
                map := fun {j j'} f =>
                  (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
                      (Pushforward.comp (F.obj j).presheaf ((F ⋙ forget C).map f) (colimit.ι (F ⋙ forget C) j')).inv ≫
                        (pushforwardEq
                            (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                            (F.obj j).presheaf).hom).op }.map
            g))
      U
[PROOFSTEP]
dsimp only [comp_obj, forget_obj, Functor.comp_map, forget_map, op_comp, unop_op, pushforwardObj_obj, op_obj, opEquiv,
  Equiv.coe_fn_mk, unop_comp, Quiver.Hom.unop_op]
  -- Porting note : some `simp` lemmas are not picked up
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ NatTrans.app
      (pushforwardMap (colimit.ι (F ⋙ forget C) j₃) (F.map (f ≫ g)).c ≫
        (Pushforward.comp (F.obj j₁).presheaf (F.map (f ≫ g)).base (colimit.ι (F ⋙ forget C) j₃)).inv ≫
          (pushforwardEq (_ : (F ⋙ forget C).map (f ≫ g) ≫ colimit.ι (F ⋙ forget C) j₃ = colimit.ι (F ⋙ forget C) j₁)
              (F.obj j₁).presheaf).hom)
      U =
    NatTrans.app
      ((pushforwardMap (colimit.ι (F ⋙ forget C) j₃) (F.map g).c ≫
          (Pushforward.comp (F.obj j₂).presheaf (F.map g).base (colimit.ι (F ⋙ forget C) j₃)).inv ≫
            (pushforwardEq (_ : (F ⋙ forget C).map g ≫ colimit.ι (F ⋙ forget C) j₃ = colimit.ι (F ⋙ forget C) j₂)
                (F.obj j₂).presheaf).hom) ≫
        pushforwardMap (colimit.ι (F ⋙ forget C) j₂) (F.map f).c ≫
          (Pushforward.comp (F.obj j₁).presheaf (F.map f).base (colimit.ι (F ⋙ forget C) j₂)).inv ≫
            (pushforwardEq (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j₂ = colimit.ι (F ⋙ forget C) j₁)
                (F.obj j₁).presheaf).hom)
      U
[PROOFSTEP]
rw [NatTrans.comp_app, pushforwardMap_app, NatTrans.comp_app, Pushforward.comp_inv_app, id_comp, pushforwardEq_hom_app,
  NatTrans.comp_app, NatTrans.comp_app, NatTrans.comp_app, pushforwardMap_app, Pushforward.comp_inv_app, id_comp,
  pushforwardEq_hom_app, NatTrans.comp_app, NatTrans.comp_app, pushforwardEq_hom_app, Pushforward.comp_inv_app, id_comp,
  pushforwardMap_app]
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ NatTrans.app (F.map (f ≫ g)).c ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).op.obj U) ≫
      (F.obj j₁).presheaf.map
        (_root_.id
          (eqToHom
              (_ :
                (Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop =
                  (Opens.map ((F.map (f ≫ g)).base ≫ colimit.ι (F ⋙ forget C) j₃)).obj U.unop)).op) =
    (NatTrans.app (F.map g).c ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).op.obj U) ≫
        (F.obj j₂).presheaf.map
          (_root_.id
            (eqToHom
                (_ :
                  (Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop =
                    (Opens.map ((F.map g).base ≫ colimit.ι (F ⋙ forget C) j₃)).obj U.unop)).op)) ≫
      NatTrans.app (F.map f).c ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).op.obj U) ≫
        (F.obj j₁).presheaf.map
          (_root_.id
            (eqToHom
                (_ :
                  (Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop =
                    (Opens.map ((F.map f).base ≫ colimit.ι (F ⋙ forget C) j₂)).obj U.unop)).op)
[PROOFSTEP]
simp only [pushforwardObj_obj, op_obj, unop_op, map_comp_c_app, pushforwardMap_app, Opens.map_comp_obj,
  Pushforward.comp_inv_app, pushforwardEq_hom_app, eqToHom_op, id_eq, eqToHom_map, id_comp, assoc, eqToHom_trans]
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ NatTrans.app (F.map g).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)) ≫
      NatTrans.app (F.map f).c
          (op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))) ≫
        eqToHom
          (_ :
            (F.obj j₁).presheaf.obj
                (op
                  ((Opens.map (F.map f).base).obj
                    ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)))) =
              (F.obj j₁).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop))) =
    NatTrans.app (F.map g).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)) ≫
      eqToHom
          (_ :
            (F.obj j₂).presheaf.obj
                (op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))) =
              (F.obj j₂).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) ≫
        NatTrans.app (F.map f).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)) ≫
          eqToHom
            (_ :
              (F.obj j₁).presheaf.obj
                  (op ((Opens.map (F.map f).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) =
                (F.obj j₁).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop)))
[PROOFSTEP]
dsimp
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ NatTrans.app (F.map g).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)) ≫
      NatTrans.app (F.map f).c
          (op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))) ≫
        eqToHom
          (_ :
            (F.obj j₁).presheaf.obj
                (op
                  ((Opens.map (F.map f).base).obj
                    ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)))) =
              (F.obj j₁).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop))) =
    NatTrans.app (F.map g).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)) ≫
      eqToHom
          (_ :
            (F.obj j₂).presheaf.obj
                (op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))) =
              (F.obj j₂).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) ≫
        NatTrans.app (F.map f).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)) ≫
          eqToHom
            (_ :
              (F.obj j₁).presheaf.obj
                  (op ((Opens.map (F.map f).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) =
                (F.obj j₁).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop)))
[PROOFSTEP]
congr 1
  -- The key fact is `(F.map f).c.congr`,
      -- which allows us in rewrite in the argument of `(F.map f).c.app`.
[GOAL]
case a.e_a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ NatTrans.app (F.map f).c
        (op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))) ≫
      eqToHom
        (_ :
          (F.obj j₁).presheaf.obj
              (op
                ((Opens.map (F.map f).base).obj
                  ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)))) =
            (F.obj j₁).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop))) =
    eqToHom
        (_ :
          (F.obj j₂).presheaf.obj
              (op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))) =
            (F.obj j₂).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) ≫
      NatTrans.app (F.map f).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)) ≫
        eqToHom
          (_ :
            (F.obj j₁).presheaf.obj
                (op ((Opens.map (F.map f).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) =
              (F.obj j₁).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop)))
[PROOFSTEP]
rw [@NatTrans.congr (α := (F.map f).c)
    (op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)))
    (op ((Opens.map (colimit.ι (F ⋙ PresheafedSpace.forget C) j₂)).obj (unop U))) _]
[GOAL]
case a.e_a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ ((F.obj j₂).presheaf.map (eqToHom ?m.93087) ≫
        NatTrans.app (F.map f).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)) ≫
          ((F.map f).base _* (F.obj j₁).presheaf).map
            (eqToHom
              (_ :
                op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop) =
                  op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))))) ≫
      eqToHom
        (_ :
          (F.obj j₁).presheaf.obj
              (op
                ((Opens.map (F.map f).base).obj
                  ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)))) =
            (F.obj j₁).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop))) =
    eqToHom
        (_ :
          (F.obj j₂).presheaf.obj
              (op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))) =
            (F.obj j₂).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) ≫
      NatTrans.app (F.map f).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)) ≫
        eqToHom
          (_ :
            (F.obj j₁).presheaf.obj
                (op ((Opens.map (F.map f).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) =
              (F.obj j₁).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop)))
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)) =
    op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)
[PROOFSTEP]
swap
  -- Now we show the open sets are equal.
[GOAL]
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)) =
    op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)
[PROOFSTEP]
apply unop_injective
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ (op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))).unop =
    (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)).unop
[PROOFSTEP]
rw [← Opens.map_comp_obj]
[GOAL]
case a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ (op ((Opens.map ((F.map g).base ≫ colimit.ι (F ⋙ forget C) j₃)).obj U.unop)).unop =
    (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)).unop
[PROOFSTEP]
congr
[GOAL]
case a.e_self.e_x.e_self.e_self.e_f
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ (F.map g).base ≫ colimit.ι (F ⋙ forget C) j₃ = colimit.ι (F ⋙ forget C) j₂
[PROOFSTEP]
exact colimit.w (F ⋙ PresheafedSpace.forget C) g
[GOAL]
case a.e_a
J : Type u'
inst✝² : Category.{v', u'} J
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimitsOfShape J TopCat
F : J ⥤ PresheafedSpace C
j₁ j₂ j₃ : J
f : j₁ ⟶ j₂
g : j₂ ⟶ j₃
U : (Opens ↑(colimit (F ⋙ forget C)))ᵒᵖ
⊢ ((F.obj j₂).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)) =
                op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) ≫
        NatTrans.app (F.map f).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)) ≫
          ((F.map f).base _* (F.obj j₁).presheaf).map
            (eqToHom
              (_ :
                op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop) =
                  op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))))) ≫
      eqToHom
        (_ :
          (F.obj j₁).presheaf.obj
              (op
                ((Opens.map (F.map f).base).obj
                  ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop)))) =
            (F.obj j₁).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop))) =
    eqToHom
        (_ :
          (F.obj j₂).presheaf.obj
              (op ((Opens.map (F.map g).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₃)).obj U.unop))) =
            (F.obj j₂).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) ≫
      NatTrans.app (F.map f).c (op ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop)) ≫
        eqToHom
          (_ :
            (F.obj j₁).presheaf.obj
                (op ((Opens.map (F.map f).base).obj ((Opens.map (colimit.ι (F ⋙ forget C) j₂)).obj U.unop))) =
              (F.obj j₁).presheaf.obj (op ((Opens.map (colimit.ι (F ⋙ forget C) j₁)).obj U.unop)))
[PROOFSTEP]
simp
[GOAL]
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
⊢ F.map f ≫
      (fun j => { base := colimit.ι (F ⋙ forget C) j, c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) }) j' =
    (fun j => { base := colimit.ι (F ⋙ forget C) j, c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) }) j ≫
      ((Functor.const J).obj (colimit F)).map f
[PROOFSTEP]
ext1
[GOAL]
case w
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
⊢ (F.map f ≫
        (fun j => { base := colimit.ι (F ⋙ forget C) j, c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) })
          j').base =
    ((fun j => { base := colimit.ι (F ⋙ forget C) j, c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) }) j ≫
        ((Functor.const J).obj (colimit F)).map f).base
[PROOFSTEP]
ext x
[GOAL]
case w.w
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
x : (CategoryTheory.forget TopCat).obj ↑(F.obj j)
⊢ ↑(F.map f ≫
            (fun j =>
                { base := colimit.ι (F ⋙ forget C) j, c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) })
              j').base
      x =
    ↑((fun j => { base := colimit.ι (F ⋙ forget C) j, c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) }) j ≫
            ((Functor.const J).obj (colimit F)).map f).base
      x
[PROOFSTEP]
exact colimit.w_apply (F ⋙ PresheafedSpace.forget C) f x
[GOAL]
case h
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
⊢ (F.map f ≫
          (fun j => { base := colimit.ι (F ⋙ forget C) j, c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) })
            j').c ≫
      whiskerRight
        (eqToHom
          (_ :
            (Opens.map
                  (F.map f ≫
                      (fun j =>
                          { base := colimit.ι (F ⋙ forget C) j,
                            c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) })
                        j').base).op =
              (Opens.map
                  ((fun j =>
                          { base := colimit.ι (F ⋙ forget C) j,
                            c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) })
                        j ≫
                      ((Functor.const J).obj (colimit F)).map f).base).op))
        (F.obj j).presheaf =
    ((fun j => { base := colimit.ι (F ⋙ forget C) j, c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) }) j ≫
        ((Functor.const J).obj (colimit F)).map f).c
[PROOFSTEP]
ext ⟨U, hU⟩
[GOAL]
case h.w.mk
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
U : Set ↑↑(((Functor.const J).obj (colimit F)).obj j')
hU : IsOpen U
⊢ NatTrans.app
      ((F.map f ≫
            (fun j =>
                { base := colimit.ι (F ⋙ forget C) j, c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) })
              j').c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map
                    (F.map f ≫
                        (fun j =>
                            { base := colimit.ι (F ⋙ forget C) j,
                              c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) })
                          j').base).op =
                (Opens.map
                    ((fun j =>
                            { base := colimit.ι (F ⋙ forget C) j,
                              c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) })
                          j ≫
                        ((Functor.const J).obj (colimit F)).map f).base).op))
          (F.obj j).presheaf)
      (op { carrier := U, is_open' := hU }) =
    NatTrans.app
      ((fun j => { base := colimit.ι (F ⋙ forget C) j, c := limit.π (pushforwardDiagramToColimit F).leftOp (op j) }) j ≫
          ((Functor.const J).obj (colimit F)).map f).c
      (op { carrier := U, is_open' := hU })
[PROOFSTEP]
dsimp
[GOAL]
case h.w.mk
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
U : Set ↑↑(((Functor.const J).obj (colimit F)).obj j')
hU : IsOpen U
⊢ NatTrans.app
      ((F.map f ≫
            { base := colimit.ι (F ⋙ forget C) j', c := limit.π (pushforwardDiagramToColimit F).leftOp (op j') }).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map ((F.map f).base ≫ colimit.ι (F ⋙ forget C) j')).op =
                (Opens.map (colimit.ι (F ⋙ forget C) j ≫ 𝟙 (Limits.colimit (F ⋙ forget C)))).op))
          (F.obj j).presheaf)
      (op { carrier := U, is_open' := hU }) =
    NatTrans.app (𝟙 (colimit F)).c (op { carrier := U, is_open' := hU }) ≫
      NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp (op j)) (op { carrier := U, is_open' := hU })
[PROOFSTEP]
rw [PresheafedSpace.id_c_app, map_id]
[GOAL]
case h.w.mk
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
U : Set ↑↑(((Functor.const J).obj (colimit F)).obj j')
hU : IsOpen U
⊢ NatTrans.app
      ((F.map f ≫
            { base := colimit.ι (F ⋙ forget C) j', c := limit.π (pushforwardDiagramToColimit F).leftOp (op j') }).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map ((F.map f).base ≫ colimit.ι (F ⋙ forget C) j')).op =
                (Opens.map (colimit.ι (F ⋙ forget C) j ≫ 𝟙 (Limits.colimit (F ⋙ forget C)))).op))
          (F.obj j).presheaf)
      (op { carrier := U, is_open' := hU }) =
    𝟙 ((colimit F).presheaf.obj (op { carrier := U, is_open' := hU })) ≫
      NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp (op j)) (op { carrier := U, is_open' := hU })
[PROOFSTEP]
erw [id_comp]
[GOAL]
case h.w.mk
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
U : Set ↑↑(((Functor.const J).obj (colimit F)).obj j')
hU : IsOpen U
⊢ NatTrans.app
      ((F.map f ≫
            { base := colimit.ι (F ⋙ forget C) j', c := limit.π (pushforwardDiagramToColimit F).leftOp (op j') }).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map ((F.map f).base ≫ colimit.ι (F ⋙ forget C) j')).op =
                (Opens.map (colimit.ι (F ⋙ forget C) j ≫ 𝟙 (Limits.colimit (F ⋙ forget C)))).op))
          (F.obj j).presheaf)
      (op { carrier := U, is_open' := hU }) =
    NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp (op j)) (op { carrier := U, is_open' := hU })
[PROOFSTEP]
rw [NatTrans.comp_app, PresheafedSpace.comp_c_app, whiskerRight_app, eqToHom_app, ←
  congr_arg NatTrans.app (limit.w (pushforwardDiagramToColimit F).leftOp f.op), NatTrans.comp_app, Functor.leftOp_map,
  pushforwardDiagramToColimit_map]
[GOAL]
case h.w.mk
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
U : Set ↑↑(((Functor.const J).obj (colimit F)).obj j')
hU : IsOpen U
⊢ (NatTrans.app { base := colimit.ι (F ⋙ forget C) j', c := limit.π (pushforwardDiagramToColimit F).leftOp (op j') }.c
          (op { carrier := U, is_open' := hU }) ≫
        NatTrans.app (F.map f).c
          (op
            ((Opens.map
                  { base := colimit.ι (F ⋙ forget C) j',
                      c := limit.π (pushforwardDiagramToColimit F).leftOp (op j') }.base).obj
              (op { carrier := U, is_open' := hU }).unop))) ≫
      (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Opens.map ((F.map f).base ≫ colimit.ι (F ⋙ forget C) j')).op.obj (op { carrier := U, is_open' := hU }) =
              (Opens.map (colimit.ι (F ⋙ forget C) j ≫ 𝟙 (Limits.colimit (F ⋙ forget C)))).op.obj
                (op { carrier := U, is_open' := hU }))) =
    NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp (op j')) (op { carrier := U, is_open' := hU }) ≫
      NatTrans.app
        (pushforwardMap (colimit.ι (F ⋙ forget C) (op j').unop) (F.map f.op.unop).c ≫
              (Pushforward.comp (F.obj (op j).unop).presheaf ((F ⋙ forget C).map f.op.unop)
                    (colimit.ι (F ⋙ forget C) (op j').unop)).inv ≫
                (pushforwardEq
                    (_ :
                      (F ⋙ forget C).map f.op.unop ≫ colimit.ι (F ⋙ forget C) (op j').unop =
                        colimit.ι (F ⋙ forget C) (op j).unop)
                    (F.obj (op j).unop).presheaf).hom).op.unop
        (op { carrier := U, is_open' := hU })
[PROOFSTEP]
dsimp
[GOAL]
case h.w.mk
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
U : Set ↑↑(((Functor.const J).obj (colimit F)).obj j')
hU : IsOpen U
⊢ (NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp (op j')) (op { carrier := U, is_open' := hU }) ≫
        NatTrans.app (F.map f).c
          (op
            { carrier := ↑(colimit.ι (F ⋙ forget C) j') ⁻¹' U,
              is_open' := (_ : IsOpen (↑(colimit.ι (F ⋙ forget C) j') ⁻¹' U)) })) ≫
      (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Opens.map ((F.map f).base ≫ colimit.ι (F ⋙ forget C) j')).op.obj (op { carrier := U, is_open' := hU }) =
              (Opens.map (colimit.ι (F ⋙ forget C) j ≫ 𝟙 (Limits.colimit (F ⋙ forget C)))).op.obj
                (op { carrier := U, is_open' := hU }))) =
    NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp (op j')) (op { carrier := U, is_open' := hU }) ≫
      NatTrans.app
        (pushforwardMap (colimit.ι (F ⋙ forget C) j') (F.map f).c ≫
          (Pushforward.comp (F.obj j).presheaf (F.map f).base (colimit.ι (F ⋙ forget C) j')).inv ≫
            (pushforwardEq (_ : (F ⋙ forget C).map f ≫ colimit.ι (F ⋙ forget C) j' = colimit.ι (F ⋙ forget C) j)
                (F.obj j).presheaf).hom)
        (op { carrier := U, is_open' := hU })
[PROOFSTEP]
rw [NatTrans.comp_app, NatTrans.comp_app, pushforwardEq_hom_app, id.def, eqToHom_op, Pushforward.comp_inv_app, id_comp,
  pushforwardMap_app, ← assoc]
[GOAL]
case h.w.mk
J : Type u'
inst✝³ : Category.{v', u'} J
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasColimitsOfShape J TopCat
inst✝ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
F : J ⥤ PresheafedSpace C
j j' : J
f : j ⟶ j'
U : Set ↑↑(((Functor.const J).obj (colimit F)).obj j')
hU : IsOpen U
⊢ (NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp (op j')) (op { carrier := U, is_open' := hU }) ≫
        NatTrans.app (F.map f).c
          (op
            { carrier := ↑(colimit.ι (F ⋙ forget C) j') ⁻¹' U,
              is_open' := (_ : IsOpen (↑(colimit.ι (F ⋙ forget C) j') ⁻¹' U)) })) ≫
      (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Opens.map ((F.map f).base ≫ colimit.ι (F ⋙ forget C) j')).op.obj (op { carrier := U, is_open' := hU }) =
              (Opens.map (colimit.ι (F ⋙ forget C) j ≫ 𝟙 (Limits.colimit (F ⋙ forget C)))).op.obj
                (op { carrier := U, is_open' := hU }))) =
    (NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp (op j')) (op { carrier := U, is_open' := hU }) ≫
        NatTrans.app (F.map f).c
          ((Opens.map (colimit.ι (F ⋙ forget C) j')).op.obj (op { carrier := U, is_open' := hU }))) ≫
      (F.obj j).presheaf.map
        (eqToHom
          (_ :
            op
                ((Opens.map ((F.map f).base ≫ colimit.ι (F ⋙ forget C) j')).obj
                  (op { carrier := U, is_open' := hU }).unop) =
              op ((Opens.map (colimit.ι (F ⋙ forget C) j)).obj (op { carrier := U, is_open' := hU }).unop)))
[PROOFSTEP]
congr 1
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
⊢ s.pt.presheaf.obj U ⟶
    (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s) _* limit (pushforwardDiagramToColimit F).leftOp).obj U
[PROOFSTEP]
refine'
  limit.lift _
      { pt := s.pt.presheaf.obj U
        π :=
          { app := fun j => _
            naturality := fun j j' f => _ } } ≫
    (limitObjIsoLimitCompEvaluation _ _).inv
[GOAL]
case refine'_1
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
⊢ ((Functor.const Jᵒᵖ).obj (s.pt.presheaf.obj U)).obj j ⟶
    ((pushforwardDiagramToColimit F).leftOp ⋙
          (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
            ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj U)).obj
      j
[PROOFSTEP]
refine' (s.ι.app (unop j)).c.app U ≫ (F.obj (unop j)).presheaf.map (eqToHom _)
[GOAL]
case refine'_1
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
⊢ (Opens.map (NatTrans.app s.ι j.unop).base).op.obj U =
    (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
      ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj U)
[PROOFSTEP]
dsimp
[GOAL]
case refine'_1
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
⊢ op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop) =
    op
      ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))
[PROOFSTEP]
rw [← Opens.map_comp_obj]
[GOAL]
case refine'_1
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
⊢ op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop) =
    op ((Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)
[PROOFSTEP]
simp
[GOAL]
case refine'_2
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j j' : Jᵒᵖ
f : j ⟶ j'
⊢ ((Functor.const Jᵒᵖ).obj (s.pt.presheaf.obj U)).map f ≫
      (fun j =>
          NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
            (F.obj j.unop).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map (NatTrans.app s.ι j.unop).base).op.obj U =
                    (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                      ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj U))))
        j' =
    (fun j =>
          NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
            (F.obj j.unop).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map (NatTrans.app s.ι j.unop).base).op.obj U =
                    (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                      ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj U))))
        j ≫
      ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj U)).map
        f
[PROOFSTEP]
dsimp
[GOAL]
case refine'_2
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j j' : Jᵒᵖ
f : j ⟶ j'
⊢ 𝟙 (s.pt.presheaf.obj U) ≫
      NatTrans.app (NatTrans.app s.ι j'.unop).c U ≫
        (F.obj j'.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j'.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j'.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) =
    (NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))) ≫
      NatTrans.app (F.map f.unop).c
          (op
            ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app
            (Pushforward.comp (F.obj j'.unop).presheaf (F.map f.unop).base (colimit.ι (F ⋙ forget C) j.unop)).inv
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
          NatTrans.app
            (pushforwardEq
                (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) j.unop = colimit.ι (F ⋙ forget C) j'.unop)
                (F.obj j'.unop).presheaf).hom
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))
[PROOFSTEP]
rw [PresheafedSpace.congr_app (s.w f.unop).symm U]
[GOAL]
case refine'_2
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j j' : Jᵒᵖ
f : j ⟶ j'
⊢ 𝟙 (s.pt.presheaf.obj U) ≫
      (NatTrans.app (F.map f.unop ≫ NatTrans.app s.ι j.unop).c U ≫
          (F.obj j'.unop).presheaf.map
            (eqToHom
              (_ :
                (Opens.map (F.map f.unop ≫ NatTrans.app s.ι j.unop).base).op.obj U =
                  (Opens.map (NatTrans.app s.ι j'.unop).base).op.obj U))) ≫
        (F.obj j'.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j'.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j'.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) =
    (NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))) ≫
      NatTrans.app (F.map f.unop).c
          (op
            ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app
            (Pushforward.comp (F.obj j'.unop).presheaf (F.map f.unop).base (colimit.ι (F ⋙ forget C) j.unop)).inv
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
          NatTrans.app
            (pushforwardEq
                (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) j.unop = colimit.ι (F ⋙ forget C) j'.unop)
                (F.obj j'.unop).presheaf).hom
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))
[PROOFSTEP]
have w :=
  Functor.congr_obj (congr_arg Opens.map (colimit.ι_desc ((PresheafedSpace.forget C).mapCocone s) (unop j))) (unop U)
[GOAL]
case refine'_2
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j j' : Jᵒᵖ
f : j ⟶ j'
w :
  (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop =
    (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop
⊢ 𝟙 (s.pt.presheaf.obj U) ≫
      (NatTrans.app (F.map f.unop ≫ NatTrans.app s.ι j.unop).c U ≫
          (F.obj j'.unop).presheaf.map
            (eqToHom
              (_ :
                (Opens.map (F.map f.unop ≫ NatTrans.app s.ι j.unop).base).op.obj U =
                  (Opens.map (NatTrans.app s.ι j'.unop).base).op.obj U))) ≫
        (F.obj j'.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j'.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j'.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) =
    (NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))) ≫
      NatTrans.app (F.map f.unop).c
          (op
            ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app
            (Pushforward.comp (F.obj j'.unop).presheaf (F.map f.unop).base (colimit.ι (F ⋙ forget C) j.unop)).inv
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
          NatTrans.app
            (pushforwardEq
                (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) j.unop = colimit.ι (F ⋙ forget C) j'.unop)
                (F.obj j'.unop).presheaf).hom
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))
[PROOFSTEP]
simp only [Opens.map_comp_obj_unop] at w
[GOAL]
case refine'_2
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j j' : Jᵒᵖ
f : j ⟶ j'
w :
  (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
      ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop) =
    (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop
⊢ 𝟙 (s.pt.presheaf.obj U) ≫
      (NatTrans.app (F.map f.unop ≫ NatTrans.app s.ι j.unop).c U ≫
          (F.obj j'.unop).presheaf.map
            (eqToHom
              (_ :
                (Opens.map (F.map f.unop ≫ NatTrans.app s.ι j.unop).base).op.obj U =
                  (Opens.map (NatTrans.app s.ι j'.unop).base).op.obj U))) ≫
        (F.obj j'.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j'.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j'.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) =
    (NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))) ≫
      NatTrans.app (F.map f.unop).c
          (op
            ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app
            (Pushforward.comp (F.obj j'.unop).presheaf (F.map f.unop).base (colimit.ι (F ⋙ forget C) j.unop)).inv
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
          NatTrans.app
            (pushforwardEq
                (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) j.unop = colimit.ι (F ⋙ forget C) j'.unop)
                (F.obj j'.unop).presheaf).hom
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))
[PROOFSTEP]
replace w := congr_arg op w
[GOAL]
case refine'_2
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j j' : Jᵒᵖ
f : j ⟶ j'
w :
  op
      ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    op ((Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop)
⊢ 𝟙 (s.pt.presheaf.obj U) ≫
      (NatTrans.app (F.map f.unop ≫ NatTrans.app s.ι j.unop).c U ≫
          (F.obj j'.unop).presheaf.map
            (eqToHom
              (_ :
                (Opens.map (F.map f.unop ≫ NatTrans.app s.ι j.unop).base).op.obj U =
                  (Opens.map (NatTrans.app s.ι j'.unop).base).op.obj U))) ≫
        (F.obj j'.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j'.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j'.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) =
    (NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))) ≫
      NatTrans.app (F.map f.unop).c
          (op
            ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app
            (Pushforward.comp (F.obj j'.unop).presheaf (F.map f.unop).base (colimit.ι (F ⋙ forget C) j.unop)).inv
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
          NatTrans.app
            (pushforwardEq
                (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) j.unop = colimit.ι (F ⋙ forget C) j'.unop)
                (F.obj j'.unop).presheaf).hom
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))
[PROOFSTEP]
have w' := NatTrans.congr (F.map f.unop).c w
[GOAL]
case refine'_2
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j j' : Jᵒᵖ
f : j ⟶ j'
w :
  op
      ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    op ((Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop)
w' :
  NatTrans.app (F.map f.unop).c
      (op
        ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) =
    (F.obj j.unop).presheaf.map (eqToHom w) ≫
      NatTrans.app (F.map f.unop).c (op ((Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop)) ≫
        ((F.map f.unop).base _* (F.obj j'.unop).presheaf).map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))
⊢ 𝟙 (s.pt.presheaf.obj U) ≫
      (NatTrans.app (F.map f.unop ≫ NatTrans.app s.ι j.unop).c U ≫
          (F.obj j'.unop).presheaf.map
            (eqToHom
              (_ :
                (Opens.map (F.map f.unop ≫ NatTrans.app s.ι j.unop).base).op.obj U =
                  (Opens.map (NatTrans.app s.ι j'.unop).base).op.obj U))) ≫
        (F.obj j'.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j'.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j'.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) =
    (NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))) ≫
      NatTrans.app (F.map f.unop).c
          (op
            ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app
            (Pushforward.comp (F.obj j'.unop).presheaf (F.map f.unop).base (colimit.ι (F ⋙ forget C) j.unop)).inv
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
          NatTrans.app
            (pushforwardEq
                (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) j.unop = colimit.ι (F ⋙ forget C) j'.unop)
                (F.obj j'.unop).presheaf).hom
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))
[PROOFSTEP]
rw [w']
[GOAL]
case refine'_2
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U : (Opens ↑↑s.pt)ᵒᵖ
j j' : Jᵒᵖ
f : j ⟶ j'
w :
  op
      ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    op ((Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop)
w' :
  NatTrans.app (F.map f.unop).c
      (op
        ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) =
    (F.obj j.unop).presheaf.map (eqToHom w) ≫
      NatTrans.app (F.map f.unop).c (op ((Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop)) ≫
        ((F.map f.unop).base _* (F.obj j'.unop).presheaf).map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))
⊢ 𝟙 (s.pt.presheaf.obj U) ≫
      (NatTrans.app (F.map f.unop ≫ NatTrans.app s.ι j.unop).c U ≫
          (F.obj j'.unop).presheaf.map
            (eqToHom
              (_ :
                (Opens.map (F.map f.unop ≫ NatTrans.app s.ι j.unop).base).op.obj U =
                  (Opens.map (NatTrans.app s.ι j'.unop).base).op.obj U))) ≫
        (F.obj j'.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j'.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j'.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) =
    (NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop) =
                op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))) ≫
      ((F.obj j.unop).presheaf.map (eqToHom w) ≫
          NatTrans.app (F.map f.unop).c (op ((Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop)) ≫
            ((F.map f.unop).base _* (F.obj j'.unop).presheaf).map
              (eqToHom
                (_ :
                  op ((Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop) =
                    op
                      ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))) ≫
        NatTrans.app
            (Pushforward.comp (F.obj j'.unop).presheaf (F.map f.unop).base (colimit.ι (F ⋙ forget C) j.unop)).inv
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
          NatTrans.app
            (pushforwardEq
                (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) j.unop = colimit.ι (F ⋙ forget C) j'.unop)
                (F.obj j'.unop).presheaf).hom
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))
[PROOFSTEP]
simp
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
⊢ s.pt.presheaf.map i ≫ descCApp F s V =
    descCApp F s U ≫ (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s) _* (colimitCocone F).pt.presheaf).map i
[PROOFSTEP]
dsimp [descCApp]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
⊢ s.pt.presheaf.map i ≫
      limit.lift
          ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))
          { pt := s.pt.presheaf.obj V,
            π :=
              NatTrans.mk fun j =>
                NatTrans.app (NatTrans.app s.ι j.unop).c V ≫
                  (F.obj j.unop).presheaf.map
                    (eqToHom
                      (_ :
                        (Opens.map (NatTrans.app s.ι j.unop).base).op.obj V =
                          (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                            ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj V))) } ≫
        (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop))).inv =
    (limit.lift
          ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))
          { pt := s.pt.presheaf.obj U,
            π :=
              NatTrans.mk fun j =>
                NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
                  (F.obj j.unop).presheaf.map
                    (eqToHom
                      (_ :
                        (Opens.map (NatTrans.app s.ι j.unop).base).op.obj U =
                          (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                            ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj U))) } ≫
        (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))).inv) ≫
      (limit (pushforwardDiagramToColimit F).leftOp).map
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop).op
[PROOFSTEP]
refine limit_obj_ext (fun j => ?_)
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
⊢ (s.pt.presheaf.map i ≫
        limit.lift
            ((pushforwardDiagramToColimit F).leftOp ⋙
              (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))
            { pt := s.pt.presheaf.obj V,
              π :=
                NatTrans.mk fun j =>
                  NatTrans.app (NatTrans.app s.ι j.unop).c V ≫
                    (F.obj j.unop).presheaf.map
                      (eqToHom
                        (_ :
                          (Opens.map (NatTrans.app s.ι j.unop).base).op.obj V =
                            (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj V))) } ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop))).inv) ≫
      NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
        (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)) =
    ((limit.lift
            ((pushforwardDiagramToColimit F).leftOp ⋙
              (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))
            { pt := s.pt.presheaf.obj U,
              π :=
                NatTrans.mk fun j =>
                  NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
                    (F.obj j.unop).presheaf.map
                      (eqToHom
                        (_ :
                          (Opens.map (NatTrans.app s.ι j.unop).base).op.obj U =
                            (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj U))) } ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))).inv) ≫
        (limit (pushforwardDiagramToColimit F).leftOp).map
          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop).op) ≫
      NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
        (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop))
[PROOFSTEP]
simp only [limit.lift_π, NatTrans.naturality, limit.lift_π_assoc, eqToHom_map, assoc, pushforwardObj_map,
  NatTrans.naturality_assoc, op_map, limitObjIsoLimitCompEvaluation_inv_π_app_assoc,
  limitObjIsoLimitCompEvaluation_inv_π_app]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
⊢ NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      (F.obj j.unop).presheaf.map ((Opens.map (NatTrans.app s.ι j.unop).base).map i.unop).op ≫
        eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        ((pushforwardDiagramToColimit F).leftOp.obj j).map
          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop).op
[PROOFSTEP]
dsimp
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
⊢ NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      (F.obj j.unop).presheaf.map ((Opens.map (NatTrans.app s.ι j.unop).base).map i.unop).op ≫
        eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op
[PROOFSTEP]
have w :=
  Functor.congr_hom (congr_arg Opens.map (colimit.ι_desc ((PresheafedSpace.forget C).mapCocone s) (unop j))) i.unop
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop =
    eqToHom
        (_ :
          (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj
              V.unop =
            (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj V.unop) ≫
      (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).map i.unop ≫
        eqToHom
          (_ :
            (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop =
              (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj
                U.unop)
⊢ NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      (F.obj j.unop).presheaf.map ((Opens.map (NatTrans.app s.ι j.unop).base).map i.unop).op ≫
        eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op
[PROOFSTEP]
simp only [Opens.map_comp_map] at w
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
      ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop) =
    eqToHom
        (_ :
          (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj
              V.unop =
            (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj V.unop) ≫
      (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).map i.unop ≫
        eqToHom
          (_ :
            (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop =
              (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj
                U.unop)
⊢ NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      (F.obj j.unop).presheaf.map ((Opens.map (NatTrans.app s.ι j.unop).base).map i.unop).op ≫
        eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op
[PROOFSTEP]
replace w := congr_arg Quiver.Hom.op w
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op =
    (eqToHom
          (_ :
            (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj
                V.unop =
              (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj V.unop) ≫
        (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).map i.unop ≫
          eqToHom
            (_ :
              (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop =
                (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj
                  U.unop)).op
⊢ NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      (F.obj j.unop).presheaf.map ((Opens.map (NatTrans.app s.ι j.unop).base).map i.unop).op ≫
        eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        (F.obj j.unop).presheaf.map
          ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op
[PROOFSTEP]
rw [w]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
U V : (Opens ↑↑s.pt)ᵒᵖ
i : U ⟶ V
j : Jᵒᵖ
w :
  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).map
        ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).map i.unop)).op =
    (eqToHom
          (_ :
            (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj
                V.unop =
              (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj V.unop) ≫
        (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).map i.unop ≫
          eqToHom
            (_ :
              (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop =
                (Opens.map (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj
                  U.unop)).op
⊢ NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      (F.obj j.unop).presheaf.map ((Opens.map (NatTrans.app s.ι j.unop).base).map i.unop).op ≫
        eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj V.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj V.unop)))) =
    NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      eqToHom
          (_ :
            (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
              (F.obj j.unop).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))) ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
                (_ :
                  (Opens.map
                          (colimit.ι (F ⋙ forget C) j.unop ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj
                      V.unop =
                    (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj V.unop) ≫
              (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).map i.unop ≫
                eqToHom
                  (_ :
                    (Opens.map (NatTrans.app ((forget C).mapCocone s).ι j.unop)).obj U.unop =
                      (Opens.map
                            (colimit.ι (F ⋙ forget C) j.unop ≫
                              colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj
                        U.unop)).op
[PROOFSTEP]
simp
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
j : J
⊢ NatTrans.app (colimitCocone F).ι j ≫ desc F s = NatTrans.app s.ι j
[PROOFSTEP]
ext U
[GOAL]
case w.w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
j : J
U : (CategoryTheory.forget TopCat).obj ↑(F.obj j)
⊢ ↑(NatTrans.app (colimitCocone F).ι j ≫ desc F s).base U = ↑(NatTrans.app s.ι j).base U
[PROOFSTEP]
simp [desc]
[GOAL]
case h.w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
j : J
U : Opens ↑↑s.pt
⊢ NatTrans.app
      ((NatTrans.app (colimitCocone F).ι j ≫ desc F s).c ≫
        whiskerRight
          (eqToHom
            (_ :
              (Opens.map (NatTrans.app (colimitCocone F).ι j ≫ desc F s).base).op =
                (Opens.map (NatTrans.app s.ι j).base).op))
          (F.obj j).presheaf)
      (op U) =
    NatTrans.app (NatTrans.app s.ι j).c (op U)
[PROOFSTEP]
rw [NatTrans.comp_app, PresheafedSpace.comp_c_app, whiskerRight_app]
[GOAL]
case h.w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
j : J
U : Opens ↑↑s.pt
⊢ (NatTrans.app (desc F s).c (op U) ≫
        NatTrans.app (NatTrans.app (colimitCocone F).ι j).c (op ((Opens.map (desc F s).base).obj (op U).unop))) ≫
      (F.obj j).presheaf.map
        (NatTrans.app
          (eqToHom
            (_ :
              (Opens.map (NatTrans.app (colimitCocone F).ι j ≫ desc F s).base).op =
                (Opens.map (NatTrans.app s.ι j).base).op))
          (op U)) =
    NatTrans.app (NatTrans.app s.ι j).c (op U)
[PROOFSTEP]
dsimp [desc, descCApp]
[GOAL]
case h.w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
j : J
U : Opens ↑↑s.pt
⊢ ((limit.lift
            ((pushforwardDiagramToColimit F).leftOp ⋙
              (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U)))
            { pt := s.pt.presheaf.obj (op U),
              π :=
                NatTrans.mk fun j =>
                  NatTrans.app (NatTrans.app s.ι j.unop).c (op U) ≫
                    (F.obj j.unop).presheaf.map
                      (eqToHom
                        (_ :
                          (Opens.map (NatTrans.app s.ι j.unop).base).op.obj (op U) =
                            (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj (op U)))) } ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U))).inv) ≫
        NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp (op j))
          (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U))) ≫
      (F.obj j).presheaf.map
        (NatTrans.app
          (eqToHom
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) j ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op =
                (Opens.map (NatTrans.app s.ι j).base).op))
          (op U)) =
    NatTrans.app (NatTrans.app s.ι j).c (op U)
[PROOFSTEP]
simp only [eqToHom_app, op_obj, Opens.map_comp_obj, eqToHom_map, Functor.leftOp, assoc]
[GOAL]
case h.w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
j : J
U : Opens ↑↑s.pt
⊢ limit.lift
        (CategoryTheory.Functor.mk
            { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
              map := fun {X Y} f => ((pushforwardDiagramToColimit F).map f.unop).unop } ⋙
          (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U)))
        { pt := s.pt.presheaf.obj (op U),
          π :=
            NatTrans.mk fun j =>
              NatTrans.app (NatTrans.app s.ι j.unop).c (op U) ≫
                (F.obj j.unop).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map (NatTrans.app s.ι j.unop).base).op.obj (op U) =
                        (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj (op U)))) } ≫
      (limitObjIsoLimitCompEvaluation
            (CategoryTheory.Functor.mk
              { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
                map := fun {X Y} f => ((pushforwardDiagramToColimit F).map f.unop).unop })
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U))).inv ≫
        NatTrans.app
            (limit.π
              (CategoryTheory.Functor.mk
                { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
                  map := fun {X Y} f => ((pushforwardDiagramToColimit F).map f.unop).unop })
              (op j))
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U)) ≫
          eqToHom
            (_ :
              (F.obj j).presheaf.obj
                  (op
                    ((Opens.map (colimit.ι (F ⋙ forget C) j)).obj
                      ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U))) =
                (F.obj j).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j).base).obj U))) =
    NatTrans.app (NatTrans.app s.ι j).c (op U)
[PROOFSTEP]
rw [limitObjIsoLimitCompEvaluation_inv_π_app_assoc]
[GOAL]
case h.w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
j : J
U : Opens ↑↑s.pt
⊢ limit.lift
        (CategoryTheory.Functor.mk
            { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
              map := fun {X Y} f => ((pushforwardDiagramToColimit F).map f.unop).unop } ⋙
          (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U)))
        { pt := s.pt.presheaf.obj (op U),
          π :=
            NatTrans.mk fun j =>
              NatTrans.app (NatTrans.app s.ι j.unop).c (op U) ≫
                (F.obj j.unop).presheaf.map
                  (eqToHom
                    (_ :
                      (Opens.map (NatTrans.app s.ι j.unop).base).op.obj (op U) =
                        (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                          ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj (op U)))) } ≫
      limit.π
          (CategoryTheory.Functor.mk
              { obj := fun X => ((pushforwardDiagramToColimit F).obj X.unop).unop,
                map := fun {X Y} f => ((pushforwardDiagramToColimit F).map f.unop).unop } ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U)))
          (op j) ≫
        eqToHom
          (_ :
            (F.obj j).presheaf.obj
                (op
                  ((Opens.map (colimit.ι (F ⋙ forget C) j)).obj
                    ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U))) =
              (F.obj j).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j).base).obj U))) =
    NatTrans.app (NatTrans.app s.ι j).c (op U)
[PROOFSTEP]
simp
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
⊢ m = (fun s => desc F s) s
[PROOFSTEP]
have t : m.base = colimit.desc (F ⋙ PresheafedSpace.forget C) ((PresheafedSpace.forget C).mapCocone s) :=
  by
  dsimp
  ext j
  rw [colimit.ι_desc, mapCocone_ι_app, ← w j]
  simp
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
⊢ m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
[PROOFSTEP]
dsimp
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
⊢ m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
[PROOFSTEP]
ext j
[GOAL]
case w.w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
j : J
x✝ : (CategoryTheory.forget TopCat).obj ((F ⋙ forget C).obj j)
⊢ ↑(colimit.ι (F ⋙ forget C) j ≫ m.base) x✝ =
    ↑(colimit.ι (F ⋙ forget C) j ≫ colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)) x✝
[PROOFSTEP]
rw [colimit.ι_desc, mapCocone_ι_app, ← w j]
[GOAL]
case w.w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
j : J
x✝ : (CategoryTheory.forget TopCat).obj ((F ⋙ forget C).obj j)
⊢ ↑(colimit.ι (F ⋙ forget C) j ≫ m.base) x✝ = ↑((forget C).map (NatTrans.app (colimitCocone F).ι j ≫ m)) x✝
[PROOFSTEP]
simp
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
⊢ m = (fun s => desc F s) s
[PROOFSTEP]
ext : 1
[GOAL]
case w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
⊢ m.base = ((fun s => desc F s) s).base
[PROOFSTEP]
exact t
[GOAL]
case h
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
⊢ m.c ≫
      whiskerRight (eqToHom (_ : (Opens.map m.base).op = (Opens.map ((fun s => desc F s) s).base).op))
        (colimitCocone F).pt.presheaf =
    ((fun s => desc F s) s).c
[PROOFSTEP]
refine NatTrans.ext _ _ (funext fun U => limit_obj_ext fun j => ?_)
[GOAL]
case h
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
⊢ NatTrans.app
        (m.c ≫
          whiskerRight (eqToHom (_ : (Opens.map m.base).op = (Opens.map ((fun s => desc F s) s).base).op))
            (colimitCocone F).pt.presheaf)
        U ≫
      NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
        ((Opens.map ((fun s => desc F s) s).base).op.obj U) =
    NatTrans.app ((fun s => desc F s) s).c U ≫
      NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
        ((Opens.map ((fun s => desc F s) s).base).op.obj U)
[PROOFSTEP]
dsimp only [colimitCocone_pt, colimit_carrier, leftOp_obj, pushforwardDiagramToColimit_obj, comp_obj, forget_obj,
  unop_op, op_obj, desc, colimit_presheaf, descCApp, mapCocone_pt, pushforwardObj_obj, const_obj_obj, id_eq,
  evaluation_obj_obj, Eq.ndrec, eq_mpr_eq_cast]
[GOAL]
case h
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
⊢ NatTrans.app
        (m.c ≫
          whiskerRight
            (eqToHom
              (_ : (Opens.map m.base).op = (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op))
            (limit (pushforwardDiagramToColimit F).leftOp))
        U ≫
      NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
        (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    (limit.lift
          ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))
          { pt := s.pt.presheaf.obj U,
            π :=
              NatTrans.mk fun j =>
                NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
                  (F.obj j.unop).presheaf.map
                    (eqToHom
                      (_ :
                        (Opens.map (NatTrans.app s.ι j.unop).base).op.obj U =
                          (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                            ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj U))) } ≫
        (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))).inv) ≫
      NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
        (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))
[PROOFSTEP]
rw [NatTrans.comp_app, whiskerRight_app]
[GOAL]
case h
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
⊢ (NatTrans.app m.c U ≫
        (limit (pushforwardDiagramToColimit F).leftOp).map
          (NatTrans.app
            (eqToHom
              (_ : (Opens.map m.base).op = (Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op))
            U)) ≫
      NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
        (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    (limit.lift
          ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑(Limits.colimit (F ⋙ forget C)))ᵒᵖ C).obj
              (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)))
          { pt := s.pt.presheaf.obj U,
            π :=
              NatTrans.mk fun j =>
                NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
                  (F.obj j.unop).presheaf.map
                    (eqToHom
                      (_ :
                        (Opens.map (NatTrans.app s.ι j.unop).base).op.obj U =
                          (Opens.map (colimit.ι (F ⋙ forget C) j.unop)).op.obj
                            ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).op.obj U))) } ≫
        (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))).inv) ≫
      NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
        (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))
[PROOFSTEP]
simp only [pushforwardObj_obj, op_obj, comp_obj, eqToHom_app, eqToHom_map, assoc,
  limitObjIsoLimitCompEvaluation_inv_π_app, limit.lift_π]
[GOAL]
case h
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
⊢ NatTrans.app m.c U ≫
      eqToHom
          (_ :
            (limit (pushforwardDiagramToColimit F).leftOp).obj (op ((Opens.map m.base).obj U.unop)) =
              (limit (pushforwardDiagramToColimit F).leftOp).obj
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
          (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    NatTrans.app (NatTrans.app s.ι j.unop).c U ≫
      eqToHom
        (_ :
          (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
            (F.obj j.unop).presheaf.obj
              (op
                ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                  ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))
[PROOFSTEP]
rw [PresheafedSpace.congr_app (w (unop j)).symm U]
[GOAL]
case h
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
⊢ NatTrans.app m.c U ≫
      eqToHom
          (_ :
            (limit (pushforwardDiagramToColimit F).leftOp).obj (op ((Opens.map m.base).obj U.unop)) =
              (limit (pushforwardDiagramToColimit F).leftOp).obj
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
          (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    (NatTrans.app (NatTrans.app (colimitCocone F).ι j.unop ≫ m).c U ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              (Opens.map (NatTrans.app (colimitCocone F).ι j.unop ≫ m).base).op.obj U =
                (Opens.map (NatTrans.app s.ι j.unop).base).op.obj U))) ≫
      eqToHom
        (_ :
          (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
            (F.obj j.unop).presheaf.obj
              (op
                ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                  ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))
[PROOFSTEP]
dsimp
[GOAL]
case h
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
⊢ NatTrans.app m.c U ≫
      eqToHom
          (_ :
            (limit (pushforwardDiagramToColimit F).leftOp).obj (op ((Opens.map m.base).obj U.unop)) =
              (limit (pushforwardDiagramToColimit F).leftOp).obj
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
          (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    ((NatTrans.app m.c U ≫
          NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j) (op ((Opens.map m.base).obj U.unop))) ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app (colimitCocone F).ι j.unop ≫ m).base).obj U.unop) =
                op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)))) ≫
      eqToHom
        (_ :
          (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
            (F.obj j.unop).presheaf.obj
              (op
                ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                  ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))
[PROOFSTEP]
have w := congr_arg op (Functor.congr_obj (congr_arg Opens.map t) (unop U))
[GOAL]
case h
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w✝ : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
w :
  op ((Opens.map m.base).obj U.unop) =
    op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)
⊢ NatTrans.app m.c U ≫
      eqToHom
          (_ :
            (limit (pushforwardDiagramToColimit F).leftOp).obj (op ((Opens.map m.base).obj U.unop)) =
              (limit (pushforwardDiagramToColimit F).leftOp).obj
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
          (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    ((NatTrans.app m.c U ≫
          NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j) (op ((Opens.map m.base).obj U.unop))) ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app (colimitCocone F).ι j.unop ≫ m).base).obj U.unop) =
                op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)))) ≫
      eqToHom
        (_ :
          (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
            (F.obj j.unop).presheaf.obj
              (op
                ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                  ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))
[PROOFSTEP]
rw [NatTrans.congr (limit.π (pushforwardDiagramToColimit F).leftOp j) w]
[GOAL]
case h
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
s : Cocone F
m : (colimitCocone F).pt ⟶ s.pt
w✝ : ∀ (j : J), NatTrans.app (colimitCocone F).ι j ≫ m = NatTrans.app s.ι j
t : m.base = colimit.desc (F ⋙ forget C) ((forget C).mapCocone s)
U : (Opens ↑↑s.pt)ᵒᵖ
j : Jᵒᵖ
w :
  op ((Opens.map m.base).obj U.unop) =
    op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)
⊢ NatTrans.app m.c U ≫
      eqToHom
          (_ :
            (limit (pushforwardDiagramToColimit F).leftOp).obj (op ((Opens.map m.base).obj U.unop)) =
              (limit (pushforwardDiagramToColimit F).leftOp).obj
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
          (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) =
    ((NatTrans.app m.c U ≫
          (limit (pushforwardDiagramToColimit F).leftOp).map (eqToHom w) ≫
            NatTrans.app (limit.π (pushforwardDiagramToColimit F).leftOp j)
                (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
              ((pushforwardDiagramToColimit F).leftOp.obj j).map
                (eqToHom
                  (_ :
                    op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop) =
                      op ((Opens.map m.base).obj U.unop)))) ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (NatTrans.app (colimitCocone F).ι j.unop ≫ m).base).obj U.unop) =
                op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)))) ≫
      eqToHom
        (_ :
          (F.obj j.unop).presheaf.obj (op ((Opens.map (NatTrans.app s.ι j.unop).base).obj U.unop)) =
            (F.obj j.unop).presheaf.obj
              (op
                ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
                  ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))))
[PROOFSTEP]
simp
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
⊢ IsColimit ((forget C).mapCocone (colimitCocone F))
[PROOFSTEP]
apply IsColimit.ofIsoColimit (colimit.isColimit _)
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
⊢ colimit.cocone (F ⋙ forget C) ≅ (forget C).mapCocone (colimitCocone F)
[PROOFSTEP]
fapply Cocones.ext
[GOAL]
case φ
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
⊢ (colimit.cocone (F ⋙ forget C)).pt ≅ ((forget C).mapCocone (colimitCocone F)).pt
[PROOFSTEP]
rfl
[GOAL]
case w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
⊢ autoParam
    (∀ (j : J),
      NatTrans.app (colimit.cocone (F ⋙ forget C)).ι j ≫ (Iso.refl (colimit.cocone (F ⋙ forget C)).pt).hom =
        NatTrans.app ((forget C).mapCocone (colimitCocone F)).ι j)
    _auto✝
[PROOFSTEP]
intro j
[GOAL]
case w
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
j : J
⊢ NatTrans.app (colimit.cocone (F ⋙ forget C)).ι j ≫ (Iso.refl (colimit.cocone (F ⋙ forget C)).pt).hom =
    NatTrans.app ((forget C).mapCocone (colimitCocone F)).ι j
[PROOFSTEP]
simp
[GOAL]
J✝ : Type u'
inst✝⁵ : Category.{v', u'} J✝
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J✝ TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape J✝ᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape J✝ᵒᵖ C
inst✝ : HasLimits C
J : Type v
𝒥 : Category.{v, v} J
F : J ⥤ PresheafedSpace C
⊢ IsColimit ((forget C).mapCocone (colimitCocone F))
[PROOFSTEP]
apply IsColimit.ofIsoColimit (colimit.isColimit _)
[GOAL]
J✝ : Type u'
inst✝⁵ : Category.{v', u'} J✝
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J✝ TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape J✝ᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape J✝ᵒᵖ C
inst✝ : HasLimits C
J : Type v
𝒥 : Category.{v, v} J
F : J ⥤ PresheafedSpace C
⊢ colimit.cocone (F ⋙ forget C) ≅ (forget C).mapCocone (colimitCocone F)
[PROOFSTEP]
fapply Cocones.ext
[GOAL]
case φ
J✝ : Type u'
inst✝⁵ : Category.{v', u'} J✝
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J✝ TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape J✝ᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape J✝ᵒᵖ C
inst✝ : HasLimits C
J : Type v
𝒥 : Category.{v, v} J
F : J ⥤ PresheafedSpace C
⊢ (colimit.cocone (F ⋙ forget C)).pt ≅ ((forget C).mapCocone (colimitCocone F)).pt
[PROOFSTEP]
rfl
[GOAL]
case w
J✝ : Type u'
inst✝⁵ : Category.{v', u'} J✝
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J✝ TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape J✝ᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape J✝ᵒᵖ C
inst✝ : HasLimits C
J : Type v
𝒥 : Category.{v, v} J
F : J ⥤ PresheafedSpace C
⊢ autoParam
    (∀ (j : J),
      NatTrans.app (colimit.cocone (F ⋙ forget C)).ι j ≫ (Iso.refl (colimit.cocone (F ⋙ forget C)).pt).hom =
        NatTrans.app ((forget C).mapCocone (colimitCocone F)).ι j)
    _auto✝
[PROOFSTEP]
intro j
[GOAL]
case w
J✝ : Type u'
inst✝⁵ : Category.{v', u'} J✝
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J✝ TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape J✝ᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape J✝ᵒᵖ C
inst✝ : HasLimits C
J : Type v
𝒥 : Category.{v, v} J
F : J ⥤ PresheafedSpace C
j : J
⊢ NatTrans.app (colimit.cocone (F ⋙ forget C)).ι j ≫ (Iso.refl (colimit.cocone (F ⋙ forget C)).pt).hom =
    NatTrans.app ((forget C).mapCocone (colimitCocone F)).ι j
[PROOFSTEP]
simp
[GOAL]
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
⊢ (Limits.colimit F).presheaf.obj (op U) ≅ limit (componentwiseDiagram F U)
[PROOFSTEP]
refine' ((sheafIsoOfIso (colimit.isoColimitCocone ⟨_, colimitCoconeIsColimit F⟩).symm).app (op U)).trans _
[GOAL]
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
⊢ ((colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base _*
          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.pt.presheaf).obj
      (op U) ≅
    limit (componentwiseDiagram F U)
[PROOFSTEP]
refine' (limitObjIsoLimitCompEvaluation _ _).trans (Limits.lim.mapIso _)
[GOAL]
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
⊢ (pushforwardDiagramToColimit F).leftOp ⋙
      (evaluation (Opens ↑↑{ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.pt)ᵒᵖ C).obj
        ((Opens.map
                (colimit.isoColimitCocone
                        { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
          (op U)) ≅
    componentwiseDiagram F U
[PROOFSTEP]
fapply NatIso.ofComponents
[GOAL]
case app
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
⊢ (X : Jᵒᵖ) →
    ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑↑{ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.pt)ᵒᵖ
                  C).obj
              ((Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F,
                                isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                (op U))).obj
        X ≅
      (componentwiseDiagram F U).obj X
[PROOFSTEP]
intro X
[GOAL]
case app
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X : Jᵒᵖ
⊢ ((pushforwardDiagramToColimit F).leftOp ⋙
          (evaluation (Opens ↑↑{ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.pt)ᵒᵖ C).obj
            ((Opens.map
                    (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
              (op U))).obj
      X ≅
    (componentwiseDiagram F U).obj X
[PROOFSTEP]
refine' (F.obj (unop X)).presheaf.mapIso (eqToIso _)
[GOAL]
case app
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X : Jᵒᵖ
⊢ (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
      ((Opens.map
              (colimit.isoColimitCocone
                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
        (op U)) =
    op ((Opens.map (colimit.ι F X.unop).base).obj U)
[PROOFSTEP]
simp only [Functor.op_obj, unop_op, op_inj_iff, Opens.map_coe, SetLike.ext'_iff, Set.preimage_preimage]
[GOAL]
case app
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X : Jᵒᵖ
⊢ (fun x =>
        ↑(colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base
          (↑(colimit.ι (F ⋙ forget C) X.unop) x)) ⁻¹'
      ↑U =
    ↑(colimit.ι F X.unop).base ⁻¹' ↑U
[PROOFSTEP]
refine congr_arg (Set.preimage . U.1) (funext fun x => ?_)
[GOAL]
case app
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X : Jᵒᵖ
x : (CategoryTheory.forget TopCat).obj ((F ⋙ forget C).obj X.unop)
⊢ ↑(colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base
      (↑(colimit.ι (F ⋙ forget C) X.unop) x) =
    ↑(colimit.ι F X.unop).base x
[PROOFSTEP]
erw [← comp_app]
[GOAL]
case app
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X : Jᵒᵖ
x : (CategoryTheory.forget TopCat).obj ((F ⋙ forget C).obj X.unop)
⊢ ↑(colimit.ι (F ⋙ forget C) X.unop ≫
          (colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base)
      x =
    ↑(colimit.ι F X.unop).base x
[PROOFSTEP]
congr
[GOAL]
case app.e_a
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X : Jᵒᵖ
x : (CategoryTheory.forget TopCat).obj ((F ⋙ forget C).obj X.unop)
⊢ colimit.ι (F ⋙ forget C) X.unop ≫
      (colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base =
    (colimit.ι F X.unop).base
[PROOFSTEP]
exact ι_preservesColimitsIso_inv (forget C) F (unop X)
[GOAL]
case naturality
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
⊢ autoParam
    (∀ {X Y : Jᵒᵖ} (f : X ⟶ Y),
      ((pushforwardDiagramToColimit F).leftOp ⋙
                (evaluation (Opens ↑↑{ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.pt)ᵒᵖ
                      C).obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U))).map
            f ≫
          ((F.obj Y.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Opens.map (colimit.ι (F ⋙ forget C) Y.unop)).op.obj
                      ((Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                        (op U)) =
                    op ((Opens.map (colimit.ι F Y.unop).base).obj U)))).hom =
        ((F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                      ((Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                        (op U)) =
                    op ((Opens.map (colimit.ι F X.unop).base).obj U)))).hom ≫
          (componentwiseDiagram F U).map f)
    _auto✝
[PROOFSTEP]
intro X Y f
[GOAL]
case naturality
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X Y : Jᵒᵖ
f : X ⟶ Y
⊢ ((pushforwardDiagramToColimit F).leftOp ⋙
            (evaluation (Opens ↑↑{ cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.pt)ᵒᵖ
                  C).obj
              ((Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F,
                                isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                (op U))).map
        f ≫
      ((F.obj Y.unop).presheaf.mapIso
          (eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) Y.unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F Y.unop).base).obj U)))).hom =
    ((F.obj X.unop).presheaf.mapIso
          (eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F X.unop).base).obj U)))).hom ≫
      (componentwiseDiagram F U).map f
[PROOFSTEP]
change ((F.map f.unop).c.app _ ≫ _ ≫ _) ≫ (F.obj (unop Y)).presheaf.map _ = _ ≫ _
[GOAL]
case naturality
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X Y : Jᵒᵖ
f : X ⟶ Y
⊢ (NatTrans.app (F.map f.unop).c
          ((Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
            ((Opens.map
                    (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
              (op U))) ≫
        NatTrans.app
            (Pushforward.comp (F.obj Y.unop).presheaf ((F ⋙ forget C).map f.unop) (colimit.ι (F ⋙ forget C) X.unop)).inv
            ((Opens.map
                    (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
              (op U)) ≫
          NatTrans.app
            (pushforwardEq
                (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) X.unop = colimit.ι (F ⋙ forget C) Y.unop)
                (F.obj Y.unop).presheaf).hom
            ((Opens.map
                    (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
              (op U))) ≫
      (F.obj Y.unop).presheaf.map
        (eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) Y.unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F Y.unop).base).obj U))).hom =
    ((F.obj X.unop).presheaf.mapIso
          (eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F X.unop).base).obj U)))).hom ≫
      (componentwiseDiagram F U).map f
[PROOFSTEP]
rw [TopCat.Presheaf.Pushforward.comp_inv_app]
[GOAL]
case naturality
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X Y : Jᵒᵖ
f : X ⟶ Y
⊢ (NatTrans.app (F.map f.unop).c
          ((Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
            ((Opens.map
                    (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
              (op U))) ≫
        𝟙
            ((colimit.ι (F ⋙ forget C) X.unop _* ((F ⋙ forget C).map f.unop _* (F.obj Y.unop).presheaf)).obj
              ((Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F,
                                isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                (op U))) ≫
          NatTrans.app
            (pushforwardEq
                (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) X.unop = colimit.ι (F ⋙ forget C) Y.unop)
                (F.obj Y.unop).presheaf).hom
            ((Opens.map
                    (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
              (op U))) ≫
      (F.obj Y.unop).presheaf.map
        (eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) Y.unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F Y.unop).base).obj U))).hom =
    ((F.obj X.unop).presheaf.mapIso
          (eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F X.unop).base).obj U)))).hom ≫
      (componentwiseDiagram F U).map f
[PROOFSTEP]
erw [Category.id_comp]
[GOAL]
case naturality
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X Y : Jᵒᵖ
f : X ⟶ Y
⊢ (NatTrans.app (F.map f.unop).c
          ((Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
            ((Opens.map
                    (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
              (op U))) ≫
        NatTrans.app
          (pushforwardEq
              (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) X.unop = colimit.ι (F ⋙ forget C) Y.unop)
              (F.obj Y.unop).presheaf).hom
          ((Opens.map
                  (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
            (op U))) ≫
      (F.obj Y.unop).presheaf.map
        (eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) Y.unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F Y.unop).base).obj U))).hom =
    ((F.obj X.unop).presheaf.mapIso
          (eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F X.unop).base).obj U)))).hom ≫
      (componentwiseDiagram F U).map f
[PROOFSTEP]
rw [Category.assoc]
[GOAL]
case naturality
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X Y : Jᵒᵖ
f : X ⟶ Y
⊢ NatTrans.app (F.map f.unop).c
        ((Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
          ((Opens.map
                  (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
            (op U))) ≫
      NatTrans.app
          (pushforwardEq
              (_ : (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) X.unop = colimit.ι (F ⋙ forget C) Y.unop)
              (F.obj Y.unop).presheaf).hom
          ((Opens.map
                  (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
            (op U)) ≫
        (F.obj Y.unop).presheaf.map
          (eqToIso
              (_ :
                (Opens.map (colimit.ι (F ⋙ forget C) Y.unop)).op.obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                      (op U)) =
                  op ((Opens.map (colimit.ι F Y.unop).base).obj U))).hom =
    ((F.obj X.unop).presheaf.mapIso
          (eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F X.unop).base).obj U)))).hom ≫
      (componentwiseDiagram F U).map f
[PROOFSTEP]
erw [← (F.obj (unop Y)).presheaf.map_comp, (F.map f.unop).c.naturality_assoc, ← (F.obj (unop Y)).presheaf.map_comp]
[GOAL]
case naturality
J : Type u'
inst✝⁵ : Category.{v', u'} J
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasColimitsOfShape J TopCat
inst✝² : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝¹ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
inst✝ : HasColimit F
U : Opens ↑↑(Limits.colimit F)
X Y : Jᵒᵖ
f : X ⟶ Y
⊢ NatTrans.app (F.map f.unop).c
        ((Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
          ((Opens.map
                  (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
            (op U))) ≫
      (F.obj Y.unop).presheaf.map
        (NatTrans.app
            (NatIso.op
                (Opens.mapIso ((F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) X.unop)
                    (colimit.ι (F ⋙ forget C) Y.unop)
                    (_ :
                      (F ⋙ forget C).map f.unop ≫ colimit.ι (F ⋙ forget C) X.unop =
                        colimit.ι (F ⋙ forget C) Y.unop)).symm).hom
            ((Opens.map
                    (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
              (op U)) ≫
          (eqToIso
              (_ :
                (Opens.map (colimit.ι (F ⋙ forget C) Y.unop)).op.obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                      (op U)) =
                  op ((Opens.map (colimit.ι F Y.unop).base).obj U))).hom) =
    NatTrans.app (F.map f.unop).c
        ((Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
          ((Opens.map
                  (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
            (op U))) ≫
      (F.obj Y.unop).presheaf.map
        ((Opens.map (F.map f.unop).base).op.map
            (eqToIso
                (_ :
                  (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                      ((Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                        (op U)) =
                    op ((Opens.map (colimit.ι F X.unop).base).obj U))).hom ≫
          eqToHom
            (_ :
              (Opens.map (F.map f.unop).base).op.obj (op ((Opens.map (colimit.ι F X.unop).base).obj U)) =
                op ((Opens.map (colimit.ι F Y.unop).base).obj U)))
[PROOFSTEP]
rfl
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
⊢ (colimitPresheafObjIsoComponentwiseLimit F U).inv ≫ NatTrans.app (colimit.ι F j).c (op U) =
    limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
delta colimitPresheafObjIsoComponentwiseLimit
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
⊢ ((sheafIsoOfIso
                (colimit.isoColimitCocone
                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).symm).app
            (op U) ≪≫
          limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              ((Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F,
                                isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                (op U)) ≪≫
            Limits.lim.mapIso
              (NatIso.ofComponents fun X =>
                (F.obj X.unop).presheaf.mapIso
                  (eqToIso
                    (_ :
                      (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                          ((Opens.map
                                  (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                            (op U)) =
                        op ((Opens.map (colimit.ι F X.unop).base).obj U))))).inv ≫
      NatTrans.app (colimit.ι F j).c (op U) =
    limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
rw [Iso.trans_inv, Iso.trans_inv, Iso.app_inv, sheafIsoOfIso_inv, pushforwardToOfIso_app, congr_app (Iso.symm_inv _)]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
⊢ (((Limits.lim.mapIso
              (NatIso.ofComponents fun X =>
                (F.obj X.unop).presheaf.mapIso
                  (eqToIso
                    (_ :
                      (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                          ((Opens.map
                                  (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                            (op U)) =
                        op ((Opens.map (colimit.ι F X.unop).base).obj U))))).inv ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              ((Opens.map
                      (colimit.isoColimitCocone
                              { cocone := colimitCocone F,
                                isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                (op U))).inv) ≫
        (NatTrans.app
              (colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c
              (op
                ((Opens.map
                      ((forget C).mapIso
                            (colimit.isoColimitCocone
                                { cocone := colimitCocone F,
                                  isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                  (op U).unop)) ≫
            (Limits.colimit F).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base).op.obj
                      (op
                        ((Opens.map
                              ((forget C).mapIso
                                    (colimit.isoColimitCocone
                                        { cocone := colimitCocone F,
                                          isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                          (op U).unop)) =
                    (Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.inv.base).op.obj
                      (op
                        ((Opens.map
                              ((forget C).mapIso
                                    (colimit.isoColimitCocone
                                        { cocone := colimitCocone F,
                                          isColimit := colimitCoconeIsColimit F }).symm).symm.inv).obj
                          (op U).unop))))) ≫
          (Limits.colimit F).presheaf.map
            (eqToHom
              (_ :
                op
                    {
                      carrier :=
                        ↑((forget C).mapIso
                                  (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm).symm.hom ⁻¹'
                          ↑(op
                                {
                                  carrier :=
                                    ↑((forget C).mapIso
                                              (colimit.isoColimitCocone
                                                  { cocone := colimitCocone F,
                                                    isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                      ↑(op U).unop,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑((forget C).mapIso
                                                  (colimit.isoColimitCocone
                                                      { cocone := colimitCocone F,
                                                        isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                          ↑(op U).unop)) }).unop,
                      is_open' :=
                        (_ :
                          IsOpen
                            (↑((forget C).mapIso
                                      (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm).symm.hom ⁻¹'
                              ↑(op
                                    {
                                      carrier :=
                                        ↑((forget C).mapIso
                                                  (colimit.isoColimitCocone
                                                      { cocone := colimitCocone F,
                                                        isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                          ↑(op U).unop,
                                      is_open' :=
                                        (_ :
                                          IsOpen
                                            (↑((forget C).mapIso
                                                      (colimit.isoColimitCocone
                                                          { cocone := colimitCocone F,
                                                            isColimit := colimitCoconeIsColimit F }).symm).symm.inv ⁻¹'
                                              ↑(op U).unop)) }).unop)) } =
                  op U))) ≫
      NatTrans.app (colimit.ι F j).c (op U) =
    limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
dsimp
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
⊢ ((limMap
            (NatIso.ofComponents fun X =>
                (F.obj X.unop).presheaf.mapIso
                  (eqToIso
                    (_ :
                      (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                          ((Opens.map
                                  (colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                            (op U)) =
                        op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv ≫
          (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
              (op
                ((Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U))).inv) ≫
        (NatTrans.app
              (colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c
              (op
                ((Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                  U)) ≫
            (Limits.colimit F).presheaf.map
              (𝟙
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base).obj
                    ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U))))) ≫
          (Limits.colimit F).presheaf.map
            (eqToHom
              (_ :
                op
                    {
                      carrier :=
                        ↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          (↑(colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                            ↑U),
                      is_open' :=
                        (_ :
                          IsOpen
                            (↑(colimit.isoColimitCocone
                                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                              ↑{
                                  carrier :=
                                    ↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(colimit.isoColimitCocone
                                                  { cocone := colimitCocone F,
                                                    isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                          ↑U)) })) } =
                  op U))) ≫
      NatTrans.app (colimit.ι F j).c (op U) =
    limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
rw [map_id, comp_id, assoc, assoc, assoc, NatTrans.naturality]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
⊢ limMap
        (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                      ((Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                        (op U)) =
                    op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            (op
              ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U))).inv ≫
        NatTrans.app
            (colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.c
            (op
              ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U)) ≫
          NatTrans.app (colimit.ι F j).c
              (op
                ((Opens.map
                      (colimit.isoColimitCocone
                            { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base).obj
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U))) ≫
            ((colimit.ι F j).base _* (F.obj j).presheaf).map
              (eqToHom
                (_ :
                  op
                      {
                        carrier :=
                          ↑(colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                            (↑(colimit.isoColimitCocone
                                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                              ↑U),
                        is_open' :=
                          (_ :
                            IsOpen
                              (↑(colimit.isoColimitCocone
                                        { cocone := colimitCocone F,
                                          isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                                ↑{
                                    carrier :=
                                      ↑(colimit.isoColimitCocone
                                                { cocone := colimitCocone F,
                                                  isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                        ↑U,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(colimit.isoColimitCocone
                                                    { cocone := colimitCocone F,
                                                      isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                            ↑U)) })) } =
                    op U)) =
    limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
erw [← comp_c_app_assoc]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
⊢ limMap
        (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                      ((Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                        (op U)) =
                    op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            (op
              ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U))).inv ≫
        NatTrans.app
            (colimit.ι F j ≫
                (colimit.isoColimitCocone { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).c
            (op
              ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U)) ≫
          ((colimit.ι F j).base _* (F.obj j).presheaf).map
            (eqToHom
              (_ :
                op
                    {
                      carrier :=
                        ↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          (↑(colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                            ↑U),
                      is_open' :=
                        (_ :
                          IsOpen
                            (↑(colimit.isoColimitCocone
                                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                              ↑{
                                  carrier :=
                                    ↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(colimit.isoColimitCocone
                                                  { cocone := colimitCocone F,
                                                    isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                          ↑U)) })) } =
                  op U)) =
    limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
rw [congr_app (colimit.isoColimitCocone_ι_hom _ _), assoc]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
⊢ limMap
        (NatIso.ofComponents fun X =>
            (F.obj X.unop).presheaf.mapIso
              (eqToIso
                (_ :
                  (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                      ((Opens.map
                              (colimit.isoColimitCocone
                                      { cocone := colimitCocone F,
                                        isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                        (op U)) =
                    op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv ≫
      (limitObjIsoLimitCompEvaluation (pushforwardDiagramToColimit F).leftOp
            (op
              ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U))).inv ≫
        NatTrans.app (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι j).c
            (op
              ((Opens.map
                    (colimit.isoColimitCocone
                          { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                U)) ≫
          (F.obj j).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map
                            (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                                j).base).op.obj
                      (op
                        ((Opens.map
                              (colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                          U)) =
                    (Opens.map
                            (colimit.ι F j ≫
                                (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                      (op
                        ((Opens.map
                              (colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                          U)))) ≫
            ((colimit.ι F j).base _* (F.obj j).presheaf).map
              (eqToHom
                (_ :
                  op
                      {
                        carrier :=
                          ↑(colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                            (↑(colimit.isoColimitCocone
                                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                              ↑U),
                        is_open' :=
                          (_ :
                            IsOpen
                              (↑(colimit.isoColimitCocone
                                        { cocone := colimitCocone F,
                                          isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                                ↑{
                                    carrier :=
                                      ↑(colimit.isoColimitCocone
                                                { cocone := colimitCocone F,
                                                  isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                        ↑U,
                                    is_open' :=
                                      (_ :
                                        IsOpen
                                          (↑(colimit.isoColimitCocone
                                                    { cocone := colimitCocone F,
                                                      isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                            ↑U)) })) } =
                    op U)) =
    limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
erw [limitObjIsoLimitCompEvaluation_inv_π_app_assoc, limMap_π_assoc]
  -- Porting note : `convert` doesn't work due to meta variable, so change to a `suffices` block
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
⊢ limit.π (componentwiseDiagram F U) (op j) ≫
      NatTrans.app
          (NatIso.ofComponents fun X =>
              (F.obj X.unop).presheaf.mapIso
                (eqToIso
                  (_ :
                    (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                        ((Opens.map
                                (colimit.isoColimitCocone
                                        { cocone := colimitCocone F,
                                          isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                          (op U)) =
                      op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv
          (op j) ≫
        (F.obj j).presheaf.map
            (eqToHom
              (_ :
                (Opens.map
                          (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                              j).base).op.obj
                    (op
                      ((Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                        U)) =
                  (Opens.map
                          (colimit.ι F j ≫
                              (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                    (op
                      ((Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                        U)))) ≫
          ((colimit.ι F j).base _* (F.obj j).presheaf).map
            (eqToHom
              (_ :
                op
                    {
                      carrier :=
                        ↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          (↑(colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                            ↑U),
                      is_open' :=
                        (_ :
                          IsOpen
                            (↑(colimit.isoColimitCocone
                                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                              ↑{
                                  carrier :=
                                    ↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(colimit.isoColimitCocone
                                                  { cocone := colimitCocone F,
                                                    isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                          ↑U)) })) } =
                  op U)) =
    limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
set f := _
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
f : ?m.311389 := ?m.311390
⊢ limit.π (componentwiseDiagram F U) (op j) ≫
      NatTrans.app
          (NatIso.ofComponents fun X =>
              (F.obj X.unop).presheaf.mapIso
                (eqToIso
                  (_ :
                    (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                        ((Opens.map
                                (colimit.isoColimitCocone
                                        { cocone := colimitCocone F,
                                          isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                          (op U)) =
                      op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv
          (op j) ≫
        (F.obj j).presheaf.map
            (eqToHom
              (_ :
                (Opens.map
                          (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                              j).base).op.obj
                    (op
                      ((Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                        U)) =
                  (Opens.map
                          (colimit.ι F j ≫
                              (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                    (op
                      ((Opens.map
                            (colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                        U)))) ≫
          ((colimit.ι F j).base _* (F.obj j).presheaf).map
            (eqToHom
              (_ :
                op
                    {
                      carrier :=
                        ↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          (↑(colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                            ↑U),
                      is_open' :=
                        (_ :
                          IsOpen
                            (↑(colimit.isoColimitCocone
                                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                              ↑{
                                  carrier :=
                                    ↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(colimit.isoColimitCocone
                                                  { cocone := colimitCocone F,
                                                    isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                          ↑U)) })) } =
                  op U)) =
    limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
change _ ≫ f = _
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
f : (componentwiseDiagram F U).obj (op j) ⟶ (F.obj j).presheaf.obj (op ((Opens.map (colimit.ι F j).base).obj U)) :=
  NatTrans.app
      (NatIso.ofComponents fun X =>
          (F.obj X.unop).presheaf.mapIso
            (eqToIso
              (_ :
                (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                      (op U)) =
                  op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv
      (op j) ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Opens.map
                      (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                          j).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)) =
              (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)))) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            op
                {
                  carrier :=
                    ↑(colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      (↑(colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                        ↑U),
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ↑{
                              carrier :=
                                ↑(colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                  ↑U,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U)) })) } =
              op U))
⊢ limit.π (componentwiseDiagram F U) (op j) ≫ f = limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
suffices f_eq : f = 𝟙 _ by rw [f_eq, comp_id]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
f : (componentwiseDiagram F U).obj (op j) ⟶ (F.obj j).presheaf.obj (op ((Opens.map (colimit.ι F j).base).obj U)) :=
  NatTrans.app
      (NatIso.ofComponents fun X =>
          (F.obj X.unop).presheaf.mapIso
            (eqToIso
              (_ :
                (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                      (op U)) =
                  op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv
      (op j) ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Opens.map
                      (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                          j).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)) =
              (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)))) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            op
                {
                  carrier :=
                    ↑(colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      (↑(colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                        ↑U),
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ↑{
                              carrier :=
                                ↑(colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                  ↑U,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U)) })) } =
              op U))
f_eq : f = 𝟙 ((componentwiseDiagram F U).obj (op j))
⊢ limit.π (componentwiseDiagram F U) (op j) ≫ f = limit.π (componentwiseDiagram F U) (op j)
[PROOFSTEP]
rw [f_eq, comp_id]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
f : (componentwiseDiagram F U).obj (op j) ⟶ (F.obj j).presheaf.obj (op ((Opens.map (colimit.ι F j).base).obj U)) :=
  NatTrans.app
      (NatIso.ofComponents fun X =>
          (F.obj X.unop).presheaf.mapIso
            (eqToIso
              (_ :
                (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                      (op U)) =
                  op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv
      (op j) ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Opens.map
                      (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                          j).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)) =
              (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)))) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            op
                {
                  carrier :=
                    ↑(colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      (↑(colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                        ↑U),
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ↑{
                              carrier :=
                                ↑(colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                  ↑U,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U)) })) } =
              op U))
⊢ f = 𝟙 ((componentwiseDiagram F U).obj (op j))
[PROOFSTEP]
erw [← (F.obj j).presheaf.map_id]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
f : (componentwiseDiagram F U).obj (op j) ⟶ (F.obj j).presheaf.obj (op ((Opens.map (colimit.ι F j).base).obj U)) :=
  NatTrans.app
      (NatIso.ofComponents fun X =>
          (F.obj X.unop).presheaf.mapIso
            (eqToIso
              (_ :
                (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                      (op U)) =
                  op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv
      (op j) ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Opens.map
                      (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                          j).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)) =
              (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)))) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            op
                {
                  carrier :=
                    ↑(colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      (↑(colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                        ↑U),
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ↑{
                              carrier :=
                                ↑(colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                  ↑U,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U)) })) } =
              op U))
⊢ f = (F.obj j).presheaf.map (𝟙 (op ((Opens.map (colimit.ι F (op j).unop).base).obj U)))
[PROOFSTEP]
change (F.obj j).presheaf.map _ ≫ _ = _
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
f : (componentwiseDiagram F U).obj (op j) ⟶ (F.obj j).presheaf.obj (op ((Opens.map (colimit.ι F j).base).obj U)) :=
  NatTrans.app
      (NatIso.ofComponents fun X =>
          (F.obj X.unop).presheaf.mapIso
            (eqToIso
              (_ :
                (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                      (op U)) =
                  op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv
      (op j) ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Opens.map
                      (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                          j).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)) =
              (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)))) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            op
                {
                  carrier :=
                    ↑(colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      (↑(colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                        ↑U),
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ↑{
                              carrier :=
                                ↑(colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                  ↑U,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U)) })) } =
              op U))
⊢ (F.obj j).presheaf.map
        (eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) (op j).unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F (op j).unop).base).obj U))).inv ≫
      (F.obj j).presheaf.map
          (eqToHom
            (_ :
              (Opens.map
                        (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                            j).base).op.obj
                  (op
                    ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U)) =
                (Opens.map
                        (colimit.ι F j ≫
                            (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                  (op
                    ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U)))) ≫
        ((colimit.ι F j).base _* (F.obj j).presheaf).map
          (eqToHom
            (_ :
              op
                  {
                    carrier :=
                      ↑(colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                        (↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                          ↑U),
                    is_open' :=
                      (_ :
                        IsOpen
                          (↑(colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                            ↑{
                                carrier :=
                                  ↑(colimit.isoColimitCocone
                                            { cocone := colimitCocone F,
                                              isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                    ↑U,
                                is_open' :=
                                  (_ :
                                    IsOpen
                                      (↑(colimit.isoColimitCocone
                                                { cocone := colimitCocone F,
                                                  isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                        ↑U)) })) } =
                op U)) =
    (F.obj j).presheaf.map (𝟙 (op ((Opens.map (colimit.ι F (op j).unop).base).obj U)))
[PROOFSTEP]
erw [← (F.obj j).presheaf.map_comp, ← (F.obj j).presheaf.map_comp]
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
f : (componentwiseDiagram F U).obj (op j) ⟶ (F.obj j).presheaf.obj (op ((Opens.map (colimit.ι F j).base).obj U)) :=
  NatTrans.app
      (NatIso.ofComponents fun X =>
          (F.obj X.unop).presheaf.mapIso
            (eqToIso
              (_ :
                (Opens.map (colimit.ι (F ⋙ forget C) X.unop)).op.obj
                    ((Opens.map
                            (colimit.isoColimitCocone
                                    { cocone := colimitCocone F,
                                      isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                      (op U)) =
                  op ((Opens.map (colimit.ι F X.unop).base).obj U)))).inv
      (op j) ≫
    (F.obj j).presheaf.map
        (eqToHom
          (_ :
            (Opens.map
                      (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                          j).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)) =
              (Opens.map
                      (colimit.ι F j ≫
                          (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                (op
                  ((Opens.map
                        (colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                    U)))) ≫
      ((colimit.ι F j).base _* (F.obj j).presheaf).map
        (eqToHom
          (_ :
            op
                {
                  carrier :=
                    ↑(colimit.isoColimitCocone
                              { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                      (↑(colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                        ↑U),
                  is_open' :=
                    (_ :
                      IsOpen
                        (↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          ↑{
                              carrier :=
                                ↑(colimit.isoColimitCocone
                                          { cocone := colimitCocone F,
                                            isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                  ↑U,
                              is_open' :=
                                (_ :
                                  IsOpen
                                    (↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U)) })) } =
              op U))
⊢ (F.obj j).presheaf.map
      ((eqToIso
            (_ :
              (Opens.map (colimit.ι (F ⋙ forget C) (op j).unop)).op.obj
                  ((Opens.map
                          (colimit.isoColimitCocone
                                  { cocone := colimitCocone F,
                                    isColimit := colimitCoconeIsColimit F }).symm.hom.base).op.obj
                    (op U)) =
                op ((Opens.map (colimit.ι F (op j).unop).base).obj U))).inv ≫
        eqToHom
            (_ :
              (Opens.map
                        (NatTrans.app { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }.cocone.ι
                            j).base).op.obj
                  (op
                    ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U)) =
                (Opens.map
                        (colimit.ι F j ≫
                            (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom).base).op.obj
                  (op
                    ((Opens.map
                          (colimit.isoColimitCocone
                                { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base).obj
                      U))) ≫
          (Opens.map (colimit.ι F j).base).op.map
            (eqToHom
              (_ :
                op
                    {
                      carrier :=
                        ↑(colimit.isoColimitCocone
                                  { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                          (↑(colimit.isoColimitCocone
                                    { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                            ↑U),
                      is_open' :=
                        (_ :
                          IsOpen
                            (↑(colimit.isoColimitCocone
                                      { cocone := colimitCocone F, isColimit := colimitCoconeIsColimit F }).hom.base ⁻¹'
                              ↑{
                                  carrier :=
                                    ↑(colimit.isoColimitCocone
                                              { cocone := colimitCocone F,
                                                isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                      ↑U,
                                  is_open' :=
                                    (_ :
                                      IsOpen
                                        (↑(colimit.isoColimitCocone
                                                  { cocone := colimitCocone F,
                                                    isColimit := colimitCoconeIsColimit F }).inv.base ⁻¹'
                                          ↑U)) })) } =
                  op U))) =
    (F.obj j).presheaf.map (𝟙 (op ((Opens.map (colimit.ι F (op j).unop).base).obj U)))
[PROOFSTEP]
congr 1
[GOAL]
J : Type u'
inst✝⁴ : Category.{v', u'} J
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasColimitsOfShape J TopCat
inst✝¹ : ∀ (X : TopCat), HasLimitsOfShape Jᵒᵖ (Presheaf C X)
inst✝ : HasLimitsOfShape Jᵒᵖ C
F : J ⥤ PresheafedSpace C
U : Opens ↑↑(Limits.colimit F)
j : J
⊢ (colimitPresheafObjIsoComponentwiseLimit F U).hom ≫ limit.π (componentwiseDiagram F U) (op j) =
    NatTrans.app (colimit.ι F j).c (op U)
[PROOFSTEP]
rw [← Iso.eq_inv_comp, colimitPresheafObjIsoComponentwiseLimit_inv_ι_app]