theorem pullbackConeOfLeftLift_fst :
    pullbackConeOfLeftLift f g s ≫ (pullbackConeOfLeft f g).fst = s.fst := by
  -- Porting note : `ext` did not pick up `NatTrans.ext`
  refine PresheafedSpace.Hom.ext _ _ ?_ <| NatTrans.ext _ _ <| funext fun x => ?_
  · change pullback.lift _ _ _ ≫ pullback.fst = _
    simp
  · induction x using Opposite.rec' with | h x => ?_
    change ((_ ≫ _) ≫ _ ≫ _) ≫ _ = _
    simp_rw [Category.assoc]
    erw [← s.pt.presheaf.map_comp]
    erw [s.snd.c.naturality_assoc]
    have := congr_app s.condition (op (hf.openFunctor.obj x))
    dsimp only [comp_c_app, unop_op] at this
    rw [← IsIso.comp_inv_eq] at this
    replace this := reassoc_of% this
    erw [← this, hf.invApp_app_assoc, s.fst.c.naturality_assoc]
    

Proof state:
case refine_2.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
s : PullbackCone f g
x : Opens ↑↑X
this :
  ∀ {Z_1 : C} (h : ((PullbackCone.snd s ≫ g).base _* s.pt.presheaf).obj (op ((openFunctor hf).obj x)) ⟶ Z_1),
    f.c.app (op ((openFunctor hf).obj x)) ≫
        (PullbackCone.fst s).c.app (op ((Opens.map f.base).obj ((openFunctor hf).obj x))) ≫
          inv
              (s.pt.presheaf.map
                (eqToHom
                  (_ :
                    (Opens.map (PullbackCone.snd s ≫ g).base).op.obj (op ((openFunctor hf).obj x)) =
                      (Opens.map (PullbackCone.fst s ≫ f).base).op.obj (op ((openFunctor hf).obj x))))) ≫
            h =
      g.c.app (op ((openFunctor hf).obj x)) ≫
        (PullbackCone.snd s).c.app (op ((Opens.map g.base).obj ((openFunctor hf).obj x))) ≫ h
⊢ (PullbackCone.fst s).c.app (op (op x).unop) ≫
      ((PullbackCone.fst s).base _* s.pt.presheaf).map
          (eqToHom (_ : op (op x).unop = op ((Opens.map f.base).obj (op ((openFunctor hf).obj (op x).unop)).unop))) ≫
        inv
            (s.pt.presheaf.map
              (eqToHom
                (_ :
                  (Opens.map (PullbackCone.snd s ≫ g).base).op.obj (op ((openFunctor hf).obj x)) =
                    (Opens.map (PullbackCone.fst s ≫ f).base).op.obj (op ((openFunctor hf).obj x))))) ≫
          ((PullbackCone.snd s).base _* s.pt.presheaf).map
              (eqToHom
                (_ :
                  (Opens.map g.base).op.obj (op ((IsOpenMap.functor (_ : IsOpenMap ⇑f.base)).obj (op x).unop)) =
                    (IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                      ((Opens.map pullback.fst).op.obj (op x)))) ≫
            s.pt.presheaf.map
              (eqToHom
                  (_ :
                    (Opens.map (PullbackCone.snd s).base).op.obj
                        ((IsOpenMap.functor (_ : IsOpenMap ⇑pullback.snd)).op.obj
                          ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) =
                      (Opens.map
                              (pullback.lift (PullbackCone.fst s).base (PullbackCone.snd s).base
                                (_ : (PullbackCone.fst s ≫ f).base = (PullbackCone.snd s ≫ g).base))).op.obj
                        ((Opens.map (PullbackCone.fst (pullbackConeOfLeft f g)).base).op.obj (op x))) ≫
                (eqToHom
                      (_ :
                        (Opens.map (pullbackConeOfLeftLift f g s ≫ PullbackCone.fst (pullbackConeOfLeft f g)).base).op =
                          (Opens.map (PullbackCone.fst s).base).op)).app
                  (op x)) =
    (PullbackCone.fst s).c.app (op x)

Next tactic:
simp [eqToHom_map]