l3lab/ntp-mathlib huggingface dataset:
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.instHasColimits`.
-/
@[simps]
def colimitCocone (F : J ⥤ PresheafedSpace.{_, _, v} C) : Cocone F where
  pt := colimit F
  ι :=
    { app := fun j =>
        { base := colimit.ι (F ⋙ PresheafedSpace.forget C) j
          c := limit.π _ (op j) }
      naturality := fun {j j'} f => by
        ext1
        · ext x
          exact colimit.w_apply (F ⋙ PresheafedSpace.forget C) f x
        · ext ⟨U, hU⟩
          dsimp
          rw [PresheafedSpace.id_c_app, map_id]
          erw [id_comp]
          

Proof state:
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
⊢ ((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).app
      (op { carrier := U, is_open' := hU }) =
    (limit.π (pushforwardDiagramToColimit F).leftOp (op j)).app (op { carrier := U, is_open' := hU })

Next tactic:
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]
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.instHasColimits`.
-/
@[simps]
def colimitCocone (F : J ⥤ PresheafedSpace.{_, _, v} C) : Cocone F where
  pt := colimit F
  ι :=
    { app := fun j =>
        { base := colimit.ι (F ⋙ PresheafedSpace.forget C) j
          c := limit.π _ (op j) }
      naturality := fun {j j'} f => by
        ext1
        · ext x
          exact colimit.w_apply (F ⋙ PresheafedSpace.forget C) f x
        · ext ⟨U, hU⟩
          dsimp
          rw [PresheafedSpace.id_c_app, map_id]
          erw [id_comp]
          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]
          

Proof state:
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
⊢ ({ base := colimit.ι (F ⋙ forget C) j', c := limit.π (pushforwardDiagramToColimit F).leftOp (op j') }.c.app
          (op { carrier := U, is_open' := hU }) ≫
        (F.map f).c.app
          (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 }))) =
    (limit.π (pushforwardDiagramToColimit F).leftOp (op j')).app (op { carrier := U, is_open' := hU }) ≫
      (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.app
        (op { carrier := U, is_open' := hU })

Next tactic:
dsimp
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.instHasColimits`.
-/
@[simps]
def colimitCocone (F : J ⥤ PresheafedSpace.{_, _, v} C) : Cocone F where
  pt := colimit F
  ι :=
    { app := fun j =>
        { base := colimit.ι (F ⋙ PresheafedSpace.forget C) j
          c := limit.π _ (op j) }
      naturality := fun {j j'} f => by
        ext1
        · ext x
          exact colimit.w_apply (F ⋙ PresheafedSpace.forget C) f x
        · ext ⟨U, hU⟩
          dsimp
          rw [PresheafedSpace.id_c_app, map_id]
          erw [id_comp]
          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]
          dsimp
          

Proof state:
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
⊢ ((limit.π (pushforwardDiagramToColimit F).leftOp (op j')).app (op { carrier := U, is_open' := hU }) ≫
        (F.map f).c.app
          (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 }))) =
    (limit.π (pushforwardDiagramToColimit F).leftOp (op j')).app (op { carrier := U, is_open' := hU }) ≫
      (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).app
        (op { carrier := U, is_open' := hU })

Next tactic:
rw [NatTrans.comp_app, NatTrans.comp_app, pushforwardEq_hom_app, id.def, eqToHom_op,
            Pushforward.comp_inv_app, id_comp, pushforwardMap_app, ← assoc]
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.instHasColimits`.
-/
@[simps]
def colimitCocone (F : J ⥤ PresheafedSpace.{_, _, v} C) : Cocone F where
  pt := colimit F
  ι :=
    { app := fun j =>
        { base := colimit.ι (F ⋙ PresheafedSpace.forget C) j
          c := limit.π _ (op j) }
      naturality := fun {j j'} f => by
        ext1
        · ext x
          exact colimit.w_apply (F ⋙ PresheafedSpace.forget C) f x
        · ext ⟨U, hU⟩
          dsimp
          rw [PresheafedSpace.id_c_app, map_id]
          erw [id_comp]
          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]
          dsimp
          rw [NatTrans.comp_app, NatTrans.comp_app, pushforwardEq_hom_app, id.def, eqToHom_op,
            Pushforward.comp_inv_app, id_comp, pushforwardMap_app, ← assoc]
          

Proof state:
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
⊢ ((limit.π (pushforwardDiagramToColimit F).leftOp (op j')).app (op { carrier := U, is_open' := hU }) ≫
        (F.map f).c.app
          (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 }))) =
    ((limit.π (pushforwardDiagramToColimit F).leftOp (op j')).app (op { carrier := U, is_open' := hU }) ≫
        (F.map f).c.app ((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)))

Next tactic:
congr 1
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.colimitCoconeIsColimit`.
-/
def descCApp (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (U : (Opens s.pt.carrier)ᵒᵖ) :
    s.pt.presheaf.obj U ⟶
      (colimit.desc (F ⋙ PresheafedSpace.forget C) ((PresheafedSpace.forget C).mapCocone s) _*
            limit (pushforwardDiagramToColimit F).leftOp).obj
        U := by
  

Proof state:
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

Next tactic:
refine'
    limit.lift _
        { pt := s.pt.presheaf.obj U
          π :=
            { app := fun j => _
              naturality := fun j j' f => _ } } ≫
      (limitObjIsoLimitCompEvaluation _ _).inv
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.colimitCoconeIsColimit`.
-/
def descCApp (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (U : (Opens s.pt.carrier)ᵒᵖ) :
    s.pt.presheaf.obj U ⟶
      (colimit.desc (F ⋙ PresheafedSpace.forget C) ((PresheafedSpace.forget C).mapCocone s) _*
            limit (pushforwardDiagramToColimit F).leftOp).obj
        U := by
  refine'
    limit.lift _
        { pt := s.pt.presheaf.obj U
          π :=
            { app := fun j => _
              naturality := fun j j' f => _ } } ≫
      (limitObjIsoLimitCompEvaluation _ _).inv
  -- We still need to construct the `app` and `naturality'` fields omitted above.
  · 

Proof state:
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

Next tactic:
refine' (s.ι.app (unop j)).c.app U ≫ (F.obj (unop j)).presheaf.map (eqToHom _)
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.colimitCoconeIsColimit`.
-/
def descCApp (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (U : (Opens s.pt.carrier)ᵒᵖ) :
    s.pt.presheaf.obj U ⟶
      (colimit.desc (F ⋙ PresheafedSpace.forget C) ((PresheafedSpace.forget C).mapCocone s) _*
            limit (pushforwardDiagramToColimit F).leftOp).obj
        U := by
  refine'
    limit.lift _
        { pt := s.pt.presheaf.obj U
          π :=
            { app := fun j => _
              naturality := fun j j' f => _ } } ≫
      (limitObjIsoLimitCompEvaluation _ _).inv
  -- We still need to construct the `app` and `naturality'` fields omitted above.
  · refine' (s.ι.app (unop j)).c.app U ≫ (F.obj (unop j)).presheaf.map (eqToHom _)
    

Proof state:
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 (s.ι.app 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)

Next tactic:
dsimp
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.colimitCoconeIsColimit`.
-/
def descCApp (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (U : (Opens s.pt.carrier)ᵒᵖ) :
    s.pt.presheaf.obj U ⟶
      (colimit.desc (F ⋙ PresheafedSpace.forget C) ((PresheafedSpace.forget C).mapCocone s) _*
            limit (pushforwardDiagramToColimit F).leftOp).obj
        U := by
  refine'
    limit.lift _
        { pt := s.pt.presheaf.obj U
          π :=
            { app := fun j => _
              naturality := fun j j' f => _ } } ≫
      (limitObjIsoLimitCompEvaluation _ _).inv
  -- We still need to construct the `app` and `naturality'` fields omitted above.
  · refine' (s.ι.app (unop j)).c.app U ≫ (F.obj (unop j)).presheaf.map (eqToHom _)
    dsimp
    

Proof state:
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 (s.ι.app 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))

Next tactic:
rw [← Opens.map_comp_obj]
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.colimitCoconeIsColimit`.
-/
def descCApp (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (U : (Opens s.pt.carrier)ᵒᵖ) :
    s.pt.presheaf.obj U ⟶
      (colimit.desc (F ⋙ PresheafedSpace.forget C) ((PresheafedSpace.forget C).mapCocone s) _*
            limit (pushforwardDiagramToColimit F).leftOp).obj
        U := by
  refine'
    limit.lift _
        { pt := s.pt.presheaf.obj U
          π :=
            { app := fun j => _
              naturality := fun j j' f => _ } } ≫
      (limitObjIsoLimitCompEvaluation _ _).inv
  -- We still need to construct the `app` and `naturality'` fields omitted above.
  · refine' (s.ι.app (unop j)).c.app U ≫ (F.obj (unop j)).presheaf.map (eqToHom _)
    dsimp
    rw [← Opens.map_comp_obj]
    

Proof state:
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 (s.ι.app 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)

Next tactic:
simp
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.colimitCoconeIsColimit`.
-/
def descCApp (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (U : (Opens s.pt.carrier)ᵒᵖ) :
    s.pt.presheaf.obj U ⟶
      (colimit.desc (F ⋙ PresheafedSpace.forget C) ((PresheafedSpace.forget C).mapCocone s) _*
            limit (pushforwardDiagramToColimit F).leftOp).obj
        U := by
  refine'
    limit.lift _
        { pt := s.pt.presheaf.obj U
          π :=
            { app := fun j => _
              naturality := fun j j' f => _ } } ≫
      (limitObjIsoLimitCompEvaluation _ _).inv
  -- We still need to construct the `app` and `naturality'` fields omitted above.
  · refine' (s.ι.app (unop j)).c.app U ≫ (F.obj (unop j)).presheaf.map (eqToHom _)
    dsimp
    rw [← Opens.map_comp_obj]
    simp
  · 

Proof state:
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 =>
          (s.ι.app j.unop).c.app U ≫
            (F.obj j.unop).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map (s.ι.app 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 =>
          (s.ι.app j.unop).c.app U ≫
            (F.obj j.unop).presheaf.map
              (eqToHom
                (_ :
                  (Opens.map (s.ι.app 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

Next tactic:
dsimp
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.colimitCoconeIsColimit`.
-/
def descCApp (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (U : (Opens s.pt.carrier)ᵒᵖ) :
    s.pt.presheaf.obj U ⟶
      (colimit.desc (F ⋙ PresheafedSpace.forget C) ((PresheafedSpace.forget C).mapCocone s) _*
            limit (pushforwardDiagramToColimit F).leftOp).obj
        U := by
  refine'
    limit.lift _
        { pt := s.pt.presheaf.obj U
          π :=
            { app := fun j => _
              naturality := fun j j' f => _ } } ≫
      (limitObjIsoLimitCompEvaluation _ _).inv
  -- We still need to construct the `app` and `naturality'` fields omitted above.
  · refine' (s.ι.app (unop j)).c.app U ≫ (F.obj (unop j)).presheaf.map (eqToHom _)
    dsimp
    rw [← Opens.map_comp_obj]
    simp
  · dsimp
    

Proof state:
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) ≫
      (s.ι.app j'.unop).c.app U ≫
        (F.obj j'.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (s.ι.app 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)))) =
    ((s.ι.app j.unop).c.app U ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (s.ι.app 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.map f.unop).c.app
          (op
            ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        (Pushforward.comp (F.obj j'.unop).presheaf (F.map f.unop).base (colimit.ι (F ⋙ forget C) j.unop)).inv.app
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
          (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.app
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))

Next tactic:
rw [PresheafedSpace.congr_app (s.w f.unop).symm U]
/-- Auxiliary definition for `AlgebraicGeometry.PresheafedSpace.colimitCoconeIsColimit`.
-/
def descCApp (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F) (U : (Opens s.pt.carrier)ᵒᵖ) :
    s.pt.presheaf.obj U ⟶
      (colimit.desc (F ⋙ PresheafedSpace.forget C) ((PresheafedSpace.forget C).mapCocone s) _*
            limit (pushforwardDiagramToColimit F).leftOp).obj
        U := by
  refine'
    limit.lift _
        { pt := s.pt.presheaf.obj U
          π :=
            { app := fun j => _
              naturality := fun j j' f => _ } } ≫
      (limitObjIsoLimitCompEvaluation _ _).inv
  -- We still need to construct the `app` and `naturality'` fields omitted above.
  · refine' (s.ι.app (unop j)).c.app U ≫ (F.obj (unop j)).presheaf.map (eqToHom _)
    dsimp
    rw [← Opens.map_comp_obj]
    simp
  · dsimp
    rw [PresheafedSpace.congr_app (s.w f.unop).symm U]
    

Proof state:
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) ≫
      ((F.map f.unop ≫ s.ι.app j.unop).c.app U ≫
          (F.obj j'.unop).presheaf.map
            (eqToHom
              (_ :
                (Opens.map (F.map f.unop ≫ s.ι.app j.unop).base).op.obj U =
                  (Opens.map (s.ι.app j'.unop).base).op.obj U))) ≫
        (F.obj j'.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (s.ι.app 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)))) =
    ((s.ι.app j.unop).c.app U ≫
        (F.obj j.unop).presheaf.map
          (eqToHom
            (_ :
              op ((Opens.map (s.ι.app 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.map f.unop).c.app
          (op
            ((Opens.map (colimit.ι (F ⋙ forget C) j.unop)).obj
              ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))) ≫
        (Pushforward.comp (F.obj j'.unop).presheaf (F.map f.unop).base (colimit.ι (F ⋙ forget C) j.unop)).inv.app
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop)) ≫
          (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.app
            (op ((Opens.map (colimit.desc (F ⋙ forget C) ((forget C).mapCocone s))).obj U.unop))

Next tactic:
have w :=
      Functor.congr_obj
        (congr_arg Opens.map (colimit.ι_desc ((PresheafedSpace.forget C).mapCocone s) (unop j)))
        (unop U)
theorem desc_c_naturality (F : J ⥤ PresheafedSpace.{_, _, v} C) (s : Cocone F)
    {U V : (Opens s.pt.carrier)ᵒᵖ} (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 := by
  

Proof state:
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

Next tactic:
dsimp [descCApp]