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

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
⊢ 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✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (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₁ := Scheme.congr_app (X.restrictFunctor_map_ofRestrict i) (V.ι ''ᵁ W)
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (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✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op
tactic: have : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W := W.map_functor_eq (U := V)
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
⊢ 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✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToIso this).hom.op ≫
      Hom.app (X.restrictFunctor.map i).left (V.ι ⁻¹ᵁ V.ι ''ᵁ 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 (eqToIso this).hom.op.unop).op
⊢ Hom.app (X.restrictFunctor.map i).left W = X.presheaf.map (homOfLE ⋯).op
tactic: have e₂ := (X.restrictFunctor.map i).1.naturality (eqToIso this).hom.op
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToIso this).hom.op ≫
      Hom.app (X.restrictFunctor.map i).left (V.ι ⁻¹ᵁ V.ι ''ᵁ 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 (eqToIso this).hom.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✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToIso this).hom.op ≫
      Hom.app (X.restrictFunctor.map i).left (V.ι ⁻¹ᵁ V.ι ''ᵁ 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 (eqToIso this).hom.op.unop).op
e₃ :
  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 (eqToIso this).hom.op.unop).op =
    Hom.app U.ι (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₃ := e₂.symm.trans e₁
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToIso this).hom.op ≫
      Hom.app (X.restrictFunctor.map i).left (V.ι ⁻¹ᵁ V.ι ''ᵁ 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 (eqToIso this).hom.op.unop).op
e₃ :
  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 (eqToIso this).hom.op.unop).op =
    Hom.app U.ι (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✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToIso this).hom.op ≫
      Hom.app (X.restrictFunctor.map i).left (V.ι ⁻¹ᵁ V.ι ''ᵁ 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 (eqToIso this).hom.op.unop).op
e₃ :
  Hom.app (IsOpenImmersion.lift V.ι U.ι ⋯) W ≫
      X.presheaf.map
        ((Hom.opensFunctor U.ι).map ((Opens.map (IsOpenImmersion.lift V.ι U.ι ⋯).val.base).map (eqToHom this))).op =
    X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op
⊢ Hom.app (IsOpenImmersion.lift V.ι U.ι ⋯) W = X.presheaf.map (homOfLE ⋯).op
tactic: dsimp at e₃ ⊢
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToIso this).hom.op ≫
      Hom.app (X.restrictFunctor.map i).left (V.ι ⁻¹ᵁ V.ι ''ᵁ 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 (eqToIso this).hom.op.unop).op
e₃ :
  Hom.app (IsOpenImmersion.lift V.ι U.ι ⋯) W ≫
      X.presheaf.map
        ((Hom.opensFunctor U.ι).map ((Opens.map (IsOpenImmersion.lift V.ι U.ι ⋯).val.base).map (eqToHom this))).op =
    X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op
⊢ Hom.app (IsOpenImmersion.lift V.ι U.ι ⋯) W = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToIso this).hom.op ≫
      Hom.app (X.restrictFunctor.map i).left (V.ι ⁻¹ᵁ V.ι ''ᵁ 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 (eqToIso this).hom.op.unop).op
e₃ :
  Hom.app (IsOpenImmersion.lift V.ι U.ι ⋯) W =
    X.presheaf.map ((homOfLE ⋯).op ≫ ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op) ≫
      X.presheaf.map
        (inv ((Hom.opensFunctor U.ι).map ((Opens.map (IsOpenImmersion.lift V.ι U.ι ⋯).val.base).map (eqToHom this))).op)
⊢ Hom.app (IsOpenImmersion.lift V.ι U.ι ⋯) W = X.presheaf.map (homOfLE ⋯).op
tactic: rw [← IsIso.eq_comp_inv, ← Functor.map_inv, ← Functor.map_comp] at e₃
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToIso this).hom.op ≫
      Hom.app (X.restrictFunctor.map i).left (V.ι ⁻¹ᵁ V.ι ''ᵁ 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 (eqToIso this).hom.op.unop).op
e₃ :
  Hom.app (IsOpenImmersion.lift V.ι U.ι ⋯) W =
    X.presheaf.map ((homOfLE ⋯).op ≫ ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op) ≫
      X.presheaf.map
        (inv ((Hom.opensFunctor U.ι).map ((Opens.map (IsOpenImmersion.lift V.ι U.ι ⋯).val.base).map (eqToHom this))).op)
⊢ Hom.app (IsOpenImmersion.lift V.ι U.ι ⋯) W = X.presheaf.map (homOfLE ⋯).op
state_after: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToIso this).hom.op ≫
      Hom.app (X.restrictFunctor.map i).left (V.ι ⁻¹ᵁ V.ι ''ᵁ 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 (eqToIso this).hom.op.unop).op
e₃ :
  Hom.app (IsOpenImmersion.lift V.ι U.ι ⋯) W =
    X.presheaf.map ((homOfLE ⋯).op ≫ ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op) ≫
      X.presheaf.map
        (inv ((Hom.opensFunctor U.ι).map ((Opens.map (IsOpenImmersion.lift V.ι U.ι ⋯).val.base).map (eqToHom this))).op)
⊢ X.presheaf.map
      (((homOfLE ⋯).op ≫ ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op) ≫
        inv
          ((Hom.opensFunctor U.ι).map ((Opens.map (IsOpenImmersion.lift V.ι U.ι ⋯).val.base).map (eqToHom this))).op) =
    X.presheaf.map (homOfLE ⋯).op
tactic: rw [e₃, ← Functor.map_comp]
state_before: C : Type u₁
inst✝ : Category.{v, u₁} C
X : Scheme
U✝ U V : X.Opens
i : U ⟶ V
W : (↑V).Opens
e₁ :
  Hom.app ((X.restrictFunctor.map i).left ≫ V.ι) (V.ι ''ᵁ W) =
    Hom.app U.ι (V.ι ''ᵁ W) ≫ (X.restrictFunctor.obj U).left.presheaf.map (eqToHom ⋯).op
this : V.ι ⁻¹ᵁ V.ι ''ᵁ W = W
e₂ :
  (X.restrictFunctor.obj V).left.presheaf.map (eqToIso this).hom.op ≫
      Hom.app (X.restrictFunctor.map i).left (V.ι ⁻¹ᵁ V.ι ''ᵁ 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 (eqToIso this).hom.op.unop).op
e₃ :
  Hom.app (IsOpenImmersion.lift V.ι U.ι ⋯) W =
    X.presheaf.map ((homOfLE ⋯).op ≫ ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op) ≫
      X.presheaf.map
        (inv ((Hom.opensFunctor U.ι).map ((Opens.map (IsOpenImmersion.lift V.ι U.ι ⋯).val.base).map (eqToHom this))).op)
⊢ X.presheaf.map
      (((homOfLE ⋯).op ≫ ((Hom.opensFunctor U.ι).map (eqToHom ⋯)).op) ≫
        inv
          ((Hom.opensFunctor U.ι).map ((Opens.map (IsOpenImmersion.lift V.ι U.ι ⋯).val.base).map (eqToHom this))).op) =
    X.presheaf.map (homOfLE ⋯).op
state_after: no goals
tactic: congr 1