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

tactic: intro U
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
⊢ affineLocally P f
state_after: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
⊢ sourceAffineLocally P (f ∣_ ↑U)

tactic: haveI H : IsAffine _ := U.2
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
⊢ sourceAffineLocally P (f ∣_ ↑U)
state_after: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
⊢ sourceAffineLocally P (f ∣_ ↑U)

tactic: rw [← Category.comp_id (f ∣_ U)]
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
⊢ sourceAffineLocally P (f ∣_ ↑U)
state_after: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
⊢ sourceAffineLocally P (f ∣_ ↑U ≫ 𝟙 (Y ∣_ᵤ ↑U))

tactic: apply hP.sourceAffineLocally_comp_of_isOpenImmersion
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
⊢ sourceAffineLocally P (f ∣_ ↑U ≫ 𝟙 (Y ∣_ᵤ ↑U))
state_after: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
⊢ sourceAffineLocally P (𝟙 (Y ∣_ᵤ ↑U))

tactic: rw [@source_affine_openCover_iff _ hP _ _ _ _ (Scheme.openCoverOfIsIso (𝟙 _)) (_)]
state_before: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
⊢ sourceAffineLocally P (𝟙 (Y ∣_ᵤ ↑U))
state_after: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
⊢ ∀ (i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J),
    P (Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op)

P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
⊢ ∀ (i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J), IsAffine ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i)

tactic: intro i
state_before: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
⊢ ∀ (i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J),
    P (Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op)
state_after: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
⊢ P (Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op)

tactic: let esto := Scheme.Γ.obj (Opposite.op (Y.restrict <| Opens.openEmbedding U.val))
state_before: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
⊢ P (Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op)
state_after: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
⊢ P (Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op)

tactic: let eso := Scheme.Γ.obj (Opposite.op ((Scheme.openCoverOfIsIso
  (𝟙 (Y.restrict <| Opens.openEmbedding U.val))).obj i))
state_before: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
⊢ P (Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op)
state_after: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
eso : CommRingCat := Scheme.Γ.obj { unop := (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i }
⊢ P (Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op)

tactic: have := hP.HoldsForLocalizationAway
state_before: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
eso : CommRingCat := Scheme.Γ.obj { unop := (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i }
⊢ P (Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op)
state_after: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
eso : CommRingCat := Scheme.Γ.obj { unop := (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i }
this : RingHom.HoldsForLocalizationAway P
⊢ P (Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op)

tactic: convert @this esto eso _ _ ?_ 1 ?_
state_before: case H
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
eso : CommRingCat := Scheme.Γ.obj { unop := (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i }
this : RingHom.HoldsForLocalizationAway P
⊢ P (Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op)
state_after: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
eso : CommRingCat := Scheme.Γ.obj { unop := (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i }
this : RingHom.HoldsForLocalizationAway P
⊢ Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op = algebraMap ↑esto ↑eso

case H.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
eso : CommRingCat := Scheme.Γ.obj { unop := (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i }
this : RingHom.HoldsForLocalizationAway P
⊢ Algebra ↑esto ↑eso

case H.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
eso : CommRingCat := Scheme.Γ.obj { unop := (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i }
this : RingHom.HoldsForLocalizationAway P
⊢ IsLocalization.Away 1 ↑eso

tactic: exact (RingHom.algebraMap_toAlgebra (Scheme.Γ.map _)).symm
state_before: case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
eso : CommRingCat := Scheme.Γ.obj { unop := (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i }
this : RingHom.HoldsForLocalizationAway P
⊢ Scheme.Γ.map ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).map i ≫ 𝟙 (Y ∣_ᵤ ↑U)).op = algebraMap ↑esto ↑eso
state_after: no goals

tactic: exact
  @IsLocalization.away_of_isUnit_of_bijective _ _ _ _ (_) _ isUnit_one Function.bijective_id
state_before: case H.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
esto : CommRingCat := Scheme.Γ.obj { unop := Y ∣_ᵤ ↑U }
eso : CommRingCat := Scheme.Γ.obj { unop := (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i }
this : RingHom.HoldsForLocalizationAway P
⊢ IsLocalization.Away 1 ↑eso
state_after: no goals

tactic: intro
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
⊢ ∀ (i : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J), IsAffine ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i)
state_after: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i✝ : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
⊢ IsAffine ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i✝)

tactic: exact H
state_before: P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP✝ hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
U : ↑Y.affineOpens
H : IsAffine (Y.restrict ⋯)
i✝ : (Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).J
⊢ IsAffine ((Scheme.openCoverOfIsIso (𝟙 (Y ∣_ᵤ ↑U))).obj i✝)
state_after: no goals