Theorem: AlgebraicGeometry.Scheme.restrictFunctor_map_app
File: Mathlib/AlgebraicGeometry/Restrict.lean

tactic: have e₁ :=
  Scheme.congr_app (X.restrictFunctor_map_ofRestrict i) (ιOpens V ''ᵁ W)
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ ιOpens V) (ιOpens V ''ᵁ W) =
    Hom.app (ιOpens U) (ιOpens V ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op

tactic: rw [Scheme.comp_app] at e₁
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ ιOpens V) (ιOpens V ''ᵁ W) =
    Hom.app (ιOpens U) (ιOpens V ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  Hom.app (ιOpens V) (ιOpens V ''ᵁ W) ≫ Hom.app (X.restrictFunctor.map i).left (ιOpens V ⁻¹ᵁ ιOpens V ''ᵁ W) =
    Hom.app (ιOpens U) (ιOpens V ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op

tactic: have e₂ := (X.restrictFunctor.map i).1.naturality (eqToHom <| W.map_functor_eq (U := V)).op
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  Hom.app (ιOpens V) (ιOpens V ''ᵁ W) ≫ Hom.app (X.restrictFunctor.map i).left (ιOpens V ⁻¹ᵁ ιOpens V ''ᵁ W) =
    Hom.app (ιOpens U) (ιOpens V ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  Hom.app (ιOpens V) (ιOpens V ''ᵁ W) ≫ Hom.app (X.restrictFunctor.map i).left (ιOpens V ⁻¹ᵁ ιOpens V ''ᵁ W) =
    Hom.app (ιOpens U) (ιOpens V ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToHom ⋯).op ≫
      Hom.app (X.restrictFunctor.map i).left ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    Hom.app (X.restrictFunctor.map i).left W ≫
      (X.restrictFunctor.obj U).left.presheaf.map
        ((Opens.map (X.restrictFunctor.map i).left.val.base).map (eqToHom ⋯).op.unop).op
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op

tactic: rw [← IsIso.eq_inv_comp] at e₂
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  Hom.app (ιOpens V) (ιOpens V ''ᵁ W) ≫ Hom.app (X.restrictFunctor.map i).left (ιOpens V ⁻¹ᵁ ιOpens V ''ᵁ W) =
    Hom.app (ιOpens U) (ιOpens V ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToHom ⋯).op ≫
      Hom.app (X.restrictFunctor.map i).left ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    Hom.app (X.restrictFunctor.map i).left W ≫
      (X.restrictFunctor.obj U).left.presheaf.map
        ((Opens.map (X.restrictFunctor.map i).left.val.base).map (eqToHom ⋯).op.unop).op
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  Hom.app (ιOpens V) (ιOpens V ''ᵁ W) ≫ Hom.app (X.restrictFunctor.map i).left (ιOpens V ⁻¹ᵁ ιOpens V ''ᵁ W) =
    Hom.app (ιOpens U) (ιOpens V ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
e₂ :
  Hom.app (X.restrictFunctor.map i).left ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    inv ((X.restrictFunctor.obj V).left.presheaf.map (eqToHom ⋯).op) ≫
      Hom.app (X.restrictFunctor.map i).left W ≫
        (X.restrictFunctor.obj U).left.presheaf.map
          ((Opens.map (X.restrictFunctor.map i).left.val.base).map (eqToHom ⋯).op.unop).op
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op

tactic: dsimp [restrict] at e₁ e₂ ⊢
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  Hom.app (ιOpens V) (ιOpens V ''ᵁ W) ≫ Hom.app (X.restrictFunctor.map i).left (ιOpens V ⁻¹ᵁ ιOpens V ''ᵁ W) =
    Hom.app (ιOpens U) (ιOpens V ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
e₂ :
  Hom.app (X.restrictFunctor.map i).left ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    inv ((X.restrictFunctor.obj V).left.presheaf.map (eqToHom ⋯).op) ≫
      Hom.app (X.restrictFunctor.map i).left W ≫
        (X.restrictFunctor.obj U).left.presheaf.map
          ((Opens.map (X.restrictFunctor.map i).left.val.base).map (eqToHom ⋯).op.unop).op
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op
state_after: 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 (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫
      Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯)
        ((Opens.map V.inclusion).obj ((Hom.opensFunctor (ιOpens V)).obj W)) =
    X.presheaf.map (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫
      X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op
e₂ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    inv (X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op) ≫
      Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W ≫
        X.presheaf.map
          (⋯.functor.map ((Opens.map (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯).val.base).map (eqToHom ⋯))).op
⊢ Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W = X.presheaf.map (homOfLE ⋯).op

tactic: rw [e₂, W.adjunction_counit_map_functor (U := V), ← IsIso.eq_inv_comp, IsIso.inv_comp_eq,
  ← IsIso.eq_comp_inv] at e₁
state_before: 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 (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫
      Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯)
        ((Opens.map V.inclusion).obj ((Hom.opensFunctor (ιOpens V)).obj W)) =
    X.presheaf.map (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫
      X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op
e₂ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    inv (X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op) ≫
      Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W ≫
        X.presheaf.map
          (⋯.functor.map ((Opens.map (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯).val.base).map (eqToHom ⋯))).op
⊢ Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W =
    (X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op ≫
        inv (X.presheaf.map (eqToHom ⋯).op) ≫
          X.presheaf.map (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫
            X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op) ≫
      inv
        (X.presheaf.map
          (⋯.functor.map ((Opens.map (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯).val.base).map (eqToHom ⋯))).op)
e₂ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    inv (X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op) ≫
      Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W ≫
        X.presheaf.map
          (⋯.functor.map ((Opens.map (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯).val.base).map (eqToHom ⋯))).op
⊢ Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W = X.presheaf.map (homOfLE ⋯).op

tactic: simp_rw [eqToHom_map (Opens.map _), eqToHom_map (IsOpenMap.functor _), ← Functor.map_inv,
  ← Functor.map_comp] at e₁
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₁ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W =
    (X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op ≫
        inv (X.presheaf.map (eqToHom ⋯).op) ≫
          X.presheaf.map (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫
            X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op) ≫
      inv
        (X.presheaf.map
          (⋯.functor.map ((Opens.map (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯).val.base).map (eqToHom ⋯))).op)
e₂ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    inv (X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op) ≫
      Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W ≫
        X.presheaf.map
          (⋯.functor.map ((Opens.map (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯).val.base).map (eqToHom ⋯))).op
⊢ Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₂ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    inv (X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op) ≫
      Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W ≫
        X.presheaf.map
          (⋯.functor.map ((Opens.map (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯).val.base).map (eqToHom ⋯))).op
e₁ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W =
    X.presheaf.map
      (((eqToHom ⋯).op ≫
          inv (eqToHom ⋯).op ≫ (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫ (eqToHom ⋯).op) ≫
        inv (eqToHom ⋯).op)
⊢ Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W = X.presheaf.map (homOfLE ⋯).op

tactic: rw [e₁]
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₂ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    inv (X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op) ≫
      Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W ≫
        X.presheaf.map
          (⋯.functor.map ((Opens.map (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯).val.base).map (eqToHom ⋯))).op
e₁ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W =
    X.presheaf.map
      (((eqToHom ⋯).op ≫
          inv (eqToHom ⋯).op ≫ (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫ (eqToHom ⋯).op) ≫
        inv (eqToHom ⋯).op)
⊢ Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₂ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    inv (X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op) ≫
      Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W ≫
        X.presheaf.map
          (⋯.functor.map ((Opens.map (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯).val.base).map (eqToHom ⋯))).op
e₁ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W =
    X.presheaf.map
      (((eqToHom ⋯).op ≫
          inv (eqToHom ⋯).op ≫ (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫ (eqToHom ⋯).op) ≫
        inv (eqToHom ⋯).op)
⊢ X.presheaf.map
      (((eqToHom ⋯).op ≫
          inv (eqToHom ⋯).op ≫ (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫ (eqToHom ⋯).op) ≫
        inv (eqToHom ⋯).op) =
    X.presheaf.map (homOfLE ⋯).op

tactic: congr 1
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
W : Opens ↥V
e₂ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) ((Opens.map V.inclusion).obj (⋯.functor.obj W)) =
    inv (X.presheaf.map (⋯.functor.map (eqToHom ⋯)).op) ≫
      Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W ≫
        X.presheaf.map
          (⋯.functor.map ((Opens.map (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯).val.base).map (eqToHom ⋯))).op
e₁ :
  Hom.app (IsOpenImmersion.lift (ιOpens V) (ιOpens U) ⋯) W =
    X.presheaf.map
      (((eqToHom ⋯).op ≫
          inv (eqToHom ⋯).op ≫ (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫ (eqToHom ⋯).op) ≫
        inv (eqToHom ⋯).op)
⊢ X.presheaf.map
      (((eqToHom ⋯).op ≫
          inv (eqToHom ⋯).op ≫ (⋯.adjunction.counit.app ((Hom.opensFunctor (ιOpens V)).obj W)).op ≫ (eqToHom ⋯).op) ≫
        inv (eqToHom ⋯).op) =
    X.presheaf.map (homOfLE ⋯).op
state_after: no goals