Theorem: RingHom.RespectsIso.basicOpen_iff
File: Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean

tactic: rw [Γ_map_morphismRestrict, hP.cancel_left_isIso, hP.cancel_right_isIso,
  ← hP.cancel_right_isIso (f.val.c.app (Opposite.op (Y.basicOpen r)))
    (X.presheaf.map (eqToHom (Scheme.preimage_basicOpen f r).symm).op), ← eq_iff_iff]
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
⊢ P (Scheme.Γ.map (f ∣_ Y.basicOpen r).op) ↔
    P
      (IsLocalization.Away.map (↑Γ(Y, Y.basicOpen r)) (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op)
        r)
state_after: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
⊢ P (f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom ⋯).op) =
    P
      (IsLocalization.Away.map (↑Γ(Y, Y.basicOpen r)) (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op)
        r)

tactic: congr
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
⊢ P (f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom ⋯).op) =
    P
      (IsLocalization.Away.map (↑Γ(Y, Y.basicOpen r)) (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op)
        r)
state_after: case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
⊢ f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom ⋯).op =
    IsLocalization.Away.map (↑Γ(Y, Y.basicOpen r)) (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op) r

tactic: delta IsLocalization.Away.map
state_before: case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
⊢ f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom ⋯).op =
    IsLocalization.Away.map (↑Γ(Y, Y.basicOpen r)) (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op) r
state_after: case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
⊢ f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom ⋯).op =
    IsLocalization.map (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op) ⋯

tactic: refine IsLocalization.ringHom_ext (Submonoid.powers r) ?_
state_before: case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
⊢ f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom ⋯).op =
    IsLocalization.map (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op) ⋯
state_after: case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
⊢ comp (f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom ⋯).op)
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r)) =
    (IsLocalization.map (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op) ⋯).comp
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r))

tactic: generalize_proofs
state_before: case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
⊢ comp (f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom ⋯).op)
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r)) =
    (IsLocalization.map (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op) ⋯).comp
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r))
state_after: case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
⊢ comp (f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom pf✝⁴).op)
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r)) =
    (IsLocalization.map (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op) pf✝).comp
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r))

tactic: haveI i1 := @isLocalization_away_of_isAffine X _ (Scheme.Γ.map f.op r)
state_before: case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
⊢ comp (f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom pf✝⁴).op)
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r)) =
    (IsLocalization.map (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op) pf✝).comp
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r))
state_after: case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
i1 : IsLocalization.Away ((Scheme.Γ.map f.op) r) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))
⊢ comp (f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom pf✝⁴).op)
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r)) =
    (IsLocalization.map (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op) pf✝).comp
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r))

tactic: convert
  (@IsLocalization.map_comp (hy := ‹_ ≤ _›) (Y.presheaf.obj <| Opposite.op (Scheme.basicOpen Y r))
  _ _ (isLocalization_away_of_isAffine _) _ _ _ i1).symm using 1
state_before: case e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
i1 : IsLocalization.Away ((Scheme.Γ.map f.op) r) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))
⊢ comp (f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom pf✝⁴).op)
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r)) =
    (IsLocalization.map (↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))) (Scheme.Γ.map f.op) pf✝).comp
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r))
state_after: case h.e'_2.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
i1 : IsLocalization.Away ((Scheme.Γ.map f.op) r) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))
e_1✝ :
  (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))) = (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r)))
⊢ comp (f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom pf✝⁴).op)
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r)) =
    (algebraMap ↑Γ(X, ⊤) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))).comp (Scheme.Γ.map f.op)

tactic: change Y.presheaf.map _ ≫ _ = _ ≫ X.presheaf.map _
state_before: case h.e'_2.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
i1 : IsLocalization.Away ((Scheme.Γ.map f.op) r) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))
e_1✝ :
  (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))) = (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r)))
⊢ comp (f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom pf✝⁴).op)
      (algebraMap ↑Γ(Y, ⊤) ↑Γ(Y, Y.basicOpen r)) =
    (algebraMap ↑Γ(X, ⊤) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))).comp (Scheme.Γ.map f.op)
state_after: case h.e'_2.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
i1 : IsLocalization.Away ((Scheme.Γ.map f.op) r) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))
e_1✝ :
  (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))) = (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r)))
⊢ Y.presheaf.map (homOfLE ⋯).op ≫ f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom pf✝⁴).op =
    Scheme.Γ.map f.op ≫ X.presheaf.map (homOfLE ⋯).op

tactic: rw [f.val.c.naturality_assoc]
state_before: case h.e'_2.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
i1 : IsLocalization.Away ((Scheme.Γ.map f.op) r) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))
e_1✝ :
  (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))) = (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r)))
⊢ Y.presheaf.map (homOfLE ⋯).op ≫ f.val.c.app { unop := Y.basicOpen r } ≫ X.presheaf.map (eqToHom pf✝⁴).op =
    Scheme.Γ.map f.op ≫ X.presheaf.map (homOfLE ⋯).op
state_after: case h.e'_2.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
i1 : IsLocalization.Away ((Scheme.Γ.map f.op) r) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))
e_1✝ :
  (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))) = (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r)))
⊢ f.val.c.app { unop := ⊤ } ≫ (f.val.base _* X.presheaf).map (homOfLE ⋯).op ≫ X.presheaf.map (eqToHom pf✝⁴).op =
    Scheme.Γ.map f.op ≫ X.presheaf.map (homOfLE ⋯).op

tactic: simp only [TopCat.Presheaf.pushforwardObj_map, ← X.presheaf.map_comp]
state_before: case h.e'_2.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
i1 : IsLocalization.Away ((Scheme.Γ.map f.op) r) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))
e_1✝ :
  (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))) = (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r)))
⊢ f.val.c.app { unop := ⊤ } ≫ (f.val.base _* X.presheaf).map (homOfLE ⋯).op ≫ X.presheaf.map (eqToHom pf✝⁴).op =
    Scheme.Γ.map f.op ≫ X.presheaf.map (homOfLE ⋯).op
state_after: case h.e'_2.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
i1 : IsLocalization.Away ((Scheme.Γ.map f.op) r) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))
e_1✝ :
  (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))) = (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r)))
⊢ f.val.c.app { unop := ⊤ } ≫ X.presheaf.map ((Opens.map f.val.base).op.map (homOfLE ⋯).op ≫ (eqToHom pf✝⁴).op) =
    Scheme.Γ.map f.op ≫ X.presheaf.map (homOfLE ⋯).op

tactic: congr 1
state_before: case h.e'_2.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : RespectsIso P
X Y : Scheme
inst✝¹ : IsAffine X
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑Γ(Y, ⊤)
pf✝⁴ : X.basicOpen ((Scheme.Hom.app f ⊤) r) = f ⁻¹ᵁ { unop := Y.basicOpen r }.unop
pf✝³ : IsLocalization (Submonoid.powers r) ↑Γ(Y, Y.basicOpen r)
pf✝² : IsLocalization (Submonoid.powers ((Scheme.Γ.map f.op) r)) ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))
pf✝¹ : MonoidHomClass (↑Γ(Y, ⊤) →+* ↑Γ(X, ⊤)) ↑Γ(Y, ⊤) ↑Γ(X, ⊤)
pf✝ : Submonoid.powers r ≤ Submonoid.comap (Scheme.Γ.map f.op) (Submonoid.powers ((Scheme.Γ.map f.op) r))
i1 : IsLocalization.Away ((Scheme.Γ.map f.op) r) ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r))
e_1✝ :
  (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Hom.app f ⊤) r))) = (↑Γ(Y, ⊤) →+* ↑Γ(X, X.basicOpen ((Scheme.Γ.map f.op) r)))
⊢ f.val.c.app { unop := ⊤ } ≫ X.presheaf.map ((Opens.map f.val.base).op.map (homOfLE ⋯).op ≫ (eqToHom pf✝⁴).op) =
    Scheme.Γ.map f.op ≫ X.presheaf.map (homOfLE ⋯).op
state_after: no goals