Theorem: AlgebraicGeometry.targetAffineLocally_of_openCover
File: Mathlib/AlgebraicGeometry/Morphisms/Basic.lean

tactic: let S i : Y.affineOpens := ⟨_, isAffineOpen_opensRange (𝒰.map i)⟩
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
⊢ targetAffineLocally P f
state_after: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
⊢ targetAffineLocally P f

tactic: intro U
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
⊢ targetAffineLocally P f
state_after: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
⊢ P (f ∣_ ↑U)

tactic: haveI : IsAffine _ := U.2
state_before: case basicOpen
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
r : ↑Γ(Y, ↑U)
h : P (f ∣_ ↑U)
⊢ P (f ∣_ ↑(Y.affineBasicOpen r))
state_after: case basicOpen
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
r : ↑Γ(Y, ↑U)
h : P (f ∣_ ↑U)
this : IsAffine (Y.restrict ⋯)
⊢ P (f ∣_ ↑(Y.affineBasicOpen r))

tactic: have := hP.2 (f ∣_ U.1)
state_before: case basicOpen
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
r : ↑Γ(Y, ↑U)
h : P (f ∣_ ↑U)
this : IsAffine (Y.restrict ⋯)
⊢ P (f ∣_ ↑(Y.affineBasicOpen r))
state_after: case basicOpen
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
r : ↑Γ(Y, ↑U)
h : P (f ∣_ ↑U)
this✝ : IsAffine (Y.restrict ⋯)
this : ∀ (r : ↑Γ(Y ∣_ᵤ ↑U, ⊤)), P (f ∣_ ↑U) → P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen r)
⊢ P (f ∣_ ↑(Y.affineBasicOpen r))

tactic: replace this := this (Y.presheaf.map (eqToHom U.1.openEmbedding_obj_top).op r) h
state_before: case basicOpen
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
r : ↑Γ(Y, ↑U)
h : P (f ∣_ ↑U)
this✝ : IsAffine (Y.restrict ⋯)
this : ∀ (r : ↑Γ(Y ∣_ᵤ ↑U, ⊤)), P (f ∣_ ↑U) → P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen r)
⊢ P (f ∣_ ↑(Y.affineBasicOpen r))
state_after: case basicOpen
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
r : ↑Γ(Y, ↑U)
h : P (f ∣_ ↑U)
this✝ : IsAffine (Y.restrict ⋯)
this : P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ((Y.presheaf.map (eqToHom ⋯).op) r))
⊢ P (f ∣_ ↑(Y.affineBasicOpen r))

tactic: rw [← P.toProperty_apply] at this ⊢
state_before: case basicOpen
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
r : ↑Γ(Y, ↑U)
h : P (f ∣_ ↑U)
this✝ : IsAffine (Y.restrict ⋯)
this : P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ((Y.presheaf.map (eqToHom ⋯).op) r))
⊢ P (f ∣_ ↑(Y.affineBasicOpen r))
state_after: case basicOpen
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
r : ↑Γ(Y, ↑U)
h : P (f ∣_ ↑U)
this✝ : IsAffine (Y.restrict ⋯)
this : P.toProperty (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ((Y.presheaf.map (eqToHom ⋯).op) r))
⊢ P.toProperty (f ∣_ ↑(Y.affineBasicOpen r))

tactic: exact (hP.1.arrow_mk_iso_iff (morphismRestrictRestrictBasicOpen f _ r)).mp this
state_before: case basicOpen
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
r : ↑Γ(Y, ↑U)
h : P (f ∣_ ↑U)
this✝ : IsAffine (Y.restrict ⋯)
this : P.toProperty (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ((Y.presheaf.map (eqToHom ⋯).op) r))
⊢ P.toProperty (f ∣_ ↑(Y.affineBasicOpen r))
state_after: no goals

tactic: haveI : IsAffine _ := U.2
state_before: case openCover
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
⊢ P (f ∣_ ↑U)
state_after: case openCover
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
⊢ P (f ∣_ ↑U)

tactic: apply hP.3 (f ∣_ U.1) (s.image (Y.presheaf.map (eqToHom U.1.openEmbedding_obj_top).op))
state_before: case openCover
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
⊢ P (f ∣_ ↑U)
state_after: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
⊢ Ideal.span ↑(Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s) = ⊤

case openCover.a
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
⊢ ∀ (r : { x // x ∈ Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s }), P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ↑r)

tactic: apply_fun Ideal.comap (Y.presheaf.map (eqToHom U.1.openEmbedding_obj_top.symm).op) at hs
state_before: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
⊢ Ideal.span ↑(Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s) = ⊤
state_after: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) ⊤
⊢ Ideal.span ↑(Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s) = ⊤

tactic: rw [Ideal.comap_top] at hs
state_before: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) ⊤
⊢ Ideal.span ↑(Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s) = ⊤
state_after: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
⊢ Ideal.span ↑(Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s) = ⊤

tactic: rw [← hs]
state_before: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
⊢ Ideal.span ↑(Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s) = ⊤
state_after: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
⊢ Ideal.span ↑(Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s) =
    Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s)

tactic: simp only [eqToHom_op, eqToHom_map, Finset.coe_image]
state_before: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
⊢ Ideal.span ↑(Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s) =
    Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s)
state_after: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
⊢ Ideal.span (⇑(eqToHom ⋯) '' ↑s) = Ideal.comap (eqToHom ⋯) (Ideal.span ↑s)

tactic: have : ∀ {R S : CommRingCat} (e : S = R) (s : Set S),
    Ideal.span (eqToHom e '' s) = Ideal.comap (eqToHom e.symm) (Ideal.span s) := by
  intro _ S e _
  subst e
  simp only [eqToHom_refl, CommRingCat.id_apply, Set.image_id']
  exact (Ideal.comap_id _).symm
state_before: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
⊢ Ideal.span (⇑(eqToHom ⋯) '' ↑s) = Ideal.comap (eqToHom ⋯) (Ideal.span ↑s)
state_after: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this✝ : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
this :
  ∀ {R S : CommRingCat} (e : S = R) (s : Set ↑S),
    Ideal.span (⇑(eqToHom e) '' s) = Ideal.comap (eqToHom ⋯) (Ideal.span s)
⊢ Ideal.span (⇑(eqToHom ⋯) '' ↑s) = Ideal.comap (eqToHom ⋯) (Ideal.span ↑s)

tactic: apply this
state_before: case openCover.x
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this✝ : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
this :
  ∀ {R S : CommRingCat} (e : S = R) (s : Set ↑S),
    Ideal.span (⇑(eqToHom e) '' s) = Ideal.comap (eqToHom ⋯) (Ideal.span s)
⊢ Ideal.span (⇑(eqToHom ⋯) '' ↑s) = Ideal.comap (eqToHom ⋯) (Ideal.span ↑s)
state_after: no goals

tactic: intro _ S e _
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
⊢ ∀ {R S : CommRingCat} (e : S = R) (s : Set ↑S),
    Ideal.span (⇑(eqToHom e) '' s) = Ideal.comap (eqToHom ⋯) (Ideal.span s)
state_after: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S✝ : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
R✝ S : CommRingCat
e : S = R✝
s✝ : Set ↑S
⊢ Ideal.span (⇑(eqToHom e) '' s✝) = Ideal.comap (eqToHom ⋯) (Ideal.span s✝)

tactic: subst e
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S✝ : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
R✝ S : CommRingCat
e : S = R✝
s✝ : Set ↑S
⊢ Ideal.span (⇑(eqToHom e) '' s✝) = Ideal.comap (eqToHom ⋯) (Ideal.span s✝)
state_after: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S✝ : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
S : CommRingCat
s✝ : Set ↑S
⊢ Ideal.span (⇑(eqToHom ⋯) '' s✝) = Ideal.comap (eqToHom ⋯) (Ideal.span s✝)

tactic: simp only [eqToHom_refl, CommRingCat.id_apply, Set.image_id']
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S✝ : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
S : CommRingCat
s✝ : Set ↑S
⊢ Ideal.span (⇑(eqToHom ⋯) '' s✝) = Ideal.comap (eqToHom ⋯) (Ideal.span s✝)
state_after: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S✝ : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
S : CommRingCat
s✝ : Set ↑S
⊢ Ideal.span s✝ = Ideal.comap (𝟙 S) (Ideal.span s✝)

tactic: exact (Ideal.comap_id _).symm
state_before: P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S✝ : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
hs : Ideal.comap (Y.presheaf.map (eqToHom ⋯).op) (Ideal.span ↑s) = ⊤
S : CommRingCat
s✝ : Set ↑S
⊢ Ideal.span s✝ = Ideal.comap (𝟙 S) (Ideal.span s✝)
state_after: no goals

tactic: rintro ⟨r, hr⟩
state_before: case openCover.a
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
⊢ ∀ (r : { x // x ∈ Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s }), P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ↑r)
state_after: case openCover.a.mk
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
r : ↑Γ(Y ∣_ᵤ ↑U, ⊤)
hr : r ∈ Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s
⊢ P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ↑⟨r, hr⟩)

tactic: obtain ⟨r, hr', rfl⟩ := Finset.mem_image.mp hr
state_before: case openCover.a.mk
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
r : ↑Γ(Y ∣_ᵤ ↑U, ⊤)
hr : r ∈ Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s
⊢ P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ↑⟨r, hr⟩)
state_after: case openCover.a.mk.intro.intro
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
r : ↑Γ(Y, ↑U)
hr' : r ∈ s
hr : (Y.presheaf.map (eqToHom ⋯).op) r ∈ Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s
⊢ P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ↑⟨(Y.presheaf.map (eqToHom ⋯).op) r, hr⟩)

tactic: specialize H ⟨r, hr'⟩
state_before: case openCover.a.mk.intro.intro
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
H : ∀ (f_1 : { x // x ∈ s }), P (f ∣_ ↑(Y.affineBasicOpen ↑f_1))
this : IsAffine (Y.restrict ⋯)
r : ↑Γ(Y, ↑U)
hr' : r ∈ s
hr : (Y.presheaf.map (eqToHom ⋯).op) r ∈ Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s
⊢ P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ↑⟨(Y.presheaf.map (eqToHom ⋯).op) r, hr⟩)
state_after: case openCover.a.mk.intro.intro
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
this : IsAffine (Y.restrict ⋯)
r : ↑Γ(Y, ↑U)
hr' : r ∈ s
hr : (Y.presheaf.map (eqToHom ⋯).op) r ∈ Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s
H : P (f ∣_ ↑(Y.affineBasicOpen ↑⟨r, hr'⟩))
⊢ P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ↑⟨(Y.presheaf.map (eqToHom ⋯).op) r, hr⟩)

tactic: rw [← P.toProperty_apply] at H ⊢
state_before: case openCover.a.mk.intro.intro
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
this : IsAffine (Y.restrict ⋯)
r : ↑Γ(Y, ↑U)
hr' : r ∈ s
hr : (Y.presheaf.map (eqToHom ⋯).op) r ∈ Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s
H : P (f ∣_ ↑(Y.affineBasicOpen ↑⟨r, hr'⟩))
⊢ P (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ↑⟨(Y.presheaf.map (eqToHom ⋯).op) r, hr⟩)
state_after: case openCover.a.mk.intro.intro
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
this : IsAffine (Y.restrict ⋯)
r : ↑Γ(Y, ↑U)
hr' : r ∈ s
hr : (Y.presheaf.map (eqToHom ⋯).op) r ∈ Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s
H : P.toProperty (f ∣_ ↑(Y.affineBasicOpen ↑⟨r, hr'⟩))
⊢ P.toProperty (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ↑⟨(Y.presheaf.map (eqToHom ⋯).op) r, hr⟩)

tactic: exact (hP.1.arrow_mk_iso_iff (morphismRestrictRestrictBasicOpen f _ r)).mpr H
state_before: case openCover.a.mk.intro.intro
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
U : ↑Y.affineOpens
s : Finset ↑Γ(Y, ↑U)
hs : Ideal.span ↑s = ⊤
this : IsAffine (Y.restrict ⋯)
r : ↑Γ(Y, ↑U)
hr' : r ∈ s
hr : (Y.presheaf.map (eqToHom ⋯).op) r ∈ Finset.image (⇑(Y.presheaf.map (eqToHom ⋯).op)) s
H : P.toProperty (f ∣_ ↑(Y.affineBasicOpen ↑⟨r, hr'⟩))
⊢ P.toProperty (f ∣_ ↑U ∣_ (Y ∣_ᵤ ↑U).basicOpen ↑⟨(Y.presheaf.map (eqToHom ⋯).op) r, hr⟩)
state_after: no goals

tactic: specialize h𝒰 i
state_before: case hU
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
h𝒰 : ∀ (i : (𝒰.pullbackCover f).J), P pullback.snd
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
i : 𝒰.J
⊢ P (f ∣_ ↑(S i))
state_after: case hU
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
i : 𝒰.J
h𝒰 : P pullback.snd
⊢ P (f ∣_ ↑(S i))

tactic: rw [← P.toProperty_apply] at h𝒰 ⊢
state_before: case hU
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
i : 𝒰.J
h𝒰 : P pullback.snd
⊢ P (f ∣_ ↑(S i))
state_after: case hU
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
i : 𝒰.J
h𝒰 : P.toProperty pullback.snd
⊢ P.toProperty (f ∣_ ↑(S i))

tactic: exact (hP.1.arrow_mk_iso_iff (morphismRestrictOpensRange f _)).mpr h𝒰
state_before: case hU
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
𝒰 : Y.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
S : 𝒰.J → ↑Y.affineOpens := fun i => ⟨Scheme.Hom.opensRange (𝒰.map i), ⋯⟩
i : 𝒰.J
h𝒰 : P.toProperty pullback.snd
⊢ P.toProperty (f ∣_ ↑(S i))
state_after: no goals