Theorem: AlgebraicGeometry.reduce_to_affine_global
File: Mathlib/AlgebraicGeometry/Properties.lean

tactic: apply h₁
state_before: X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
⊢ P U
state_after: case a
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
⊢ ∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V

tactic: intro x
state_before: case a
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
⊢ ∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V
state_after: case a
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
⊢ ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V

tactic: obtain ⟨_, ⟨j, rfl⟩, hx, i⟩ :=
  X.affineBasisCover_is_basis.exists_subset_of_mem_open (SetLike.mem_coe.2 x.prop) U.isOpen
state_before: case a
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
⊢ ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V
state_after: case a.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
⊢ ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V

tactic: let U' : Opens _ := ⟨_, (X.affineBasisCover.IsOpen j).base_open.isOpen_range⟩
state_before: case a.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
⊢ ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V
state_after: case a.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
U' : Opens ↑↑X.toPresheafedSpace := { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
⊢ ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V

tactic: let i' : U' ⟶ U := homOfLE i
state_before: case a.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
U' : Opens ↑↑X.toPresheafedSpace := { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
⊢ ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V
state_after: case a.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
U' : Opens ↑↑X.toPresheafedSpace := { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
i' : U' ⟶ U := homOfLE i
⊢ ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V

tactic: refine ⟨U', hx, i', ?_⟩
state_before: case a.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
U' : Opens ↑↑X.toPresheafedSpace := { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
i' : U' ⟶ U := homOfLE i
⊢ ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V
state_after: case a.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
U' : Opens ↑↑X.toPresheafedSpace := { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
i' : U' ⟶ U := homOfLE i
⊢ P U'

tactic: obtain ⟨_, _, rfl, rfl, h₂'⟩ := h₂ _ _ (X.affineBasisCover.map j)
state_before: case a.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
U' : Opens ↑↑X.toPresheafedSpace := { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
i' : U' ⟶ U := homOfLE i
⊢ P U'
state_after: case a.intro.intro.intro.intro.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
U' : Opens ↑↑X.toPresheafedSpace := { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
i' : U' ⟶ U := homOfLE i
h₂' : P { carrier := ⊤, is_open' := ⋯ } → P { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
⊢ P U'

tactic: apply h₂'
state_before: case a.intro.intro.intro.intro.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
U' : Opens ↑↑X.toPresheafedSpace := { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
i' : U' ⟶ U := homOfLE i
h₂' : P { carrier := ⊤, is_open' := ⋯ } → P { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
⊢ P U'
state_after: case a.intro.intro.intro.intro.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
U' : Opens ↑↑X.toPresheafedSpace := { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
i' : U' ⟶ U := homOfLE i
h₂' : P { carrier := ⊤, is_open' := ⋯ } → P { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
⊢ P { carrier := ⊤, is_open' := ⋯ }

tactic: apply h₃
state_before: case a.intro.intro.intro.intro.intro.intro.intro.intro
X✝ : Scheme
P : {X : Scheme} → Opens ↑↑X.toPresheafedSpace → Prop
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : ↥U), ∃ V, ∃ (_ : ↑x ∈ V), ∃ x, P V) → P U
h₂ :
  ∀ (X Y : Scheme) (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V,
      ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
        P { carrier := U, is_open' := ⋯ } → P { carrier := V, is_open' := ⋯ }
h₃ : ∀ (R : CommRingCat), P ⊤
x : ↥U
j : X.affineBasisCover.J
hx : ↑x ∈ Set.range ⇑(X.affineBasisCover.map j).val.base
i : Set.range ⇑(X.affineBasisCover.map j).val.base ⊆ ↑U
U' : Opens ↑↑X.toPresheafedSpace := { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
i' : U' ⟶ U := homOfLE i
h₂' : P { carrier := ⊤, is_open' := ⋯ } → P { carrier := Set.range ⇑(X.affineBasisCover.map j).val.base, is_open' := ⋯ }
⊢ P { carrier := ⊤, is_open' := ⋯ }
state_after: no goals