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₂ ⊢
  rw [e₂, W.adjunction_counit_map_functor (U := V), ← IsIso.eq_inv_comp, IsIso.inv_comp_eq,
    ← IsIso.eq_comp_inv] at 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₁ :
  (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 V))).map
              (eqToHom
                (_ :
                  (Opens.map (Opens.inclusion V)).obj ((IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion V))).obj W) =
                    W))).op ≫
        inv
            (X.presheaf.map
              (eqToHom
                  (_ :
                    (Opens.map (Opens.inclusion V) ⋙ IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion V))).obj
                        ((IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion V))).obj W) =
                      (𝟭 (Opens ↑↑X.toPresheafedSpace)).obj
                        ((IsOpenMap.functor (_ : IsOpenMap ⇑(Opens.inclusion V))).obj W))).op) ≫
          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) ≫
      inv
        (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)
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:
simp_rw [eqToHom_map (Opens.map _), eqToHom_map (IsOpenMap.functor _), ← Functor.map_inv,
    ← Functor.map_comp] at e₁