l3lab/ntp-mathlib huggingface dataset:
/-- Given a diagram of `PresheafedSpace C`s, its colimit is computed by pushing the sheaves onto
the colimit of the underlying spaces, and taking componentwise limit.
This is the componentwise diagram for an open set `U` of the colimit of the underlying spaces.
-/
@[simps]
def componentwiseDiagram (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) : Jᵒᵖ ⥤ C where
  obj j := (F.obj (unop j)).presheaf.obj (op ((Opens.map (colimit.ι F (unop j)).base).obj U))
  map {j k} f := (F.map f.unop).c.app _ ≫
    (F.obj (unop k)).presheaf.map (eqToHom (by rw [← colimit.w F f.unop, comp_base]; rfl))
  map_comp {i j k} f g := by
    dsimp
    simp_rw [map_comp_c_app]
    simp only [op_obj, unop_op, eqToHom_op, id_eq, id_comp, assoc, eqToHom_trans]
    congr 1
    rw [TopCat.Presheaf.Pushforward.comp_inv_app, TopCat.Presheaf.pushforwardEq_hom_app,
      CategoryTheory.NatTrans.naturality_assoc, TopCat.Presheaf.pushforwardMap_app]
    congr 1
    simp
  map_id x := by
    dsimp
    

Proof state:
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.map (𝟙 x.unop)).c.app (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)))

Next tactic:
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']
/-- Given a diagram of `PresheafedSpace C`s, its colimit is computed by pushing the sheaves onto
the colimit of the underlying spaces, and taking componentwise limit.
This is the componentwise diagram for an open set `U` of the colimit of the underlying spaces.
-/
@[simps]
def componentwiseDiagram (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) : Jᵒᵖ ⥤ C where
  obj j := (F.obj (unop j)).presheaf.obj (op ((Opens.map (colimit.ι F (unop j)).base).obj U))
  map {j k} f := (F.map f.unop).c.app _ ≫
    (F.obj (unop k)).presheaf.map (eqToHom (by rw [← colimit.w F f.unop, comp_base]; rfl))
  map_comp {i j k} f g := by
    dsimp
    simp_rw [map_comp_c_app]
    simp only [op_obj, unop_op, eqToHom_op, id_eq, id_comp, assoc, eqToHom_trans]
    congr 1
    rw [TopCat.Presheaf.Pushforward.comp_inv_app, TopCat.Presheaf.pushforwardEq_hom_app,
      CategoryTheory.NatTrans.naturality_assoc, TopCat.Presheaf.pushforwardMap_app]
    congr 1
    simp
  map_id x := by
    dsimp
    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']
    

Proof state:
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ᵒᵖ
⊢ (Pushforward.id (F.obj x.unop).presheaf).inv.app (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)))

Next tactic:
rw [TopCat.Presheaf.Pushforward.id_inv_app']
/-- Given a diagram of `PresheafedSpace C`s, its colimit is computed by pushing the sheaves onto
the colimit of the underlying spaces, and taking componentwise limit.
This is the componentwise diagram for an open set `U` of the colimit of the underlying spaces.
-/
@[simps]
def componentwiseDiagram (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) : Jᵒᵖ ⥤ C where
  obj j := (F.obj (unop j)).presheaf.obj (op ((Opens.map (colimit.ι F (unop j)).base).obj U))
  map {j k} f := (F.map f.unop).c.app _ ≫
    (F.obj (unop k)).presheaf.map (eqToHom (by rw [← colimit.w F f.unop, comp_base]; rfl))
  map_comp {i j k} f g := by
    dsimp
    simp_rw [map_comp_c_app]
    simp only [op_obj, unop_op, eqToHom_op, id_eq, id_comp, assoc, eqToHom_trans]
    congr 1
    rw [TopCat.Presheaf.Pushforward.comp_inv_app, TopCat.Presheaf.pushforwardEq_hom_app,
      CategoryTheory.NatTrans.naturality_assoc, TopCat.Presheaf.pushforwardMap_app]
    congr 1
    simp
  map_id x := by
    dsimp
    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']
    rw [TopCat.Presheaf.Pushforward.id_inv_app']
    

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

Next tactic:
simp only [Opens.carrier_eq_coe, Opens.mk_coe, map_id]
/-- Given a diagram of `PresheafedSpace C`s, its colimit is computed by pushing the sheaves onto
the colimit of the underlying spaces, and taking componentwise limit.
This is the componentwise diagram for an open set `U` of the colimit of the underlying spaces.
-/
@[simps]
def componentwiseDiagram (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) : Jᵒᵖ ⥤ C where
  obj j := (F.obj (unop j)).presheaf.obj (op ((Opens.map (colimit.ι F (unop j)).base).obj U))
  map {j k} f := (F.map f.unop).c.app _ ≫
    (F.obj (unop k)).presheaf.map (eqToHom (by rw [← colimit.w F f.unop, comp_base]; rfl))
  map_comp {i j k} f g := by
    

Proof state:
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 =>
            (F.map f.unop).c.app (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 =>
              (F.map f.unop).c.app (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 =>
              (F.map f.unop).c.app (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

Next tactic:
dsimp
/-- Given a diagram of `PresheafedSpace C`s, its colimit is computed by pushing the sheaves onto
the colimit of the underlying spaces, and taking componentwise limit.
This is the componentwise diagram for an open set `U` of the colimit of the underlying spaces.
-/
@[simps]
def componentwiseDiagram (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) : Jᵒᵖ ⥤ C where
  obj j := (F.obj (unop j)).presheaf.obj (op ((Opens.map (colimit.ι F (unop j)).base).obj U))
  map {j k} f := (F.map f.unop).c.app _ ≫
    (F.obj (unop k)).presheaf.map (eqToHom (by rw [← colimit.w F f.unop, comp_base]; rfl))
  map_comp {i j k} f g := by
    dsimp
    

Proof state:
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 (g.unop ≫ f.unop)).c.app (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.map f.unop).c.app (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)))) ≫
      (F.map g.unop).c.app (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)))

Next tactic:
simp_rw [map_comp_c_app]
/-- Given a diagram of `PresheafedSpace C`s, its colimit is computed by pushing the sheaves onto
the colimit of the underlying spaces, and taking componentwise limit.
This is the componentwise diagram for an open set `U` of the colimit of the underlying spaces.
-/
@[simps]
def componentwiseDiagram (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) : Jᵒᵖ ⥤ C where
  obj j := (F.obj (unop j)).presheaf.obj (op ((Opens.map (colimit.ι F (unop j)).base).obj U))
  map {j k} f := (F.map f.unop).c.app _ ≫
    (F.obj (unop k)).presheaf.map (eqToHom (by rw [← colimit.w F f.unop, comp_base]; rfl))
  map_comp {i j k} f g := by
    dsimp
    simp_rw [map_comp_c_app]
    

Proof state:
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).c.app (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
        (pushforwardMap (F.map f.unop).base (F.map g.unop).c).app (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
          (Pushforward.comp (F.obj k.unop).presheaf (F.map g.unop).base (F.map f.unop).base).inv.app
              (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
            (pushforwardEq (_ : (F.map g.unop).base ≫ (F.map f.unop).base = (F.map (g.unop ≫ f.unop)).base)
                    (F.obj k.unop).presheaf).hom.app
              (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.map f.unop).c.app (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)))) ≫
      (F.map g.unop).c.app (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)))

Next tactic:
simp only [op_obj, unop_op, eqToHom_op, id_eq, id_comp, assoc, eqToHom_trans]
/-- Given a diagram of `PresheafedSpace C`s, its colimit is computed by pushing the sheaves onto
the colimit of the underlying spaces, and taking componentwise limit.
This is the componentwise diagram for an open set `U` of the colimit of the underlying spaces.
-/
@[simps]
def componentwiseDiagram (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) : Jᵒᵖ ⥤ C where
  obj j := (F.obj (unop j)).presheaf.obj (op ((Opens.map (colimit.ι F (unop j)).base).obj U))
  map {j k} f := (F.map f.unop).c.app _ ≫
    (F.obj (unop k)).presheaf.map (eqToHom (by rw [← colimit.w F f.unop, comp_base]; rfl))
  map_comp {i j k} f g := by
    dsimp
    simp_rw [map_comp_c_app]
    simp only [op_obj, unop_op, eqToHom_op, id_eq, id_comp, assoc, eqToHom_trans]
    

Proof state:
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).c.app (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
      (pushforwardMap (F.map f.unop).base (F.map g.unop).c).app (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
        (Pushforward.comp (F.obj k.unop).presheaf (F.map g.unop).base (F.map f.unop).base).inv.app
            (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
          (pushforwardEq (_ : (F.map g.unop).base ≫ (F.map f.unop).base = (F.map (g.unop ≫ f.unop)).base)
                    (F.obj k.unop).presheaf).hom.app
              (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.map f.unop).c.app (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))) ≫
        (F.map g.unop).c.app (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)))

Next tactic:
congr 1
/-- Given a diagram of `PresheafedSpace C`s, its colimit is computed by pushing the sheaves onto
the colimit of the underlying spaces, and taking componentwise limit.
This is the componentwise diagram for an open set `U` of the colimit of the underlying spaces.
-/
@[simps]
def componentwiseDiagram (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) : Jᵒᵖ ⥤ C where
  obj j := (F.obj (unop j)).presheaf.obj (op ((Opens.map (colimit.ι F (unop j)).base).obj U))
  map {j k} f := (F.map f.unop).c.app _ ≫
    (F.obj (unop k)).presheaf.map (eqToHom (by rw [← colimit.w F f.unop, comp_base]; rfl))
  map_comp {i j k} f g := by
    dsimp
    simp_rw [map_comp_c_app]
    simp only [op_obj, unop_op, eqToHom_op, id_eq, id_comp, assoc, eqToHom_trans]
    congr 1
    

Proof state:
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
⊢ (pushforwardMap (F.map f.unop).base (F.map g.unop).c).app (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
      (Pushforward.comp (F.obj k.unop).presheaf (F.map g.unop).base (F.map f.unop).base).inv.app
          (op ((Opens.map (colimit.ι F i.unop).base).obj U)) ≫
        (pushforwardEq (_ : (F.map g.unop).base ≫ (F.map f.unop).base = (F.map (g.unop ≫ f.unop)).base)
                  (F.obj k.unop).presheaf).hom.app
            (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))) ≫
      (F.map g.unop).c.app (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)))

Next tactic:
rw [TopCat.Presheaf.Pushforward.comp_inv_app, TopCat.Presheaf.pushforwardEq_hom_app,
      CategoryTheory.NatTrans.naturality_assoc, TopCat.Presheaf.pushforwardMap_app]
/-- Given a diagram of `PresheafedSpace C`s, its colimit is computed by pushing the sheaves onto
the colimit of the underlying spaces, and taking componentwise limit.
This is the componentwise diagram for an open set `U` of the colimit of the underlying spaces.
-/
@[simps]
def componentwiseDiagram (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) : Jᵒᵖ ⥤ C where
  obj j := (F.obj (unop j)).presheaf.obj (op ((Opens.map (colimit.ι F (unop j)).base).obj U))
  map {j k} f := (F.map f.unop).c.app _ ≫
    (F.obj (unop k)).presheaf.map (eqToHom (by rw [← colimit.w F f.unop, comp_base]; rfl))
  map_comp {i j k} f g := by
    dsimp
    simp_rw [map_comp_c_app]
    simp only [op_obj, unop_op, eqToHom_op, id_eq, id_comp, assoc, eqToHom_trans]
    congr 1
    rw [TopCat.Presheaf.Pushforward.comp_inv_app, TopCat.Presheaf.pushforwardEq_hom_app,
      CategoryTheory.NatTrans.naturality_assoc, TopCat.Presheaf.pushforwardMap_app]
    

Proof state:
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
⊢ (F.map g.unop).c.app ((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))) =
    (F.map g.unop).c.app (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)))

Next tactic:
congr 1
/-- Given a diagram of `PresheafedSpace C`s, its colimit is computed by pushing the sheaves onto
the colimit of the underlying spaces, and taking componentwise limit.
This is the componentwise diagram for an open set `U` of the colimit of the underlying spaces.
-/
@[simps]
def componentwiseDiagram (F : J ⥤ PresheafedSpace.{_, _, v} C) [HasColimit F]
    (U : Opens (Limits.colimit F).carrier) : Jᵒᵖ ⥤ C where
  obj j := (F.obj (unop j)).presheaf.obj (op ((Opens.map (colimit.ι F (unop j)).base).obj U))
  map {j k} f := (F.map f.unop).c.app _ ≫
    (F.obj (unop k)).presheaf.map (eqToHom (by rw [← colimit.w F f.unop, comp_base]; rfl))
  map_comp {i j k} f g := by
    dsimp
    simp_rw [map_comp_c_app]
    simp only [op_obj, unop_op, eqToHom_op, id_eq, id_comp, assoc, eqToHom_trans]
    congr 1
    rw [TopCat.Presheaf.Pushforward.comp_inv_app, TopCat.Presheaf.pushforwardEq_hom_app,
      CategoryTheory.NatTrans.naturality_assoc, TopCat.Presheaf.pushforwardMap_app]
    congr 1
    

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

Next tactic:
simp