theorem Scheme.restrictFunctor_map_app {U V : Opens X} (i : U ⟶ V) (W : Opens V) :
    (X.restrictFunctor.map i).1.1.c.app (op W) =
      X.presheaf.map (homOfLE <| X.restrictFunctor_map_app_aux i W).op := by
  have e₁ :=
    Scheme.congr_app (X.restrictFunctor_map_ofRestrict i)
      (op <| V.openEmbedding.isOpenMap.functor.obj W)
  rw [Scheme.comp_val_c_app] at e₁
  -- Porting note : `Opens.map_functor_eq` need more help
  have e₂ := (X.restrictFunctor.map i).1.val.c.naturality (eqToHom <| W.map_functor_eq (U := V)).op
  rw [← IsIso.eq_inv_comp] at e₂
  dsimp [restrict] at e₁ e₂ ⊢
  

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  X.presheaf.map
        ((IsOpenMap.adjunction (_ : IsOpenMap ⇑(Opens.inclusion V))).counit.app
            ((IsOpenMap.functor (_ : IsOpenMap Subtype.val)).obj W)).op ≫
      (IsOpenImmersion.lift (ιOpens V) (ιOpens U) (_ : Set.range Subtype.val ⊆ Set.range Subtype.val)).val.c.app
        (op ((Opens.map (Opens.inclusion V)).obj ((IsOpenMap.functor (_ : IsOpenMap Subtype.val)).obj W))) =
    X.presheaf.map
        ((IsOpenMap.adjunction (_ : IsOpenMap ⇑(Opens.inclusion U))).counit.app
            ((IsOpenMap.functor (_ : IsOpenMap Subtype.val)).obj W)).op ≫
      X.presheaf.map
        ((IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion U))).map
            (eqToHom
                (_ :
                  op ((Opens.map (ιOpens U).val.base).obj ((IsOpenMap.functor (_ : IsOpenMap Subtype.val)).obj W)) =
                    op
                      ((Opens.map
                            (IsOpenImmersion.lift (ιOpens V) (ιOpens U)
                                  (_ : Set.range Subtype.val ⊆ Set.range Subtype.val)).val.base).obj
                        ((Opens.map (Opens.inclusion V)).obj
                          ((IsOpenMap.functor (_ : IsOpenMap Subtype.val)).obj W))))).unop).op
e₂ :
  (IsOpenImmersion.lift (ιOpens V) (ιOpens U) (_ : Set.range Subtype.val ⊆ Set.range Subtype.val)).val.c.app
      (op ((Opens.map (Opens.inclusion V)).obj ((IsOpenMap.functor (_ : IsOpenMap Subtype.val)).obj W))) =
    inv
        (X.presheaf.map
          ((IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion V))).map
              (eqToHom
                (_ :
                  (Opens.map (Opens.inclusion V)).obj ((IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion V))).obj W) =
                    W))).op) ≫
      (IsOpenImmersion.lift (ιOpens V) (ιOpens U) (_ : Set.range Subtype.val ⊆ Set.range Subtype.val)).val.c.app
          (op W) ≫
        X.presheaf.map
          ((IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion U))).map
              ((Opens.map
                    (IsOpenImmersion.lift (ιOpens V) (ιOpens U)
                          (_ : Set.range Subtype.val ⊆ Set.range Subtype.val)).val.base).map
                (eqToHom
                  (_ :
                    (Opens.map (Opens.inclusion V)).obj
                        ((IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion V))).obj W) =
                      W)))).op
⊢ (IsOpenImmersion.lift (ιOpens V) (ιOpens U) (_ : Set.range Subtype.val ⊆ Set.range Subtype.val)).val.c.app (op W) =
    X.presheaf.map
      (homOfLE
          (_ :
            (IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion U))).obj (((restrictFunctor X).map i).left⁻¹ᵁ W) ≤
              (IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion V))).obj W)).op

Next tactic:
rw [e₂, W.adjunction_counit_map_functor (U := V), ← IsIso.eq_inv_comp, IsIso.inv_comp_eq,
    ← IsIso.eq_comp_inv] at e₁