Theorem: RingHom.PropertyIsLocal.sourceAffineLocally_of_source_openCover
File: Mathlib/AlgebraicGeometry/Morphisms/RingHomProperties.lean

tactic: let S i := (⟨⟨Set.range (𝒰.map i).1.base, (𝒰.IsOpen i).base_open.isOpen_range⟩,
  isAffineOpen_opensRange (𝒰.map i)⟩ : X.affineOpens)
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
⊢ sourceAffineLocally P f
state_after: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
⊢ sourceAffineLocally P f

tactic: intro U
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
⊢ sourceAffineLocally P f
state_after: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

tactic: apply of_affine_open_cover
  (P := fun V => P (Scheme.Γ.map (X.ofRestrict (Opens.openEmbedding V.val) ≫ f).op)) S
  𝒰.iSup_opensRange
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
state_after: case basicOpen
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
⊢ ∀ (U : ↑X.affineOpens) (f_1 : ↑Γ(X, ↑U)),
    P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op) → P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

case openCover
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
⊢ ∀ (U : ↑X.affineOpens) (s : Finset ↑Γ(X, ↑U)),
    Ideal.span ↑s = ⊤ →
      (∀ (f_1 : { x // x ∈ s }), P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)) → P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

case hU
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
⊢ ∀ (i : 𝒰.J), P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

tactic: intro U r H
state_before: case basicOpen
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
⊢ ∀ (U : ↑X.affineOpens) (f_1 : ↑Γ(X, ↑U)),
    P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op) → P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
state_after: case basicOpen
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

tactic: convert hP.StableUnderComposition
  (S := Scheme.Γ.obj (Opposite.op (X.restrict <| Opens.openEmbedding U.val)))
  (T := Scheme.Γ.obj (Opposite.op (X.restrict <| Opens.openEmbedding (X.basicOpen r))))
  ?_ ?_ H ?_ using 1
state_before: case basicOpen
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
state_after: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op = ?basicOpen.convert_1.comp (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ ↑(Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }) →+* ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })

case basicOpen.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P ?basicOpen.convert_1

tactic: swap
state_before: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op = ?basicOpen.convert_1.comp (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ ↑(Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }) →+* ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })

case basicOpen.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P ?basicOpen.convert_1
state_after: case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ ↑(Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }) →+* ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })

case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op = ?basicOpen.convert_1.comp (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

case basicOpen.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P ?basicOpen.convert_1

tactic: convert @HoldsForLocalizationAway _ hP _
  (Scheme.Γ.obj (Opposite.op (X.restrict (X.basicOpen r).openEmbedding))) _ _ ?_
  (X.presheaf.map (eqToHom U.1.openEmbedding_obj_top).op r) ?_
state_before: case basicOpen.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P (X.presheaf.map (homOfLE ⋯).op)
state_after: case h.e'_5.h.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
e_1✝ : ↑(Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }) = ↑Γ(X, ⋯.functor.obj ⊤)
he✝ : (Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }).instCommRingα = Γ(X, ⋯.functor.obj ⊤).instCommRingα
⊢ X.presheaf.map (homOfLE ⋯).op = algebraMap ↑Γ(X, ⋯.functor.obj ⊤) ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })

case basicOpen.convert_2.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Algebra ↑Γ(X, ⋯.functor.obj ⊤) ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })

case basicOpen.convert_2.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ IsLocalization.Away ((X.presheaf.map (eqToHom ⋯).op) r) ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })

tactic: refine X.presheaf.map
    (@homOfLE _ _ ((IsOpenMap.functor _).obj _) ((IsOpenMap.functor _).obj _) ?_).op
state_before: case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ ↑(Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }) →+* ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })
state_after: case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ ⋯.functor.obj { unop := ⊤ }.unop ≤ ⋯.functor.obj { unop := ⊤ }.unop

tactic: dsimp
state_before: case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ ⋯.functor.obj { unop := ⊤ }.unop ≤ ⋯.functor.obj { unop := ⊤ }.unop
state_after: case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ ⋯.functor.obj ⊤ ≤ ⋯.functor.obj ⊤

tactic: rw [Opens.openEmbedding_obj_top, Opens.openEmbedding_obj_top]
state_before: case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ ⋯.functor.obj ⊤ ≤ ⋯.functor.obj ⊤
state_after: case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ X.basicOpen r ≤ ↑U

tactic: exact X.basicOpen_le _
state_before: case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ X.basicOpen r ≤ ↑U
state_after: no goals

tactic: rw [op_comp, op_comp, Functor.map_comp, Functor.map_comp]
state_before: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op = comp (X.presheaf.map (homOfLE ⋯).op) (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
state_after: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map f.op ≫ Scheme.Γ.map (X.ofRestrict ⋯).op =
    comp (X.presheaf.map (homOfLE ⋯).op) (Scheme.Γ.map f.op ≫ Scheme.Γ.map (X.ofRestrict ⋯).op)

tactic: refine (Eq.trans ?_ (Category.assoc (obj := CommRingCat) _ _ _).symm : _)
state_before: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map f.op ≫ Scheme.Γ.map (X.ofRestrict ⋯).op =
    comp (X.presheaf.map (homOfLE ⋯).op) (Scheme.Γ.map f.op ≫ Scheme.Γ.map (X.ofRestrict ⋯).op)
state_after: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map f.op ≫ Scheme.Γ.map (X.ofRestrict ⋯).op =
    Scheme.Γ.map f.op ≫ Scheme.Γ.map (X.ofRestrict ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op

tactic: congr 1
state_before: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map f.op ≫ Scheme.Γ.map (X.ofRestrict ⋯).op =
    Scheme.Γ.map f.op ≫ Scheme.Γ.map (X.ofRestrict ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op
state_after: case h.e'_5.e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map (X.ofRestrict ⋯).op = Scheme.Γ.map (X.ofRestrict ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op

tactic: dsimp
state_before: case h.e'_5.e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map (X.ofRestrict ⋯).op = Scheme.Γ.map (X.ofRestrict ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op
state_after: case h.e'_5.e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ X.presheaf.map (⋯.adjunction.counit.app ⊤).op =
    X.presheaf.map (⋯.adjunction.counit.app ⊤).op ≫ X.presheaf.map (homOfLE ⋯).op

tactic: refine Eq.trans ?_ (X.presheaf.map_comp _ _)
state_before: case h.e'_5.e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ X.presheaf.map (⋯.adjunction.counit.app ⊤).op =
    X.presheaf.map (⋯.adjunction.counit.app ⊤).op ≫ X.presheaf.map (homOfLE ⋯).op
state_after: case h.e'_5.e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ X.presheaf.map (⋯.adjunction.counit.app ⊤).op = X.presheaf.map ((⋯.adjunction.counit.app ⊤).op ≫ (homOfLE ⋯).op)

tactic: congr!
state_before: case h.e'_5.e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ X.presheaf.map (⋯.adjunction.counit.app ⊤).op = X.presheaf.map ((⋯.adjunction.counit.app ⊤).op ≫ (homOfLE ⋯).op)
state_after: no goals

tactic: exact RingHom.algebraMap_toAlgebra
  (R := Scheme.Γ.obj <| Opposite.op <| X.restrict (U.1.openEmbedding))
  (S :=
    Scheme.Γ.obj (Opposite.op <| X.restrict (X.affineBasicOpen r).1.openEmbedding)) _|>.symm
state_before: case h.e'_5.h.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
e_1✝ : ↑(Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }) = ↑Γ(X, ⋯.functor.obj ⊤)
he✝ : (Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }).instCommRingα = Γ(X, ⋯.functor.obj ⊤).instCommRingα
⊢ X.presheaf.map (homOfLE ⋯).op = algebraMap ↑Γ(X, ⋯.functor.obj ⊤) ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })
state_after: no goals

tactic: dsimp [Scheme.Γ]
state_before: case basicOpen.convert_2.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ IsLocalization.Away ((X.presheaf.map (eqToHom ⋯).op) r) ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })
state_after: case basicOpen.convert_2.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ IsLocalization.Away ((X.presheaf.map (eqToHom ⋯).op) r) ↑Γ(X, ⋯.functor.obj ⊤)

tactic: have := U.2
state_before: case basicOpen.convert_2.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ IsLocalization.Away ((X.presheaf.map (eqToHom ⋯).op) r) ↑Γ(X, ⋯.functor.obj ⊤)
state_after: case basicOpen.convert_2.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ↑U ∈ X.affineOpens
⊢ IsLocalization.Away ((X.presheaf.map (eqToHom ⋯).op) r) ↑Γ(X, ⋯.functor.obj ⊤)

tactic: rw [← U.1.openEmbedding_obj_top] at this
state_before: case basicOpen.convert_2.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ↑U ∈ X.affineOpens
⊢ IsLocalization.Away ((X.presheaf.map (eqToHom ⋯).op) r) ↑Γ(X, ⋯.functor.obj ⊤)
state_after: case basicOpen.convert_2.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
⊢ IsLocalization.Away ((X.presheaf.map (eqToHom ⋯).op) r) ↑Γ(X, ⋯.functor.obj ⊤)

tactic: convert (config := {typeEqs := true, transparency := .default})
    this.isLocalization_basicOpen _ using 5
state_before: case basicOpen.convert_2.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
⊢ IsLocalization.Away ((X.presheaf.map (eqToHom ⋯).op) r) ↑Γ(X, ⋯.functor.obj ⊤)
state_after: case h.e'_4.h.e'_2.h.e'_6.h.e'_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

case h.e'_5.e'_2.e'_1.h.e'_6.h.e'_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

case h.e'_6.e'_5.h.e'_7.h.e'_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

case h.e'_6.e'_5.h.e'_8.e'_3
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_7✝ : { unop := ⋯.functor.obj ⊤ } = { unop := X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r) }
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

tactic: all_goals rw [Opens.openEmbedding_obj_top]; exact (Scheme.basicOpen_res_eq _ _ _).symm
state_before: case h.e'_4.h.e'_2.h.e'_6.h.e'_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

case h.e'_5.e'_2.e'_1.h.e'_6.h.e'_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

case h.e'_6.e'_5.h.e'_7.h.e'_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

case h.e'_6.e'_5.h.e'_8.e'_3
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_7✝ : { unop := ⋯.functor.obj ⊤ } = { unop := X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r) }
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)
state_after: no goals

tactic: rw [Opens.openEmbedding_obj_top]
state_before: case h.e'_6.e'_5.h.e'_8.e'_3
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_7✝ : { unop := ⋯.functor.obj ⊤ } = { unop := X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r) }
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)
state_after: case h.e'_6.e'_5.h.e'_8.e'_3
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_7✝ : { unop := ⋯.functor.obj ⊤ } = { unop := X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r) }
⊢ X.basicOpen r = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

tactic: exact (Scheme.basicOpen_res_eq _ _ _).symm
state_before: case h.e'_6.e'_5.h.e'_8.e'_3
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_7✝ : { unop := ⋯.functor.obj ⊤ } = { unop := X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r) }
⊢ X.basicOpen r = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)
state_after: no goals

tactic: introv hs hs'
state_before: case openCover
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
⊢ ∀ (U : ↑X.affineOpens) (s : Finset ↑Γ(X, ↑U)),
    Ideal.span ↑s = ⊤ →
      (∀ (f_1 : { x // x ∈ s }), P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)) → P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
state_after: case openCover
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
s : Finset ↑Γ(X, ↑U)
hs : Ideal.span ↑s = ⊤
hs' : ∀ (f_1 : { x // x ∈ s }), P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

tactic: exact sourceAffineLocally_of_source_open_cover_aux hP.respectsIso hP.2 _ _ _ hs hs'
state_before: case openCover
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
s : Finset ↑Γ(X, ↑U)
hs : Ideal.span ↑s = ⊤
hs' : ∀ (f_1 : { x // x ∈ s }), P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
state_after: no goals

tactic: rintro i
state_before: case hU
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
⊢ ∀ (i : 𝒰.J), P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
state_after: case hU
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
i : 𝒰.J
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

tactic: specialize H i
state_before: case hU
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
i : 𝒰.J
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
state_after: case hU
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
i : 𝒰.J
H : P (Scheme.Γ.map (𝒰.map i ≫ f).op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

tactic: rw [← hP.respectsIso.cancel_right_isIso _
    (Scheme.Γ.map
      (IsOpenImmersion.isoOfRangeEq (𝒰.map i) (X.ofRestrict (S i).1.openEmbedding)
            Subtype.range_coe.symm).inv.op)] at H
state_before: case hU
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
i : 𝒰.J
H : P (Scheme.Γ.map (𝒰.map i ≫ f).op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
state_after: case hU
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
i : 𝒰.J
H : P (Scheme.Γ.map (𝒰.map i ≫ f).op ≫ Scheme.Γ.map (IsOpenImmersion.isoOfRangeEq (𝒰.map i) (X.ofRestrict ⋯) ⋯).inv.op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)

tactic: rwa [← Scheme.Γ.map_comp, ← op_comp, IsOpenImmersion.isoOfRangeEq_inv_fac_assoc] at H
state_before: case hU
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
i : 𝒰.J
H : P (Scheme.Γ.map (𝒰.map i ≫ f).op ≫ Scheme.Γ.map (IsOpenImmersion.isoOfRangeEq (𝒰.map i) (X.ofRestrict ⋯) ⋯).inv.op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
state_after: no goals