-- Mathlib/Geometry/RingedSpace/Stalks.lean
theorem stalkSpecializes_stalkMap {X Y : PresheafedSpace.{_, _, v} C}
    (f : X ⟶ Y) {x y : X} (h : x ⤳ y) :
    Y.presheaf.stalkSpecializes (f.base.hom.map_specializes h) ≫ f.stalkMap x =
      f.stalkMap y ≫ X.presheaf.stalkSpecializes h

Proof state:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
⊢ Y.presheaf.stalkSpecializes ⋯ ≫ Hom.stalkMap f x = Hom.stalkMap f y ≫ X.presheaf.stalkSpecializes h

Tactic:
dsimp [stalkSpecializes, Hom.stalkMap, stalkFunctor, stalkPushforward]

Result:
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
⊢ colimit.desc ((OpenNhds.inclusion ((TopCat.Hom.hom f.base) y)).op ⋙ Y.presheaf)
        { pt := colimit ((OpenNhds.inclusion ((TopCat.Hom.hom f.base) x)).op ⋙ Y.presheaf),
          ι :=
            {
              app := fun U =>
                colimit.ι ((OpenNhds.inclusion ((TopCat.Hom.hom f.base) x)).op ⋙ Y.presheaf)
                  (op { obj := (unop U).obj, property := ⋯ }),
              naturality := ⋯ } } ≫
      colimMap (whiskerLeft (OpenNhds.inclusion ((ConcreteCategory.hom f.base) x)).op f.c) ≫
        colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
          colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    (colimMap (whiskerLeft (OpenNhds.inclusion ((ConcreteCategory.hom f.base) y)).op f.c) ≫
        colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
          colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
      colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
        { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
          ι :=
            {
              app := fun U =>
                colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) (op { obj := (unop U).obj, property := ⋯ }),
              naturality := ⋯ } }

Proof state:
case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds ((TopCat.Hom.hom f.base) y)
⊢ colimit.ι ((OpenNhds.inclusion ((TopCat.Hom.hom f.base) y)).op ⋙ Y.presheaf) (op j) ≫
      colimit.desc ((OpenNhds.inclusion ((TopCat.Hom.hom f.base) y)).op ⋙ Y.presheaf)
          { pt := colimit ((OpenNhds.inclusion ((TopCat.Hom.hom f.base) x)).op ⋙ Y.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion ((TopCat.Hom.hom f.base) x)).op ⋙ Y.presheaf)
                    (op { obj := (unop U).obj, property := ⋯ }),
                naturality := ⋯ } } ≫
        colimMap (whiskerLeft (OpenNhds.inclusion ((ConcreteCategory.hom f.base) x)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion x).op ⋙ X.presheaf) (OpenNhds.map f.base x).op =
    colimit.ι ((OpenNhds.inclusion ((TopCat.Hom.hom f.base) y)).op ⋙ Y.presheaf) (op j) ≫
      (colimMap (whiskerLeft (OpenNhds.inclusion ((ConcreteCategory.hom f.base) y)).op f.c) ≫
          colimMap (whiskerRight (𝟙 (OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op) X.presheaf) ≫
            colimit.pre ((OpenNhds.inclusion y).op ⋙ X.presheaf) (OpenNhds.map f.base y).op) ≫
        colimit.desc ((OpenNhds.inclusion y).op ⋙ X.presheaf)
          { pt := colimit ((OpenNhds.inclusion x).op ⋙ X.presheaf),
            ι :=
              {
                app := fun U =>
                  colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf) (op { obj := (unop U).obj, property := ⋯ }),
                naturality := ⋯ } }

Tactic:
simp only [colimit.ι_desc_assoc, ι_colimMap_assoc, whiskerLeft_app,
  whiskerRight_app, NatTrans.id_app, map_id, colimit.ι_pre, id_comp, assoc,
  colimit.pre_desc, colimit.map_desc, colimit.ι_desc, Cocones.precompose_obj_ι,
  Cocone.whisker_ι, NatTrans.comp_app]

Result:
case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds ((TopCat.Hom.hom f.base) y)
⊢ f.c.app ((OpenNhds.inclusion ((ConcreteCategory.hom f.base) x)).op.obj (op { obj := j.obj, property := ⋯ })) ≫
      X.presheaf.map (𝟙 ((OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op.obj (op { obj := j.obj, property := ⋯ }))) ≫
        colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
          ((OpenNhds.map f.base x).op.obj (op { obj := j.obj, property := ⋯ })) =
    f.c.app ((OpenNhds.inclusion ((ConcreteCategory.hom f.base) y)).op.obj (op j)) ≫
      X.presheaf.map (𝟙 ((OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op.obj (op j))) ≫
        colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
          (op { obj := (unop ((OpenNhds.map f.base y).op.obj (op j))).obj, property := ⋯ })

Proof state:
case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds ((TopCat.Hom.hom f.base) y)
⊢ f.c.app ((OpenNhds.inclusion ((ConcreteCategory.hom f.base) x)).op.obj (op { obj := j.obj, property := ⋯ })) ≫
      X.presheaf.map (𝟙 ((OpenNhds.map f.base x ⋙ OpenNhds.inclusion x).op.obj (op { obj := j.obj, property := ⋯ }))) ≫
        colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
          ((OpenNhds.map f.base x).op.obj (op { obj := j.obj, property := ⋯ })) =
    f.c.app ((OpenNhds.inclusion ((ConcreteCategory.hom f.base) y)).op.obj (op j)) ≫
      X.presheaf.map (𝟙 ((OpenNhds.map f.base y ⋙ OpenNhds.inclusion y).op.obj (op j))) ≫
        colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
          (op { obj := (unop ((OpenNhds.map f.base y).op.obj (op j))).obj, property := ⋯ })

Tactic:
erw [X.presheaf.map_id, id_comp]

Result:
case h
C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
f : X ⟶ Y
x y : ↑↑X
h : x ⤳ y
j : OpenNhds ((TopCat.Hom.hom f.base) y)
⊢ f.c.app ((OpenNhds.inclusion ((ConcreteCategory.hom f.base) x)).op.obj (op { obj := j.obj, property := ⋯ })) ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        ((OpenNhds.map f.base x).op.obj (op { obj := j.obj, property := ⋯ })) =
    f.c.app ((OpenNhds.inclusion ((ConcreteCategory.hom f.base) y)).op.obj (op j)) ≫
      colimit.ι ((OpenNhds.inclusion x).op ⋙ X.presheaf)
        ((OpenNhds.map f.base x).op.obj (op { obj := j.obj, property := ⋯ }))