[GOAL]
X : Scheme
⊢ T0Space ↑↑X.toPresheafedSpace
[PROOFSTEP]
refine' T0Space.of_open_cover fun x => _
[GOAL]
X : Scheme
x : ↑↑X.toPresheafedSpace
⊢ ∃ s, x ∈ s ∧ IsOpen s ∧ T0Space ↑s
[PROOFSTEP]
obtain ⟨U, R, ⟨e⟩⟩ := X.local_affine x
[GOAL]
case intro.intro.intro
X : Scheme
x : ↑↑X.toPresheafedSpace
U : OpenNhds x
R : CommRingCat
e :
  LocallyRingedSpace.restrict X.toLocallyRingedSpace (_ : OpenEmbedding ↑(Opens.inclusion U.obj)) ≅
    Spec.toLocallyRingedSpace.obj (op R)
⊢ ∃ s, x ∈ s ∧ IsOpen s ∧ T0Space ↑s
[PROOFSTEP]
let e' : U.1 ≃ₜ PrimeSpectrum R :=
  homeoOfIso ((LocallyRingedSpace.forgetToSheafedSpace ⋙ SheafedSpace.forget _).mapIso e)
[GOAL]
case intro.intro.intro
X : Scheme
x : ↑↑X.toPresheafedSpace
U : OpenNhds x
R : CommRingCat
e :
  LocallyRingedSpace.restrict X.toLocallyRingedSpace (_ : OpenEmbedding ↑(Opens.inclusion U.obj)) ≅
    Spec.toLocallyRingedSpace.obj (op R)
e' : { x_1 // x_1 ∈ U.obj } ≃ₜ PrimeSpectrum ↑R :=
  homeoOfIso ((LocallyRingedSpace.forgetToSheafedSpace ⋙ SheafedSpace.forget CommRingCat).mapIso e)
⊢ ∃ s, x ∈ s ∧ IsOpen s ∧ T0Space ↑s
[PROOFSTEP]
exact ⟨U.1.1, U.2, U.1.2, e'.embedding.t0Space⟩
[GOAL]
X : Scheme
⊢ QuasiSober ↑↑X.toPresheafedSpace
[PROOFSTEP]
apply (config := { allowSynthFailures := true })
  quasiSober_of_open_cover (Set.range fun x => Set.range <| (X.affineCover.map x).1.base)
[GOAL]
case hS
X : Scheme
⊢ ∀ (s : ↑(Set.range fun x => Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base)), IsOpen ↑s
[PROOFSTEP]
rintro ⟨_, i, rfl⟩
[GOAL]
case hS.mk.intro
X : Scheme
i : (Scheme.affineCover X).J
⊢ IsOpen
    ↑{ val := (fun x => Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base) i,
        property :=
          (_ :
            ∃ y,
              (fun x => Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base) y =
                (fun x => Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base) i) }
[PROOFSTEP]
exact (X.affineCover.IsOpen i).base_open.open_range
[GOAL]
case hS'
X : Scheme
⊢ ∀ (s : ↑(Set.range fun x => Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base)), QuasiSober ↑↑s
[PROOFSTEP]
rintro ⟨_, i, rfl⟩
[GOAL]
case hS'.mk.intro
X : Scheme
i : (Scheme.affineCover X).J
⊢ QuasiSober
    ↑↑{ val := (fun x => Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base) i,
          property :=
            (_ :
              ∃ y,
                (fun x => Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base) y =
                  (fun x => Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base) i) }
[PROOFSTEP]
exact
  @OpenEmbedding.quasiSober _ _ _ _ _
    (Homeomorph.ofEmbedding _ (X.affineCover.IsOpen i).base_open.toEmbedding).symm.openEmbedding
    PrimeSpectrum.quasiSober
[GOAL]
case hS''
X : Scheme
⊢ (⋃₀ Set.range fun x => Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base) = ⊤
[PROOFSTEP]
rw [Set.top_eq_univ, Set.sUnion_range, Set.eq_univ_iff_forall]
[GOAL]
case hS''
X : Scheme
⊢ ∀ (x : (forget TopCat).obj ↑X.toPresheafedSpace),
    x ∈ ⋃ (x : (Scheme.affineCover X).J), Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base
[PROOFSTEP]
intro x
[GOAL]
case hS''
X : Scheme
x : (forget TopCat).obj ↑X.toPresheafedSpace
⊢ x ∈ ⋃ (x : (Scheme.affineCover X).J), Set.range ↑(Scheme.OpenCover.map (Scheme.affineCover X) x).val.base
[PROOFSTEP]
exact ⟨_, ⟨_, rfl⟩, X.affineCover.Covers x⟩
[GOAL]
X : Scheme
inst✝ : ∀ (x : ↑↑X.toPresheafedSpace), _root_.IsReduced ↑(Presheaf.stalk X.presheaf x)
⊢ IsReduced X
[PROOFSTEP]
refine' ⟨fun U => ⟨fun s hs => _⟩⟩
[GOAL]
X : Scheme
inst✝ : ∀ (x : ↑↑X.toPresheafedSpace), _root_.IsReduced ↑(Presheaf.stalk X.presheaf x)
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : IsNilpotent s
⊢ s = 0
[PROOFSTEP]
apply Presheaf.section_ext X.sheaf U s 0
[GOAL]
X : Scheme
inst✝ : ∀ (x : ↑↑X.toPresheafedSpace), _root_.IsReduced ↑(Presheaf.stalk X.presheaf x)
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : IsNilpotent s
⊢ ∀ (x : { x // x ∈ U }),
    ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) 0
[PROOFSTEP]
intro x
[GOAL]
X : Scheme
inst✝ : ∀ (x : ↑↑X.toPresheafedSpace), _root_.IsReduced ↑(Presheaf.stalk X.presheaf x)
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : IsNilpotent s
x : { x // x ∈ U }
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) 0
[PROOFSTEP]
rw [RingHom.map_zero]
[GOAL]
X : Scheme
inst✝ : ∀ (x : ↑↑X.toPresheafedSpace), _root_.IsReduced ↑(Presheaf.stalk X.presheaf x)
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : IsNilpotent s
x : { x // x ∈ U }
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
[PROOFSTEP]
change X.presheaf.germ x s = 0
[GOAL]
X : Scheme
inst✝ : ∀ (x : ↑↑X.toPresheafedSpace), _root_.IsReduced ↑(Presheaf.stalk X.presheaf x)
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : IsNilpotent s
x : { x // x ∈ U }
⊢ ↑(Presheaf.germ X.presheaf x) s = 0
[PROOFSTEP]
exact (hs.map _).eq_zero
[GOAL]
X : Scheme
inst✝ : IsReduced X
x : ↑↑X.toPresheafedSpace
⊢ _root_.IsReduced ↑(Presheaf.stalk X.presheaf x)
[PROOFSTEP]
constructor
[GOAL]
case eq_zero
X : Scheme
inst✝ : IsReduced X
x : ↑↑X.toPresheafedSpace
⊢ ∀ (x_1 : ↑(Presheaf.stalk X.presheaf x)), IsNilpotent x_1 → x_1 = 0
[PROOFSTEP]
rintro g ⟨n, e⟩
[GOAL]
case eq_zero.intro
X : Scheme
inst✝ : IsReduced X
x : ↑↑X.toPresheafedSpace
g : ↑(Presheaf.stalk X.presheaf x)
n : ℕ
e : g ^ n = 0
⊢ g = 0
[PROOFSTEP]
obtain ⟨U, hxU, s, rfl⟩ := X.presheaf.germ_exist x g
[GOAL]
case eq_zero.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
x : ↑↑X.toPresheafedSpace
n : ℕ
U : Opens ↑↑X.toPresheafedSpace
hxU : x ∈ U
s : (forget CommRingCat).obj (X.presheaf.obj (op U))
e : ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) s ^ n = 0
⊢ ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) s = 0
[PROOFSTEP]
rw [← map_pow, ← map_zero (X.presheaf.germ ⟨x, hxU⟩)] at e
[GOAL]
case eq_zero.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
x : ↑↑X.toPresheafedSpace
n : ℕ
U : Opens ↑↑X.toPresheafedSpace
hxU : x ∈ U
s : (forget CommRingCat).obj (X.presheaf.obj (op U))
e :
  ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) (s ^ n) =
    ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) 0
⊢ ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) s = 0
[PROOFSTEP]
obtain ⟨V, hxV, iU, iV, e'⟩ := X.presheaf.germ_eq x hxU hxU _ 0 e
[GOAL]
case eq_zero.intro.intro.intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
x : ↑↑X.toPresheafedSpace
n : ℕ
U : Opens ↑↑X.toPresheafedSpace
hxU : x ∈ U
s : (forget CommRingCat).obj (X.presheaf.obj (op U))
e :
  ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) (s ^ n) =
    ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) 0
V : Opens ↑↑X.toPresheafedSpace
hxV : x ∈ V
iU iV : V ⟶ U
e' : ↑(X.presheaf.map iU.op) (s ^ n) = ↑(X.presheaf.map iV.op) 0
⊢ ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) s = 0
[PROOFSTEP]
rw [map_pow, map_zero] at e'
[GOAL]
case eq_zero.intro.intro.intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
x : ↑↑X.toPresheafedSpace
n : ℕ
U : Opens ↑↑X.toPresheafedSpace
hxU : x ∈ U
s : (forget CommRingCat).obj (X.presheaf.obj (op U))
e :
  ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) (s ^ n) =
    ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) 0
V : Opens ↑↑X.toPresheafedSpace
hxV : x ∈ V
iU iV : V ⟶ U
e' : ↑(X.presheaf.map iU.op) s ^ n = 0
⊢ ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) s = 0
[PROOFSTEP]
replace e' := (IsNilpotent.mk _ _ e').eq_zero (R := X.presheaf.obj <| op V)
[GOAL]
case eq_zero.intro.intro.intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
x : ↑↑X.toPresheafedSpace
n : ℕ
U : Opens ↑↑X.toPresheafedSpace
hxU : x ∈ U
s : (forget CommRingCat).obj (X.presheaf.obj (op U))
e :
  ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) (s ^ n) =
    ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) 0
V : Opens ↑↑X.toPresheafedSpace
hxV : x ∈ V
iU iV : V ⟶ U
e' : ↑(X.presheaf.map iU.op) s = 0
⊢ ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) s = 0
[PROOFSTEP]
erw [← ConcreteCategory.congr_hom (X.presheaf.germ_res iU ⟨x, hxV⟩) s]
[GOAL]
case eq_zero.intro.intro.intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
x : ↑↑X.toPresheafedSpace
n : ℕ
U : Opens ↑↑X.toPresheafedSpace
hxU : x ∈ U
s : (forget CommRingCat).obj (X.presheaf.obj (op U))
e :
  ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) (s ^ n) =
    ↑(Presheaf.germ X.presheaf { val := x, property := hxU }) 0
V : Opens ↑↑X.toPresheafedSpace
hxV : x ∈ V
iU iV : V ⟶ U
e' : ↑(X.presheaf.map iU.op) s = 0
⊢ ↑(X.presheaf.map iU.op ≫ Presheaf.germ X.presheaf { val := x, property := hxV }) s = 0
[PROOFSTEP]
rw [comp_apply, e', map_zero]
[GOAL]
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝ : IsReduced Y
⊢ IsReduced X
[PROOFSTEP]
constructor
[GOAL]
case component_reduced
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝ : IsReduced Y
⊢ autoParam (∀ (U : Opens ↑↑X.toPresheafedSpace), _root_.IsReduced ↑(X.presheaf.obj (op U))) _auto✝
[PROOFSTEP]
intro U
[GOAL]
case component_reduced
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝ : IsReduced Y
U : Opens ↑↑X.toPresheafedSpace
⊢ _root_.IsReduced ↑(X.presheaf.obj (op U))
[PROOFSTEP]
have : U = (Opens.map f.1.base).obj (H.base_open.isOpenMap.functor.obj U) := by ext1;
  exact (Set.preimage_image_eq _ H.base_open.inj).symm
[GOAL]
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝ : IsReduced Y
U : Opens ↑↑X.toPresheafedSpace
⊢ U = (Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)
[PROOFSTEP]
ext1
[GOAL]
case h
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝ : IsReduced Y
U : Opens ↑↑X.toPresheafedSpace
⊢ ↑U = ↑((Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U))
[PROOFSTEP]
exact (Set.preimage_image_eq _ H.base_open.inj).symm
[GOAL]
case component_reduced
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝ : IsReduced Y
U : Opens ↑↑X.toPresheafedSpace
this : U = (Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)
⊢ _root_.IsReduced ↑(X.presheaf.obj (op U))
[PROOFSTEP]
rw [this]
[GOAL]
case component_reduced
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝ : IsReduced Y
U : Opens ↑↑X.toPresheafedSpace
this : U = (Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)
⊢ _root_.IsReduced
    ↑(X.presheaf.obj (op ((Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U))))
[PROOFSTEP]
exact
  isReduced_of_injective (inv <| f.1.c.app (op <| H.base_open.isOpenMap.functor.obj U))
    (asIso <| f.1.c.app (op <| H.base_open.isOpenMap.functor.obj U) :
        Y.presheaf.obj _ ≅ _).symm.commRingCatIsoToRingEquiv.injective
[GOAL]
X : Scheme
R : CommRingCat
H : _root_.IsReduced ↑R
⊢ IsReduced (Scheme.Spec.obj (op R))
[PROOFSTEP]
apply (config := { allowSynthFailures := true }) isReducedOfStalkIsReduced
[GOAL]
case inst
X : Scheme
R : CommRingCat
H : _root_.IsReduced ↑R
⊢ ∀ (x : ↑↑(Scheme.Spec.obj (op R)).toPresheafedSpace),
    _root_.IsReduced ↑(Presheaf.stalk (Scheme.Spec.obj (op R)).presheaf x)
[PROOFSTEP]
intro x
[GOAL]
case inst
X : Scheme
R : CommRingCat
H : _root_.IsReduced ↑R
x : ↑↑(Scheme.Spec.obj (op R)).toPresheafedSpace
⊢ _root_.IsReduced ↑(Presheaf.stalk (Scheme.Spec.obj (op R)).presheaf x)
[PROOFSTEP]
dsimp
[GOAL]
case inst
X : Scheme
R : CommRingCat
H : _root_.IsReduced ↑R
x : ↑↑(Scheme.Spec.obj (op R)).toPresheafedSpace
⊢ _root_.IsReduced ↑(Presheaf.stalk (Scheme.Spec.obj (op R)).presheaf x)
[PROOFSTEP]
have : _root_.IsReduced (CommRingCat.of <| Localization.AtPrime (PrimeSpectrum.asIdeal x)) := by dsimp; infer_instance
[GOAL]
X : Scheme
R : CommRingCat
H : _root_.IsReduced ↑R
x : ↑↑(Scheme.Spec.obj (op R)).toPresheafedSpace
⊢ _root_.IsReduced ↑(CommRingCat.of (Localization.AtPrime x.asIdeal))
[PROOFSTEP]
dsimp
[GOAL]
X : Scheme
R : CommRingCat
H : _root_.IsReduced ↑R
x : ↑↑(Scheme.Spec.obj (op R)).toPresheafedSpace
⊢ _root_.IsReduced (Localization.AtPrime x.asIdeal)
[PROOFSTEP]
infer_instance
[GOAL]
case inst
X : Scheme
R : CommRingCat
H : _root_.IsReduced ↑R
x : ↑↑(Scheme.Spec.obj (op R)).toPresheafedSpace
this : _root_.IsReduced ↑(CommRingCat.of (Localization.AtPrime x.asIdeal))
⊢ _root_.IsReduced ↑(Presheaf.stalk (Scheme.Spec.obj (op R)).presheaf x)
[PROOFSTEP]
exact
  isReduced_of_injective (StructureSheaf.stalkIso R x).hom
    (StructureSheaf.stalkIso R x).commRingCatIsoToRingEquiv.injective
[GOAL]
X : Scheme
R : CommRingCat
⊢ IsReduced (Scheme.Spec.obj (op R)) ↔ _root_.IsReduced ↑R
[PROOFSTEP]
refine' ⟨_, fun h => inferInstance⟩
[GOAL]
X : Scheme
R : CommRingCat
⊢ IsReduced (Scheme.Spec.obj (op R)) → _root_.IsReduced ↑R
[PROOFSTEP]
intro h
[GOAL]
X : Scheme
R : CommRingCat
h : IsReduced (Scheme.Spec.obj (op R))
⊢ _root_.IsReduced ↑R
[PROOFSTEP]
have : _root_.IsReduced (LocallyRingedSpace.Γ.obj (op <| Spec.toLocallyRingedSpace.obj <| op R)) := by
  change _root_.IsReduced ((Scheme.Spec.obj <| op R).presheaf.obj <| op ⊤); infer_instance
[GOAL]
X : Scheme
R : CommRingCat
h : IsReduced (Scheme.Spec.obj (op R))
⊢ _root_.IsReduced ↑(LocallyRingedSpace.Γ.obj (op (Spec.toLocallyRingedSpace.obj (op R))))
[PROOFSTEP]
change _root_.IsReduced ((Scheme.Spec.obj <| op R).presheaf.obj <| op ⊤)
[GOAL]
X : Scheme
R : CommRingCat
h : IsReduced (Scheme.Spec.obj (op R))
⊢ _root_.IsReduced ↑((Scheme.Spec.obj (op R)).presheaf.obj (op ⊤))
[PROOFSTEP]
infer_instance
[GOAL]
X : Scheme
R : CommRingCat
h : IsReduced (Scheme.Spec.obj (op R))
this : _root_.IsReduced ↑(LocallyRingedSpace.Γ.obj (op (Spec.toLocallyRingedSpace.obj (op R))))
⊢ _root_.IsReduced ↑R
[PROOFSTEP]
exact isReduced_of_injective (toSpecΓ R) (asIso <| toSpecΓ R).commRingCatIsoToRingEquiv.injective
[GOAL]
X : Scheme
inst✝ : IsAffine X
h : _root_.IsReduced ↑(X.presheaf.obj (op ⊤))
⊢ IsReduced (Scheme.Spec.obj (op (Scheme.Γ.obj (op X))))
[PROOFSTEP]
rw [affine_isReduced_iff]
[GOAL]
X : Scheme
inst✝ : IsAffine X
h : _root_.IsReduced ↑(X.presheaf.obj (op ⊤))
⊢ _root_.IsReduced ↑(Scheme.Γ.obj (op X))
[PROOFSTEP]
exact h
[GOAL]
X : Scheme
P : (X : Scheme) → Opens ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : { x // x ∈ U }), ∃ V x x, P X V) → P X U
h₂ :
  ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV, P X { carrier := U, is_open' := (_ : IsOpen U) } → P Y { carrier := V, is_open' := (_ : IsOpen V) }
h₃ : ∀ (R : CommRingCat), P (Scheme.Spec.obj (op R)) ⊤
⊢ ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), P X U
[PROOFSTEP]
intro X U
[GOAL]
X✝ : Scheme
P : (X : Scheme) → Opens ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : { x // x ∈ U }), ∃ V x x, P X V) → P X U
h₂ :
  ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV, P X { carrier := U, is_open' := (_ : IsOpen U) } → P Y { carrier := V, is_open' := (_ : IsOpen V) }
h₃ : ∀ (R : CommRingCat), P (Scheme.Spec.obj (op R)) ⊤
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
⊢ P X U
[PROOFSTEP]
apply h₁
[GOAL]
case a
X✝ : Scheme
P : (X : Scheme) → Opens ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : { x // x ∈ U }), ∃ V x x, P X V) → P X U
h₂ :
  ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV, P X { carrier := U, is_open' := (_ : IsOpen U) } → P Y { carrier := V, is_open' := (_ : IsOpen V) }
h₃ : ∀ (R : CommRingCat), P (Scheme.Spec.obj (op R)) ⊤
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
⊢ ∀ (x : { x // x ∈ U }), ∃ V x x, P X V
[PROOFSTEP]
intro x
[GOAL]
case a
X✝ : Scheme
P : (X : Scheme) → Opens ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : { x // x ∈ U }), ∃ V x x, P X V) → P X U
h₂ :
  ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV, P X { carrier := U, is_open' := (_ : IsOpen U) } → P Y { carrier := V, is_open' := (_ : IsOpen V) }
h₃ : ∀ (R : CommRingCat), P (Scheme.Spec.obj (op R)) ⊤
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
x : { x // x ∈ U }
⊢ ∃ V x x, P X V
[PROOFSTEP]
obtain ⟨_, ⟨j, rfl⟩, hx, i⟩ := X.affineBasisCover_is_basis.exists_subset_of_mem_open (SetLike.mem_coe.2 x.prop) U.isOpen
[GOAL]
case a.intro.intro.intro.intro
X✝ : Scheme
P : (X : Scheme) → Opens ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : { x // x ∈ U }), ∃ V x x, P X V) → P X U
h₂ :
  ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV, P X { carrier := U, is_open' := (_ : IsOpen U) } → P Y { carrier := V, is_open' := (_ : IsOpen V) }
h₃ : ∀ (R : CommRingCat), P (Scheme.Spec.obj (op R)) ⊤
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
x : { x // x ∈ U }
j : (Scheme.affineBasisCover X).J
hx : ↑x ∈ Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base
i : Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base ⊆ ↑U
⊢ ∃ V x x, P X V
[PROOFSTEP]
let U' : Opens _ := ⟨_, (X.affineBasisCover.IsOpen j).base_open.open_range⟩
[GOAL]
case a.intro.intro.intro.intro
X✝ : Scheme
P : (X : Scheme) → Opens ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : { x // x ∈ U }), ∃ V x x, P X V) → P X U
h₂ :
  ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV, P X { carrier := U, is_open' := (_ : IsOpen U) } → P Y { carrier := V, is_open' := (_ : IsOpen V) }
h₃ : ∀ (R : CommRingCat), P (Scheme.Spec.obj (op R)) ⊤
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
x : { x // x ∈ U }
j : (Scheme.affineBasisCover X).J
hx : ↑x ∈ Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base
i : Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base ⊆ ↑U
U' : Opens ((forget TopCat).obj ↑X.toPresheafedSpace) :=
  { carrier := Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base,
    is_open' := (_ : IsOpen (Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base)) }
⊢ ∃ V x x, P X V
[PROOFSTEP]
let i' : U' ⟶ U := homOfLE i
[GOAL]
case a.intro.intro.intro.intro
X✝ : Scheme
P : (X : Scheme) → Opens ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : { x // x ∈ U }), ∃ V x x, P X V) → P X U
h₂ :
  ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV, P X { carrier := U, is_open' := (_ : IsOpen U) } → P Y { carrier := V, is_open' := (_ : IsOpen V) }
h₃ : ∀ (R : CommRingCat), P (Scheme.Spec.obj (op R)) ⊤
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
x : { x // x ∈ U }
j : (Scheme.affineBasisCover X).J
hx : ↑x ∈ Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base
i : Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base ⊆ ↑U
U' : Opens ((forget TopCat).obj ↑X.toPresheafedSpace) :=
  { carrier := Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base,
    is_open' := (_ : IsOpen (Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base)) }
i' : U' ⟶ U := homOfLE i
⊢ ∃ V x x, P X V
[PROOFSTEP]
refine' ⟨U', hx, i', _⟩
[GOAL]
case a.intro.intro.intro.intro
X✝ : Scheme
P : (X : Scheme) → Opens ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : { x // x ∈ U }), ∃ V x x, P X V) → P X U
h₂ :
  ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV, P X { carrier := U, is_open' := (_ : IsOpen U) } → P Y { carrier := V, is_open' := (_ : IsOpen V) }
h₃ : ∀ (R : CommRingCat), P (Scheme.Spec.obj (op R)) ⊤
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
x : { x // x ∈ U }
j : (Scheme.affineBasisCover X).J
hx : ↑x ∈ Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base
i : Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base ⊆ ↑U
U' : Opens ((forget TopCat).obj ↑X.toPresheafedSpace) :=
  { carrier := Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base,
    is_open' := (_ : IsOpen (Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base)) }
i' : U' ⟶ U := homOfLE i
⊢ P X U'
[PROOFSTEP]
obtain ⟨_, _, rfl, rfl, h₂'⟩ := h₂ (X.affineBasisCover.map j)
[GOAL]
case a.intro.intro.intro.intro.intro.intro.intro.intro
X✝ : Scheme
P : (X : Scheme) → Opens ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : { x // x ∈ U }), ∃ V x x, P X V) → P X U
h₂ :
  ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV, P X { carrier := U, is_open' := (_ : IsOpen U) } → P Y { carrier := V, is_open' := (_ : IsOpen V) }
h₃ : ∀ (R : CommRingCat), P (Scheme.Spec.obj (op R)) ⊤
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
x : { x // x ∈ U }
j : (Scheme.affineBasisCover X).J
hx : ↑x ∈ Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base
i : Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base ⊆ ↑U
U' : Opens ((forget TopCat).obj ↑X.toPresheafedSpace) :=
  { carrier := Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base,
    is_open' := (_ : IsOpen (Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base)) }
i' : U' ⟶ U := homOfLE i
h₂' :
  P (Scheme.OpenCover.obj (Scheme.affineBasisCover X) j) { carrier := ⊤, is_open' := (_ : IsOpen ⊤) } →
    P X
      { carrier := Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base,
        is_open' := (_ : IsOpen (Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base)) }
⊢ P X U'
[PROOFSTEP]
apply h₂'
[GOAL]
case a.intro.intro.intro.intro.intro.intro.intro.intro
X✝ : Scheme
P : (X : Scheme) → Opens ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace), (∀ (x : { x // x ∈ U }), ∃ V x x, P X V) → P X U
h₂ :
  ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV, P X { carrier := U, is_open' := (_ : IsOpen U) } → P Y { carrier := V, is_open' := (_ : IsOpen V) }
h₃ : ∀ (R : CommRingCat), P (Scheme.Spec.obj (op R)) ⊤
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
x : { x // x ∈ U }
j : (Scheme.affineBasisCover X).J
hx : ↑x ∈ Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base
i : Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base ⊆ ↑U
U' : Opens ((forget TopCat).obj ↑X.toPresheafedSpace) :=
  { carrier := Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base,
    is_open' := (_ : IsOpen (Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base)) }
i' : U' ⟶ U := homOfLE i
h₂' :
  P (Scheme.OpenCover.obj (Scheme.affineBasisCover X) j) { carrier := ⊤, is_open' := (_ : IsOpen ⊤) } →
    P X
      { carrier := Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base,
        is_open' := (_ : IsOpen (Set.range ↑(Scheme.OpenCover.map (Scheme.affineBasisCover X) j).val.base)) }
⊢ P (Scheme.OpenCover.obj (Scheme.affineBasisCover X) j) { carrier := ⊤, is_open' := (_ : IsOpen ⊤) }
[PROOFSTEP]
apply h₃
[GOAL]
X : Scheme
P : (X : Scheme) → ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (R : CommRingCat) (x : PrimeSpectrum ↑R), P (Scheme.Spec.obj (op R)) x
h₂ : ∀ {X Y : Scheme} (f : X ⟶ Y) [inst : IsOpenImmersion f] (x : ↑↑X.toPresheafedSpace), P X x → P Y (↑f.val.base x)
⊢ ∀ (X : Scheme) (x : ↑↑X.toPresheafedSpace), P X x
[PROOFSTEP]
intro X x
[GOAL]
X✝ : Scheme
P : (X : Scheme) → ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (R : CommRingCat) (x : PrimeSpectrum ↑R), P (Scheme.Spec.obj (op R)) x
h₂ : ∀ {X Y : Scheme} (f : X ⟶ Y) [inst : IsOpenImmersion f] (x : ↑↑X.toPresheafedSpace), P X x → P Y (↑f.val.base x)
X : Scheme
x : ↑↑X.toPresheafedSpace
⊢ P X x
[PROOFSTEP]
obtain ⟨y, e⟩ := X.affineCover.Covers x
[GOAL]
case intro
X✝ : Scheme
P : (X : Scheme) → ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (R : CommRingCat) (x : PrimeSpectrum ↑R), P (Scheme.Spec.obj (op R)) x
h₂ : ∀ {X Y : Scheme} (f : X ⟶ Y) [inst : IsOpenImmersion f] (x : ↑↑X.toPresheafedSpace), P X x → P Y (↑f.val.base x)
X : Scheme
x : ↑↑X.toPresheafedSpace
y :
  (forget TopCat).obj
    ↑(Scheme.OpenCover.obj (Scheme.affineCover X) (Scheme.OpenCover.f (Scheme.affineCover X) x)).toPresheafedSpace
e : ↑(Scheme.OpenCover.map (Scheme.affineCover X) (Scheme.OpenCover.f (Scheme.affineCover X) x)).val.base y = x
⊢ P X x
[PROOFSTEP]
convert h₂ (X.affineCover.map (X.affineCover.f x)) y _
[GOAL]
case h.e'_2
X✝ : Scheme
P : (X : Scheme) → ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (R : CommRingCat) (x : PrimeSpectrum ↑R), P (Scheme.Spec.obj (op R)) x
h₂ : ∀ {X Y : Scheme} (f : X ⟶ Y) [inst : IsOpenImmersion f] (x : ↑↑X.toPresheafedSpace), P X x → P Y (↑f.val.base x)
X : Scheme
x : ↑↑X.toPresheafedSpace
y :
  (forget TopCat).obj
    ↑(Scheme.OpenCover.obj (Scheme.affineCover X) (Scheme.OpenCover.f (Scheme.affineCover X) x)).toPresheafedSpace
e : ↑(Scheme.OpenCover.map (Scheme.affineCover X) (Scheme.OpenCover.f (Scheme.affineCover X) x)).val.base y = x
⊢ x = ↑(Scheme.OpenCover.map (Scheme.affineCover X) (Scheme.OpenCover.f (Scheme.affineCover X) x)).val.base y
[PROOFSTEP]
rw [e]
[GOAL]
case intro
X✝ : Scheme
P : (X : Scheme) → ↑↑X.toPresheafedSpace → Prop
h₁ : ∀ (R : CommRingCat) (x : PrimeSpectrum ↑R), P (Scheme.Spec.obj (op R)) x
h₂ : ∀ {X Y : Scheme} (f : X ⟶ Y) [inst : IsOpenImmersion f] (x : ↑↑X.toPresheafedSpace), P X x → P Y (↑f.val.base x)
X : Scheme
x : ↑↑X.toPresheafedSpace
y :
  (forget TopCat).obj
    ↑(Scheme.OpenCover.obj (Scheme.affineCover X) (Scheme.OpenCover.f (Scheme.affineCover X) x)).toPresheafedSpace
e : ↑(Scheme.OpenCover.map (Scheme.affineCover X) (Scheme.OpenCover.f (Scheme.affineCover X) x)).val.base y = x
⊢ P (Scheme.OpenCover.obj (Scheme.affineCover X) (Scheme.OpenCover.f (Scheme.affineCover X) x)) y
[PROOFSTEP]
apply h₁
[GOAL]
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
⊢ s = 0
[PROOFSTEP]
apply TopCat.Presheaf.section_ext X.sheaf U
[GOAL]
case h
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
⊢ ∀ (x : { x // x ∈ U }),
    ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) 0
[PROOFSTEP]
conv => intro x; rw [RingHom.map_zero]
[GOAL]
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
| ∀ (x : { x // x ∈ U }),
    ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) 0
[PROOFSTEP]
intro x; rw [RingHom.map_zero]
[GOAL]
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
| ∀ (x : { x // x ∈ U }),
    ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) 0
[PROOFSTEP]
intro x; rw [RingHom.map_zero]
[GOAL]
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
| ∀ (x : { x // x ∈ U }),
    ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) 0
[PROOFSTEP]
intro x
[GOAL]
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
x : { x // x ∈ U }
| ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) 0
[PROOFSTEP]
rw [RingHom.map_zero]
[GOAL]
case h
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
⊢ ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
[PROOFSTEP]
refine'
  (@reduce_to_affine_global
      (fun X U => ∀ [IsReduced X] (s : X.presheaf.obj (op U)), X.basicOpen s = ⊥ → ∀ x, (X.sheaf.presheaf.germ x) s = 0)
      _ _ _)
    X U s hs
[GOAL]
case h.refine'_1
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
⊢ ∀ (X : Scheme) (U : Opens ↑↑X.toPresheafedSpace),
    (∀ (x : { x // x ∈ U }),
        ∃ V x x,
          (fun X U =>
              ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
                Scheme.basicOpen X s = ⊥ →
                  ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
            X V) →
      (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        X U
[PROOFSTEP]
intro X U hx hX s hs x
[GOAL]
case h.refine'_1
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U✝ : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U✝))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx :
  ∀ (x : { x // x ∈ U }),
    ∃ V x x,
      (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        X V
hX : IsReduced X
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
x : { x // x ∈ U }
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
[PROOFSTEP]
obtain ⟨V, hx, i, H⟩ := hx x
[GOAL]
case h.refine'_1.intro.intro.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U✝ : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U✝))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : { x // x ∈ U }),
    ∃ V x x,
      (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        X V
hX : IsReduced X
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
x : { x // x ∈ U }
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H :
  ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op V))),
    Scheme.basicOpen X s = ⊥ → ∀ (x : { x // x ∈ V }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
[PROOFSTEP]
specialize H (X.presheaf.map i.op s)
[GOAL]
case h.refine'_1.intro.intro.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U✝ : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U✝))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : { x // x ∈ U }),
    ∃ V x x,
      (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        X V
hX : IsReduced X
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
x : { x // x ∈ U }
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H :
  Scheme.basicOpen X (↑(X.presheaf.map i.op) s) = ⊥ →
    ∀ (x : { x // x ∈ V }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) (↑(X.presheaf.map i.op) s) = 0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
[PROOFSTEP]
erw [Scheme.basicOpen_res] at H
[GOAL]
case h.refine'_1.intro.intro.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U✝ : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U✝))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : { x // x ∈ U }),
    ∃ V x x,
      (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        X V
hX : IsReduced X
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
x : { x // x ∈ U }
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H :
  V ⊓ Scheme.basicOpen X s = ⊥ →
    ∀ (x : { x // x ∈ V }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) (↑(X.presheaf.map i.op) s) = 0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
[PROOFSTEP]
rw [hs] at H
[GOAL]
case h.refine'_1.intro.intro.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U✝ : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U✝))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : { x // x ∈ U }),
    ∃ V x x,
      (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        X V
hX : IsReduced X
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
x : { x // x ∈ U }
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H :
  V ⊓ ⊥ = ⊥ →
    ∀ (x : { x // x ∈ V }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) (↑(X.presheaf.map i.op) s) = 0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
[PROOFSTEP]
specialize H inf_bot_eq ⟨x, hx⟩
[GOAL]
case h.refine'_1.intro.intro.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U✝ : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U✝))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : { x // x ∈ U }),
    ∃ V x x,
      (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        X V
hX : IsReduced X
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
x : { x // x ∈ U }
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) { val := ↑x, property := hx }) (↑(X.presheaf.map i.op) s) = 0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
[PROOFSTEP]
erw [TopCat.Presheaf.germ_res_apply] at H
[GOAL]
case h.refine'_1.intro.intro.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U✝ : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U✝))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : { x // x ∈ U }),
    ∃ V x x,
      (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        X V
hX : IsReduced X
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
x : { x // x ∈ U }
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H :
  ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X))
          ((fun x => { val := ↑x, property := (_ : ↑x ∈ ↑U) }) { val := ↑x, property := hx }))
      s =
    0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
[PROOFSTEP]
exact H
[GOAL]
case h.refine'_2
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
⊢ ∀ {X Y : Scheme} (f : X ⟶ Y) [hf : IsOpenImmersion f],
    ∃ U V hU hV,
      (fun X U =>
            ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
              Scheme.basicOpen X s = ⊥ →
                ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
          X { carrier := U, is_open' := (_ : IsOpen U) } →
        (fun X U =>
            ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
              Scheme.basicOpen X s = ⊥ →
                ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
          Y { carrier := V, is_open' := (_ : IsOpen V) }
[PROOFSTEP]
rintro X Y f hf
[GOAL]
case h.refine'_2
X✝¹ : Scheme
X✝ : Scheme
hX : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s : ↑(X✝.presheaf.obj (op U))
hs : Scheme.basicOpen X✝ s = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
⊢ ∃ U V hU hV,
    (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        X { carrier := U, is_open' := (_ : IsOpen U) } →
      (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        Y { carrier := V, is_open' := (_ : IsOpen V) }
[PROOFSTEP]
have e : f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ := by
  rw [← Set.image_univ, Set.preimage_image_eq _ hf.base_open.inj]
[GOAL]
X✝¹ : Scheme
X✝ : Scheme
hX : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s : ↑(X✝.presheaf.obj (op U))
hs : Scheme.basicOpen X✝ s = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
⊢ ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
[PROOFSTEP]
rw [← Set.image_univ, Set.preimage_image_eq _ hf.base_open.inj]
[GOAL]
case h.refine'_2
X✝¹ : Scheme
X✝ : Scheme
hX : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s : ↑(X✝.presheaf.obj (op U))
hs : Scheme.basicOpen X✝ s = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
⊢ ∃ U V hU hV,
    (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        X { carrier := U, is_open' := (_ : IsOpen U) } →
      (fun X U =>
          ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
            Scheme.basicOpen X s = ⊥ →
              ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
        Y { carrier := V, is_open' := (_ : IsOpen V) }
[PROOFSTEP]
refine' ⟨_, _, e, rfl, _⟩
[GOAL]
case h.refine'_2
X✝¹ : Scheme
X✝ : Scheme
hX : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s : ↑(X✝.presheaf.obj (op U))
hs : Scheme.basicOpen X✝ s = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
⊢ (fun X U =>
        ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
          Scheme.basicOpen X s = ⊥ → ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
      X
      { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
        is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) } →
    (fun X U =>
        ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
          Scheme.basicOpen X s = ⊥ → ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
      Y { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }
[PROOFSTEP]
rintro H hX s hs ⟨_, x, rfl⟩
[GOAL]
case h.refine'_2.mk.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
H :
  ∀ [inst : IsReduced X]
    (s :
      ↑(X.presheaf.obj
          (op
            { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
              is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }))),
    Scheme.basicOpen X s = ⊥ →
      ∀
        (x :
          { x //
            x ∈
              { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) } }),
        ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf Y))
          { val := ↑f.val.base x, property := (_ : ∃ y, ↑f.val.base y = ↑f.val.base x) })
      s =
    0
[PROOFSTEP]
haveI := isReducedOfOpenImmersion f
[GOAL]
case h.refine'_2.mk.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
H :
  ∀ [inst : IsReduced X]
    (s :
      ↑(X.presheaf.obj
          (op
            { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
              is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }))),
    Scheme.basicOpen X s = ⊥ →
      ∀
        (x :
          { x //
            x ∈
              { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) } }),
        ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
this : IsReduced X
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf Y))
          { val := ↑f.val.base x, property := (_ : ∃ y, ↑f.val.base y = ↑f.val.base x) })
      s =
    0
[PROOFSTEP]
specialize H (f.1.c.app _ s) _ ⟨x, by rw [Opens.mem_mk, e]; trivial⟩
[GOAL]
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
H :
  ∀ [inst : IsReduced X]
    (s :
      ↑(X.presheaf.obj
          (op
            { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
              is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }))),
    Scheme.basicOpen X s = ⊥ →
      ∀
        (x :
          { x //
            x ∈
              { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) } }),
        ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
this : IsReduced X
⊢ x ∈
    { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
      is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }
[PROOFSTEP]
rw [Opens.mem_mk, e]
[GOAL]
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
H :
  ∀ [inst : IsReduced X]
    (s :
      ↑(X.presheaf.obj
          (op
            { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
              is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }))),
    Scheme.basicOpen X s = ⊥ →
      ∀
        (x :
          { x //
            x ∈
              { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) } }),
        ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
this : IsReduced X
⊢ x ∈ Set.univ
[PROOFSTEP]
trivial
[GOAL]
case h.refine'_2.mk.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
H :
  ∀ [inst : IsReduced X]
    (s :
      ↑(X.presheaf.obj
          (op
            { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
              is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }))),
    Scheme.basicOpen X s = ⊥ →
      ∀
        (x :
          { x //
            x ∈
              { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) } }),
        ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
this : IsReduced X
⊢ Scheme.basicOpen X
      (↑(NatTrans.app f.val.c
            (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
        s) =
    ⊥
[PROOFSTEP]
rw [← Scheme.preimage_basicOpen, hs]
[GOAL]
case h.refine'_2.mk.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
H :
  ∀ [inst : IsReduced X]
    (s :
      ↑(X.presheaf.obj
          (op
            { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
              is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }))),
    Scheme.basicOpen X s = ⊥ →
      ∀
        (x :
          { x //
            x ∈
              { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) } }),
        ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
this : IsReduced X
⊢ (Opens.map f.val.base).obj ⊥ = ⊥
[PROOFSTEP]
ext1
[GOAL]
case h.refine'_2.mk.intro.h
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
H :
  ∀ [inst : IsReduced X]
    (s :
      ↑(X.presheaf.obj
          (op
            { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
              is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }))),
    Scheme.basicOpen X s = ⊥ →
      ∀
        (x :
          { x //
            x ∈
              { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) } }),
        ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
this : IsReduced X
⊢ ↑((Opens.map f.val.base).obj ⊥) = ↑⊥
[PROOFSTEP]
simp [Opens.map]
[GOAL]
case h.refine'_2.mk.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
this : IsReduced X
H :
  ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X))
          { val := x,
            property :=
              (_ :
                x ∈
                  { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                    is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }) })
      (↑(NatTrans.app f.val.c
            (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
        s) =
    0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf Y))
          { val := ↑f.val.base x, property := (_ : ∃ y, ↑f.val.base y = ↑f.val.base x) })
      s =
    0
[PROOFSTEP]
erw [← PresheafedSpace.stalkMap_germ_apply f.1 ⟨_, _⟩ ⟨x, _⟩] at H
[GOAL]
case h.refine'_2.mk.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
this : IsReduced X
H :
  ↑(PresheafedSpace.stalkMap f.val
          ↑{ val := x,
              property :=
                (_ :
                  x ∈
                    { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                      is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }) })
      (↑(Presheaf.germ Y.presheaf
            {
              val :=
                ↑f.val.base
                  ↑{ val := x,
                      property :=
                        (_ :
                          x ∈
                            { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                              is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }) },
              property :=
                (_ :
                  ↑{ val := x,
                        property :=
                          (_ :
                            x ∈
                              { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                                is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }) } ∈
                    (Opens.map f.val.base).obj
                      { carrier := fun x => ∃ y, ↑f.val.base y = x,
                        is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }) })
        s) =
    0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf Y))
          { val := ↑f.val.base x, property := (_ : ∃ y, ↑f.val.base y = ↑f.val.base x) })
      s =
    0
[PROOFSTEP]
apply_fun inv <| PresheafedSpace.stalkMap f.val x at H
[GOAL]
case h.refine'_2.mk.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
this : IsReduced X
H :
  ↑(inv (PresheafedSpace.stalkMap f.val x))
      (↑(PresheafedSpace.stalkMap f.val
            ↑{ val := x,
                property :=
                  (_ :
                    x ∈
                      { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                        is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }) })
        (↑(Presheaf.germ Y.presheaf
              {
                val :=
                  ↑f.val.base
                    ↑{ val := x,
                        property :=
                          (_ :
                            x ∈
                              { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                                is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }) },
                property :=
                  (_ :
                    ↑{ val := x,
                          property :=
                            (_ :
                              x ∈
                                { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                                  is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }) } ∈
                      (Opens.map f.val.base).obj
                        { carrier := fun x => ∃ y, ↑f.val.base y = x,
                          is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }) })
          s)) =
    ↑(inv (PresheafedSpace.stalkMap f.val x)) 0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf Y))
          { val := ↑f.val.base x, property := (_ : ∃ y, ↑f.val.base y = ↑f.val.base x) })
      s =
    0
[PROOFSTEP]
erw [CategoryTheory.IsIso.hom_inv_id_apply, map_zero] at H
[GOAL]
case h.refine'_2.mk.intro
X✝¹ : Scheme
X✝ : Scheme
hX✝ : IsReduced X✝
U : Opens ↑↑X✝.toPresheafedSpace
s✝ : ↑(X✝.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X✝ s✝ = ⊥
X Y : Scheme
f : X ⟶ Y
hf : IsOpenImmersion f
e : ↑f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ
hX : IsReduced Y
s : ↑(Y.presheaf.obj (op { carrier := Set.range ↑f.val.base, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }))
hs : Scheme.basicOpen Y s = ⊥
x : (forget TopCat).obj ↑X.toPresheafedSpace
this : IsReduced X
H :
  ↑(Presheaf.germ Y.presheaf
          {
            val :=
              ↑f.val.base
                ↑{ val := x,
                    property :=
                      (_ :
                        x ∈
                          { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                            is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }) },
            property :=
              (_ :
                ↑{ val := x,
                      property :=
                        (_ :
                          x ∈
                            { carrier := ↑f.val.base ⁻¹' Set.range ↑f.val.base,
                              is_open' := (_ : IsOpen (↑f.val.base ⁻¹' Set.range ↑f.val.base)) }) } ∈
                  (Opens.map f.val.base).obj
                    { carrier := fun x => ∃ y, ↑f.val.base y = x, is_open' := (_ : IsOpen (Set.range ↑f.val.base)) }) })
      s =
    0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf Y))
          { val := ↑f.val.base x, property := (_ : ∃ y, ↑f.val.base y = ↑f.val.base x) })
      s =
    0
[PROOFSTEP]
exact H
[GOAL]
case h.refine'_3
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
hs : Scheme.basicOpen X s = ⊥
⊢ ∀ (R : CommRingCat),
    (fun X U =>
        ∀ [inst : IsReduced X] (s : ↑(X.presheaf.obj (op U))),
          Scheme.basicOpen X s = ⊥ → ∀ (x : { x // x ∈ U }), ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf X)) x) s = 0)
      (Scheme.Spec.obj (op R)) ⊤
[PROOFSTEP]
intro R hX s hs x
[GOAL]
case h.refine'_3
X✝ : Scheme
X : Scheme
hX✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s✝ : ↑(X.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X s✝ = ⊥
R : CommRingCat
hX : IsReduced (Scheme.Spec.obj (op R))
s : ↑((Scheme.Spec.obj (op R)).presheaf.obj (op ⊤))
hs : Scheme.basicOpen (Scheme.Spec.obj (op R)) s = ⊥
x : { x // x ∈ ⊤ }
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf (Scheme.Spec.obj (op R)))) x) s = 0
[PROOFSTEP]
erw [basicOpen_eq_of_affine', PrimeSpectrum.basicOpen_eq_bot_iff] at hs
[GOAL]
case h.refine'_3
X✝ : Scheme
X : Scheme
hX✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s✝ : ↑(X.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X s✝ = ⊥
R : CommRingCat
hX : IsReduced (Scheme.Spec.obj (op R))
s : ↑((Scheme.Spec.obj (op R)).presheaf.obj (op ⊤))
hs : IsNilpotent (↑(SpecΓIdentity.app R).hom s)
x : { x // x ∈ ⊤ }
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf (Scheme.Spec.obj (op R)))) x) s = 0
[PROOFSTEP]
replace hs := hs.map (SpecΓIdentity.app R).inv
[GOAL]
case h.refine'_3
X✝ : Scheme
X : Scheme
hX✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s✝ : ↑(X.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X s✝ = ⊥
R : CommRingCat
hX : IsReduced (Scheme.Spec.obj (op R))
s : ↑((Scheme.Spec.obj (op R)).presheaf.obj (op ⊤))
x : { x // x ∈ ⊤ }
hs : IsNilpotent (↑(SpecΓIdentity.app R).inv (↑(SpecΓIdentity.app R).hom s))
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf (Scheme.Spec.obj (op R)))) x) s = 0
[PROOFSTEP]
replace hs := @IsNilpotent.eq_zero _ _ _ _ (show _ from ?_) hs
[GOAL]
case h.refine'_3.refine_2
X✝ : Scheme
X : Scheme
hX✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s✝ : ↑(X.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X s✝ = ⊥
R : CommRingCat
hX : IsReduced (Scheme.Spec.obj (op R))
s : ↑((Scheme.Spec.obj (op R)).presheaf.obj (op ⊤))
x : { x // x ∈ ⊤ }
hs : ↑(SpecΓIdentity.app R).inv (↑(SpecΓIdentity.app R).hom s) = 0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf (Scheme.Spec.obj (op R)))) x) s = 0
case h.refine'_3.refine_1
X✝ : Scheme
X : Scheme
hX✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s✝ : ↑(X.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X s✝ = ⊥
R : CommRingCat
hX : IsReduced (Scheme.Spec.obj (op R))
s : ↑((Scheme.Spec.obj (op R)).presheaf.obj (op ⊤))
x : { x // x ∈ ⊤ }
hs : IsNilpotent (↑(SpecΓIdentity.app R).inv (↑(SpecΓIdentity.app R).hom s))
⊢ _root_.IsReduced
    ((fun x => ↑((Spec.toLocallyRingedSpace.rightOp ⋙ LocallyRingedSpace.Γ).obj R)) (↑(SpecΓIdentity.app R).hom s))
[PROOFSTEP]
rw [Iso.hom_inv_id_apply] at hs
[GOAL]
case h.refine'_3.refine_2
X✝ : Scheme
X : Scheme
hX✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s✝ : ↑(X.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X s✝ = ⊥
R : CommRingCat
hX : IsReduced (Scheme.Spec.obj (op R))
s : ↑((Scheme.Spec.obj (op R)).presheaf.obj (op ⊤))
x : { x // x ∈ ⊤ }
hs : s = 0
⊢ ↑(Presheaf.germ (Sheaf.presheaf (Scheme.sheaf (Scheme.Spec.obj (op R)))) x) s = 0
case h.refine'_3.refine_1
X✝ : Scheme
X : Scheme
hX✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s✝ : ↑(X.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X s✝ = ⊥
R : CommRingCat
hX : IsReduced (Scheme.Spec.obj (op R))
s : ↑((Scheme.Spec.obj (op R)).presheaf.obj (op ⊤))
x : { x // x ∈ ⊤ }
hs : IsNilpotent (↑(SpecΓIdentity.app R).inv (↑(SpecΓIdentity.app R).hom s))
⊢ _root_.IsReduced
    ((fun x => ↑((Spec.toLocallyRingedSpace.rightOp ⋙ LocallyRingedSpace.Γ).obj R)) (↑(SpecΓIdentity.app R).hom s))
[PROOFSTEP]
rw [hs, map_zero]
[GOAL]
case h.refine'_3.refine_1
X✝ : Scheme
X : Scheme
hX✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s✝ : ↑(X.presheaf.obj (op U))
hs✝ : Scheme.basicOpen X s✝ = ⊥
R : CommRingCat
hX : IsReduced (Scheme.Spec.obj (op R))
s : ↑((Scheme.Spec.obj (op R)).presheaf.obj (op ⊤))
x : { x // x ∈ ⊤ }
hs : IsNilpotent (↑(SpecΓIdentity.app R).inv (↑(SpecΓIdentity.app R).hom s))
⊢ _root_.IsReduced
    ((fun x => ↑((Spec.toLocallyRingedSpace.rightOp ⋙ LocallyRingedSpace.Γ).obj R)) (↑(SpecΓIdentity.app R).hom s))
[PROOFSTEP]
exact @IsReduced.component_reduced _ hX ⊤
[GOAL]
X✝ : Scheme
X : Scheme
inst✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
⊢ Scheme.basicOpen X s = ⊥ ↔ s = 0
[PROOFSTEP]
refine' ⟨eq_zero_of_basicOpen_eq_bot s, _⟩
[GOAL]
X✝ : Scheme
X : Scheme
inst✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑(X.presheaf.obj (op U))
⊢ s = 0 → Scheme.basicOpen X s = ⊥
[PROOFSTEP]
rintro rfl
[GOAL]
X✝ : Scheme
X : Scheme
inst✝ : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
⊢ Scheme.basicOpen X 0 = ⊥
[PROOFSTEP]
simp
[GOAL]
X : Scheme
h : IsIntegral X
⊢ Nonempty { x // x ∈ ⊤ }
[PROOFSTEP]
simp only [Set.univ_nonempty, Opens.nonempty_coeSort, Opens.coe_top]
[GOAL]
X : Scheme
inst✝ : IsIntegral X
⊢ IsReduced X
[PROOFSTEP]
constructor
[GOAL]
case component_reduced
X : Scheme
inst✝ : IsIntegral X
⊢ autoParam (∀ (U : Opens ↑↑X.toPresheafedSpace), _root_.IsReduced ↑(X.presheaf.obj (op U))) _auto✝
[PROOFSTEP]
intro U
[GOAL]
case component_reduced
X : Scheme
inst✝ : IsIntegral X
U : Opens ↑↑X.toPresheafedSpace
⊢ _root_.IsReduced ↑(X.presheaf.obj (op U))
[PROOFSTEP]
cases' U.1.eq_empty_or_nonempty with h h
[GOAL]
case component_reduced.inl
X : Scheme
inst✝ : IsIntegral X
U : Opens ↑↑X.toPresheafedSpace
h : U.carrier = ∅
⊢ _root_.IsReduced ↑(X.presheaf.obj (op U))
[PROOFSTEP]
have : U = ⊥ := SetLike.ext' h
[GOAL]
case component_reduced.inl
X : Scheme
inst✝ : IsIntegral X
U : Opens ↑↑X.toPresheafedSpace
h : U.carrier = ∅
this : U = ⊥
⊢ _root_.IsReduced ↑(X.presheaf.obj (op U))
[PROOFSTEP]
haveI := CommRingCat.subsingleton_of_isTerminal (X.sheaf.isTerminalOfEqEmpty this)
[GOAL]
case component_reduced.inl
X : Scheme
inst✝ : IsIntegral X
U : Opens ↑↑X.toPresheafedSpace
h : U.carrier = ∅
this✝ : U = ⊥
this : Subsingleton ↑((Scheme.sheaf X).val.obj (op U))
⊢ _root_.IsReduced ↑(X.presheaf.obj (op U))
[PROOFSTEP]
change _root_.IsReduced (X.sheaf.val.obj (op U))
[GOAL]
case component_reduced.inl
X : Scheme
inst✝ : IsIntegral X
U : Opens ↑↑X.toPresheafedSpace
h : U.carrier = ∅
this✝ : U = ⊥
this : Subsingleton ↑((Scheme.sheaf X).val.obj (op U))
⊢ _root_.IsReduced ↑((Scheme.sheaf X).val.obj (op U))
[PROOFSTEP]
infer_instance
[GOAL]
case component_reduced.inr
X : Scheme
inst✝ : IsIntegral X
U : Opens ↑↑X.toPresheafedSpace
h : Set.Nonempty U.carrier
⊢ _root_.IsReduced ↑(X.presheaf.obj (op U))
[PROOFSTEP]
haveI : Nonempty U := by simpa
[GOAL]
X : Scheme
inst✝ : IsIntegral X
U : Opens ↑↑X.toPresheafedSpace
h : Set.Nonempty U.carrier
⊢ Nonempty { x // x ∈ U }
[PROOFSTEP]
simpa
[GOAL]
case component_reduced.inr
X : Scheme
inst✝ : IsIntegral X
U : Opens ↑↑X.toPresheafedSpace
h : Set.Nonempty U.carrier
this : Nonempty { x // x ∈ U }
⊢ _root_.IsReduced ↑(X.presheaf.obj (op U))
[PROOFSTEP]
infer_instance
[GOAL]
X : Scheme
inst✝ : IsIntegral X
⊢ IrreducibleSpace ↑↑X.toPresheafedSpace
[PROOFSTEP]
by_contra H
[GOAL]
X : Scheme
inst✝ : IsIntegral X
H : ¬IrreducibleSpace ↑↑X.toPresheafedSpace
⊢ False
[PROOFSTEP]
replace H : ¬IsPreirreducible (⊤ : Set X.carrier) := fun h =>
  H { toPreirreducibleSpace := ⟨h⟩
      toNonempty := inferInstance }
[GOAL]
X : Scheme
inst✝ : IsIntegral X
H : ¬IsPreirreducible ⊤
⊢ False
[PROOFSTEP]
simp_rw [isPreirreducible_iff_closed_union_closed, not_forall, not_or] at H
[GOAL]
X : Scheme
inst✝ : IsIntegral X
H : ∃ x x_1 h h h, ¬⊤ ⊆ x ∧ ¬⊤ ⊆ x_1
⊢ False
[PROOFSTEP]
rcases H with ⟨S, T, hS, hT, h₁, h₂, h₃⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ¬⊤ ⊆ S
h₃ : ¬⊤ ⊆ T
⊢ False
[PROOFSTEP]
erw [not_forall] at h₂ h₃
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x, ¬(x ∈ ⊤ → x ∈ S)
h₃ : ∃ x, ¬(x ∈ ⊤ → x ∈ T)
⊢ False
[PROOFSTEP]
simp_rw [not_forall] at h₂ h₃
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
⊢ False
[PROOFSTEP]
haveI : Nonempty (⟨Sᶜ, hS.1⟩ : Opens X.carrier) := ⟨⟨_, h₂.choose_spec.choose_spec⟩⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
⊢ False
[PROOFSTEP]
haveI : Nonempty (⟨Tᶜ, hT.1⟩ : Opens X.carrier) := ⟨⟨_, h₃.choose_spec.choose_spec⟩⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
⊢ False
[PROOFSTEP]
haveI : Nonempty (⟨Sᶜ, hS.1⟩ ⊔ ⟨Tᶜ, hT.1⟩ : Opens X.carrier) := ⟨⟨_, Or.inl h₂.choose_spec.choose_spec⟩⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
⊢ False
[PROOFSTEP]
let e : X.presheaf.obj _ ≅ CommRingCat.of _ :=
  (X.sheaf.isProductOfDisjoint ⟨_, hS.1⟩ ⟨_, hT.1⟩ ?_).conePointUniqueUpToIso (CommRingCat.prodFanIsLimit _ _)
[GOAL]
case intro.intro.intro.intro.intro.intro.refine_2
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
e : X.presheaf.obj
    (op ({ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) })) ≅
  CommRingCat.of
    ↑(CommRingCat.prodFan ((Scheme.sheaf X).val.obj (op { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }))
          ((Scheme.sheaf X).val.obj (op { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }))).1 :=
  IsLimit.conePointUniqueUpToIso
    (Sheaf.isProductOfDisjoint (Scheme.sheaf X) { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }
      { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } ?intro.intro.intro.intro.intro.intro.refine_1)
    (CommRingCat.prodFanIsLimit ((Scheme.sheaf X).val.obj (op { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }))
      ((Scheme.sheaf X).val.obj (op { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) })))
⊢ False
case intro.intro.intro.intro.intro.intro.refine_1
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
⊢ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊓ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } = ⊥
[PROOFSTEP]
apply (config := { allowSynthFailures := true }) false_of_nontrivial_of_product_domain
[GOAL]
case inst
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
e : X.presheaf.obj
    (op ({ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) })) ≅
  CommRingCat.of
    ↑(CommRingCat.prodFan ((Scheme.sheaf X).val.obj (op { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }))
          ((Scheme.sheaf X).val.obj (op { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }))).1 :=
  IsLimit.conePointUniqueUpToIso
    (Sheaf.isProductOfDisjoint (Scheme.sheaf X) { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }
      { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } ?intro.intro.intro.intro.intro.intro.refine_1)
    (CommRingCat.prodFanIsLimit ((Scheme.sheaf X).val.obj (op { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }))
      ((Scheme.sheaf X).val.obj (op { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) })))
⊢ IsDomain (?intro.intro.intro.intro.intro.intro.refine_2.R × ?intro.intro.intro.intro.intro.intro.refine_2.S)
[PROOFSTEP]
exact e.symm.commRingCatIsoToRingEquiv.toMulEquiv.isDomain _
[GOAL]
case inst
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
e : X.presheaf.obj
    (op ({ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) })) ≅
  CommRingCat.of
    ↑(CommRingCat.prodFan ((Scheme.sheaf X).val.obj (op { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }))
          ((Scheme.sheaf X).val.obj (op { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }))).1 :=
  IsLimit.conePointUniqueUpToIso
    (Sheaf.isProductOfDisjoint (Scheme.sheaf X) { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }
      { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } ?intro.intro.intro.intro.intro.intro.refine_1)
    (CommRingCat.prodFanIsLimit ((Scheme.sheaf X).val.obj (op { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }))
      ((Scheme.sheaf X).val.obj (op { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) })))
⊢ Nontrivial ↑((Scheme.sheaf X).val.obj (op { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }))
[PROOFSTEP]
apply X.toLocallyRingedSpace.component_nontrivial
[GOAL]
case inst
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
e : X.presheaf.obj
    (op ({ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) })) ≅
  CommRingCat.of
    ↑(CommRingCat.prodFan ((Scheme.sheaf X).val.obj (op { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }))
          ((Scheme.sheaf X).val.obj (op { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }))).1 :=
  IsLimit.conePointUniqueUpToIso
    (Sheaf.isProductOfDisjoint (Scheme.sheaf X) { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }
      { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } ?intro.intro.intro.intro.intro.intro.refine_1)
    (CommRingCat.prodFanIsLimit ((Scheme.sheaf X).val.obj (op { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }))
      ((Scheme.sheaf X).val.obj (op { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) })))
⊢ Nontrivial ↑((Scheme.sheaf X).val.obj (op { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }))
[PROOFSTEP]
apply X.toLocallyRingedSpace.component_nontrivial
[GOAL]
case intro.intro.intro.intro.intro.intro.refine_1
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
⊢ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊓ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } = ⊥
[PROOFSTEP]
ext x
[GOAL]
case intro.intro.intro.intro.intro.intro.refine_1.h.h
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
x : ↑↑X.toPresheafedSpace
⊢ x ∈ ↑({ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊓ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }) ↔ x ∈ ↑⊥
[PROOFSTEP]
constructor
[GOAL]
case intro.intro.intro.intro.intro.intro.refine_1.h.h.mp
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
x : ↑↑X.toPresheafedSpace
⊢ x ∈ ↑({ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊓ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }) → x ∈ ↑⊥
[PROOFSTEP]
rintro ⟨hS, hT⟩
[GOAL]
case intro.intro.intro.intro.intro.intro.refine_1.h.h.mp.intro
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS✝ : IsClosed S
hT✝ : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
x : ↑↑X.toPresheafedSpace
hS : x ∈ ↑{ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }
hT : x ∈ ↑{ carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }
⊢ x ∈ ↑⊥
[PROOFSTEP]
cases' h₁ (show x ∈ ⊤ by trivial) with h h
[GOAL]
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS✝ : IsClosed S
hT✝ : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
x : ↑↑X.toPresheafedSpace
hS : x ∈ ↑{ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }
hT : x ∈ ↑{ carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }
⊢ x ∈ ⊤
[PROOFSTEP]
trivial
[GOAL]
case intro.intro.intro.intro.intro.intro.refine_1.h.h.mp.intro.inl
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS✝ : IsClosed S
hT✝ : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
x : ↑↑X.toPresheafedSpace
hS : x ∈ ↑{ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }
hT : x ∈ ↑{ carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }
h : x ∈ S
⊢ x ∈ ↑⊥
case intro.intro.intro.intro.intro.intro.refine_1.h.h.mp.intro.inr
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS✝ : IsClosed S
hT✝ : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
x : ↑↑X.toPresheafedSpace
hS : x ∈ ↑{ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) }
hT : x ∈ ↑{ carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) }
h : x ∈ T
⊢ x ∈ ↑⊥
[PROOFSTEP]
exacts [hS h, hT h]
[GOAL]
case intro.intro.intro.intro.intro.intro.refine_1.h.h.mpr
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
x : ↑↑X.toPresheafedSpace
⊢ x ∈ ↑⊥ → x ∈ ↑({ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊓ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) })
[PROOFSTEP]
intro x
[GOAL]
case intro.intro.intro.intro.intro.intro.refine_1.h.h.mpr
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
x✝ : ↑↑X.toPresheafedSpace
x : x✝ ∈ ↑⊥
⊢ x✝ ∈ ↑({ carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊓ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) })
[PROOFSTEP]
refine' x.rec (by contradiction)
[GOAL]
X : Scheme
inst✝ : IsIntegral X
S T : Set ↑↑X.toPresheafedSpace
hS : IsClosed S
hT : IsClosed T
h₁ : ⊤ ⊆ S ∪ T
h₂ : ∃ x x_1, ¬x ∈ S
h₃ : ∃ x x_1, ¬x ∈ T
this✝¹ : Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } }
this✝ : Nonempty { x // x ∈ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
this :
  Nonempty { x // x ∈ { carrier := Sᶜ, is_open' := (_ : IsOpen Sᶜ) } ⊔ { carrier := Tᶜ, is_open' := (_ : IsOpen Tᶜ) } }
x✝ : ↑↑X.toPresheafedSpace
x : x✝ ∈ ↑⊥
⊢ False
[PROOFSTEP]
contradiction
[GOAL]
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
⊢ IsIntegral X
[PROOFSTEP]
constructor
[GOAL]
case nonempty
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
⊢ autoParam (Nonempty ↑↑X.toPresheafedSpace) _auto✝
[PROOFSTEP]
infer_instance
[GOAL]
case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
⊢ autoParam (∀ (U : Opens ↑↑X.toPresheafedSpace) [inst : Nonempty { x // x ∈ U }], IsDomain ↑(X.presheaf.obj (op U)))
    _auto✝
[PROOFSTEP]
intro U hU
[GOAL]
case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
⊢ IsDomain ↑(X.presheaf.obj (op U))
[PROOFSTEP]
haveI := (@LocallyRingedSpace.component_nontrivial X.toLocallyRingedSpace U hU).1
[GOAL]
case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
⊢ IsDomain ↑(X.presheaf.obj (op U))
[PROOFSTEP]
have : NoZeroDivisors (X.toLocallyRingedSpace.toSheafedSpace.toPresheafedSpace.presheaf.obj (op U)) :=
  by
  refine' ⟨fun {a b} e => _⟩
  simp_rw [← basicOpen_eq_bot_iff, ← Opens.not_nonempty_iff_eq_bot]
  by_contra' h
  obtain ⟨_, ⟨x, hx₁, rfl⟩, ⟨x, hx₂, e'⟩⟩ := nonempty_preirreducible_inter (X.basicOpen a).2 (X.basicOpen b).2 h.1 h.2
  replace e' := Subtype.eq e'
  subst e'
  replace e := congr_arg (X.presheaf.germ x) e
  rw [RingHom.map_mul, RingHom.map_zero] at e
  refine' zero_ne_one' (X.presheaf.stalk x.1) (isUnit_zero_iff.1 _)
  convert hx₁.mul hx₂
  exact e.symm
[GOAL]
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
⊢ NoZeroDivisors ↑(X.presheaf.obj (op U))
[PROOFSTEP]
refine' ⟨fun {a b} e => _⟩
[GOAL]
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
a b : ↑(X.presheaf.obj (op U))
e : a * b = 0
⊢ a = 0 ∨ b = 0
[PROOFSTEP]
simp_rw [← basicOpen_eq_bot_iff, ← Opens.not_nonempty_iff_eq_bot]
[GOAL]
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
a b : ↑(X.presheaf.obj (op U))
e : a * b = 0
⊢ ¬Set.Nonempty ↑(Scheme.basicOpen X a) ∨ ¬Set.Nonempty ↑(Scheme.basicOpen X b)
[PROOFSTEP]
by_contra' h
[GOAL]
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
a b : ↑(X.presheaf.obj (op U))
e : a * b = 0
h : Set.Nonempty ↑(Scheme.basicOpen X a) ∧ Set.Nonempty ↑(Scheme.basicOpen X b)
⊢ False
[PROOFSTEP]
obtain ⟨_, ⟨x, hx₁, rfl⟩, ⟨x, hx₂, e'⟩⟩ := nonempty_preirreducible_inter (X.basicOpen a).2 (X.basicOpen b).2 h.1 h.2
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
a b : ↑(X.presheaf.obj (op U))
e : a * b = 0
h : Set.Nonempty ↑(Scheme.basicOpen X a) ∧ Set.Nonempty ↑(Scheme.basicOpen X b)
x✝ : { x // x ∈ U }
hx₁ :
  x✝ ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) a)}
x : { x // x ∈ U }
hx₂ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) b)}
e' : ↑x = ↑x✝
⊢ False
[PROOFSTEP]
replace e' := Subtype.eq e'
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
a b : ↑(X.presheaf.obj (op U))
e : a * b = 0
h : Set.Nonempty ↑(Scheme.basicOpen X a) ∧ Set.Nonempty ↑(Scheme.basicOpen X b)
x✝ : { x // x ∈ U }
hx₁ :
  x✝ ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) a)}
x : { x // x ∈ U }
hx₂ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) b)}
e' : x = x✝
⊢ False
[PROOFSTEP]
subst e'
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
a b : ↑(X.presheaf.obj (op U))
e : a * b = 0
h : Set.Nonempty ↑(Scheme.basicOpen X a) ∧ Set.Nonempty ↑(Scheme.basicOpen X b)
x : { x // x ∈ U }
hx₂ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) b)}
hx₁ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) a)}
⊢ False
[PROOFSTEP]
replace e := congr_arg (X.presheaf.germ x) e
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
a b : ↑(X.presheaf.obj (op U))
h : Set.Nonempty ↑(Scheme.basicOpen X a) ∧ Set.Nonempty ↑(Scheme.basicOpen X b)
x : { x // x ∈ U }
hx₂ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) b)}
hx₁ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) a)}
e : ↑(Presheaf.germ X.presheaf x) (a * b) = ↑(Presheaf.germ X.presheaf x) 0
⊢ False
[PROOFSTEP]
rw [RingHom.map_mul, RingHom.map_zero] at e
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
a b : ↑(X.presheaf.obj (op U))
h : Set.Nonempty ↑(Scheme.basicOpen X a) ∧ Set.Nonempty ↑(Scheme.basicOpen X b)
x : { x // x ∈ U }
hx₂ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) b)}
hx₁ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) a)}
e : ↑(Presheaf.germ X.presheaf x) a * ↑(Presheaf.germ X.presheaf x) b = 0
⊢ False
[PROOFSTEP]
refine' zero_ne_one' (X.presheaf.stalk x.1) (isUnit_zero_iff.1 _)
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
a b : ↑(X.presheaf.obj (op U))
h : Set.Nonempty ↑(Scheme.basicOpen X a) ∧ Set.Nonempty ↑(Scheme.basicOpen X b)
x : { x // x ∈ U }
hx₂ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) b)}
hx₁ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) a)}
e : ↑(Presheaf.germ X.presheaf x) a * ↑(Presheaf.germ X.presheaf x) b = 0
⊢ IsUnit 0
[PROOFSTEP]
convert hx₁.mul hx₂
[GOAL]
case h.e'_3.h
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : ∃ x y, x ≠ y
a b : ↑(X.presheaf.obj (op U))
h : Set.Nonempty ↑(Scheme.basicOpen X a) ∧ Set.Nonempty ↑(Scheme.basicOpen X b)
x : { x // x ∈ U }
hx₂ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) b)}
hx₁ :
  x ∈
    {x |
      IsUnit
        (↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) a)}
e : ↑(Presheaf.germ X.presheaf x) a * ↑(Presheaf.germ X.presheaf x) b = 0
e_1✝ :
  ↑(Presheaf.stalk X.presheaf ↑x) =
    (fun x_1 =>
        (forget CommRingCat).obj
          (Presheaf.stalk (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf ↑x))
      a
⊢ 0 =
    ↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) a *
      ↑(Presheaf.germ (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf x) b
[PROOFSTEP]
exact e.symm
[GOAL]
case component_integral
X : Scheme
inst✝ : IsReduced X
H : IrreducibleSpace ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this✝ : ∃ x y, x ≠ y
this : NoZeroDivisors ↑(X.presheaf.obj (op U))
⊢ IsDomain ↑(X.presheaf.obj (op U))
[PROOFSTEP]
exact NoZeroDivisors.to_isDomain _
[GOAL]
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
⊢ IsIntegral X
[PROOFSTEP]
constructor
[GOAL]
case nonempty
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
⊢ autoParam (Nonempty ↑↑X.toPresheafedSpace) _auto✝
[PROOFSTEP]
infer_instance
[GOAL]
case component_integral
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
⊢ autoParam (∀ (U : Opens ↑↑X.toPresheafedSpace) [inst : Nonempty { x // x ∈ U }], IsDomain ↑(X.presheaf.obj (op U)))
    _auto✝
[PROOFSTEP]
intro U hU
[GOAL]
case component_integral
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
⊢ IsDomain ↑(X.presheaf.obj (op U))
[PROOFSTEP]
have : U = (Opens.map f.1.base).obj (H.base_open.isOpenMap.functor.obj U) := by ext1;
  exact (Set.preimage_image_eq _ H.base_open.inj).symm
[GOAL]
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
⊢ U = (Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)
[PROOFSTEP]
ext1
[GOAL]
case h
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
⊢ ↑U = ↑((Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U))
[PROOFSTEP]
exact (Set.preimage_image_eq _ H.base_open.inj).symm
[GOAL]
case component_integral
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : U = (Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)
⊢ IsDomain ↑(X.presheaf.obj (op U))
[PROOFSTEP]
rw [this]
[GOAL]
case component_integral
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : U = (Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)
⊢ IsDomain ↑(X.presheaf.obj (op ((Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U))))
[PROOFSTEP]
have : IsDomain (Y.presheaf.obj (op (H.base_open.isOpenMap.functor.obj U))) :=
  by
  apply (config := { allowSynthFailures := true }) IsIntegral.component_integral
  refine' ⟨⟨_, _, hU.some.prop, rfl⟩⟩
[GOAL]
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : U = (Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)
⊢ IsDomain ↑(Y.presheaf.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)))
[PROOFSTEP]
apply (config := { allowSynthFailures := true }) IsIntegral.component_integral
[GOAL]
case inst
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this : U = (Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)
⊢ Nonempty { x // x ∈ (IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U }
[PROOFSTEP]
refine' ⟨⟨_, _, hU.some.prop, rfl⟩⟩
[GOAL]
case component_integral
X✝ : Scheme
X Y : Scheme
f : X ⟶ Y
H : IsOpenImmersion f
inst✝¹ : IsIntegral Y
inst✝ : Nonempty ↑↑X.toPresheafedSpace
U : Opens ↑↑X.toPresheafedSpace
hU : Nonempty { x // x ∈ U }
this✝ : U = (Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)
this : IsDomain ↑(Y.presheaf.obj (op ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U)))
⊢ IsDomain ↑(X.presheaf.obj (op ((Opens.map f.val.base).obj ((IsOpenMap.functor (_ : IsOpenMap ↑f.val.base)).obj U))))
[PROOFSTEP]
exact
  (asIso <| f.1.c.app (op <| H.base_open.isOpenMap.functor.obj U) :
        Y.presheaf.obj _ ≅ _).symm.commRingCatIsoToRingEquiv.toMulEquiv.isDomain
    _
[GOAL]
X : Scheme
R : CommRingCat
H : IsDomain ↑R
⊢ IrreducibleSpace ↑↑(Scheme.Spec.obj (op R)).toPresheafedSpace
[PROOFSTEP]
convert PrimeSpectrum.irreducibleSpace (R := R)
[GOAL]
X : Scheme
inst✝¹ : IsAffine X
inst✝ : Nonempty ↑↑X.toPresheafedSpace
h : IsDomain ↑(X.presheaf.obj (op ⊤))
⊢ IsIntegral (Scheme.Spec.obj (op (Scheme.Γ.obj (op X))))
[PROOFSTEP]
rw [affine_isIntegral_iff]
[GOAL]
X : Scheme
inst✝¹ : IsAffine X
inst✝ : Nonempty ↑↑X.toPresheafedSpace
h : IsDomain ↑(X.presheaf.obj (op ⊤))
⊢ IsDomain ↑(Scheme.Γ.obj (op X))
[PROOFSTEP]
exact h
[GOAL]
X : Scheme
inst✝ : IsIntegral X
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
H : Nonempty { x // x ∈ U }
⊢ Function.Injective ↑(X.presheaf.map i.op)
[PROOFSTEP]
rw [injective_iff_map_eq_zero]
[GOAL]
X : Scheme
inst✝ : IsIntegral X
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
H : Nonempty { x // x ∈ U }
⊢ ∀ (a : (forget CommRingCat).obj (X.presheaf.obj (op V))), ↑(X.presheaf.map i.op) a = 0 → a = 0
[PROOFSTEP]
intro x hx
[GOAL]
X : Scheme
inst✝ : IsIntegral X
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
H : Nonempty { x // x ∈ U }
x : (forget CommRingCat).obj (X.presheaf.obj (op V))
hx : ↑(X.presheaf.map i.op) x = 0
⊢ x = 0
[PROOFSTEP]
rw [← basicOpen_eq_bot_iff] at hx ⊢
[GOAL]
X : Scheme
inst✝ : IsIntegral X
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
H : Nonempty { x // x ∈ U }
x : (forget CommRingCat).obj (X.presheaf.obj (op V))
hx : Scheme.basicOpen X (↑(X.presheaf.map i.op) x) = ⊥
⊢ Scheme.basicOpen X x = ⊥
[PROOFSTEP]
rw [Scheme.basicOpen_res] at hx
[GOAL]
X : Scheme
inst✝ : IsIntegral X
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
H : Nonempty { x // x ∈ U }
x : (forget CommRingCat).obj (X.presheaf.obj (op V))
hx : U ⊓ Scheme.basicOpen X x = ⊥
⊢ Scheme.basicOpen X x = ⊥
[PROOFSTEP]
revert hx
[GOAL]
X : Scheme
inst✝ : IsIntegral X
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
H : Nonempty { x // x ∈ U }
x : (forget CommRingCat).obj (X.presheaf.obj (op V))
⊢ U ⊓ Scheme.basicOpen X x = ⊥ → Scheme.basicOpen X x = ⊥
[PROOFSTEP]
contrapose!
[GOAL]
X : Scheme
inst✝ : IsIntegral X
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
H : Nonempty { x // x ∈ U }
x : (forget CommRingCat).obj (X.presheaf.obj (op V))
⊢ Scheme.basicOpen X x ≠ ⊥ → U ⊓ Scheme.basicOpen X x ≠ ⊥
[PROOFSTEP]
simp_rw [Ne.def, ← Opens.not_nonempty_iff_eq_bot, Classical.not_not]
[GOAL]
X : Scheme
inst✝ : IsIntegral X
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
H : Nonempty { x // x ∈ U }
x : (forget CommRingCat).obj (X.presheaf.obj (op V))
⊢ Set.Nonempty ↑(Scheme.basicOpen X x) → Set.Nonempty ↑(U ⊓ Scheme.basicOpen X x)
[PROOFSTEP]
apply nonempty_preirreducible_inter U.isOpen (RingedSpace.basicOpen _ _).isOpen
[GOAL]
X : Scheme
inst✝ : IsIntegral X
U V : Opens ↑↑X.toPresheafedSpace
i : U ⟶ V
H : Nonempty { x // x ∈ U }
x : (forget CommRingCat).obj (X.presheaf.obj (op V))
⊢ Set.Nonempty ↑U
[PROOFSTEP]
simpa using H


[GOAL]
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
⊢ LieRing L
[PROOFSTEP]
infer_instance
[GOAL]
R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
⊢ LieAlgebra R L
[PROOFSTEP]
infer_instance


[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
⊢ Category.{?u.2036, u₁} (Skeleton C)
[PROOFSTEP]
apply InducedCategory.category
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
⊢ Full (fromSkeleton C)
[PROOFSTEP]
apply InducedCategory.full
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
⊢ Faithful (fromSkeleton C)
[PROOFSTEP]
apply InducedCategory.faithful
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
⊢ Skeletal (Skeleton C)
[PROOFSTEP]
rintro X Y ⟨h⟩
[GOAL]
case intro
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
X Y : Skeleton C
h : X ≅ Y
⊢ X = Y
[PROOFSTEP]
have : X.out ≈ Y.out := ⟨(fromSkeleton C).mapIso h⟩
[GOAL]
case intro
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
X Y : Skeleton C
h : X ≅ Y
this : Quotient.out X ≈ Quotient.out Y
⊢ X = Y
[PROOFSTEP]
simpa using Quotient.sound this
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
⊢ ∀ (a₁ b₁ a₂ b₂ : C), a₁ ≈ a₂ → b₁ ≈ b₂ → (fun X Y => Nonempty (X ⟶ Y)) a₁ b₁ = (fun X Y => Nonempty (X ⟶ Y)) a₂ b₂
[PROOFSTEP]
rintro _ _ _ _ ⟨i₁⟩ ⟨i₂⟩
[GOAL]
case intro.intro
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
a₁✝ b₁✝ a₂✝ b₂✝ : C
i₁ : a₁✝ ≅ a₂✝
i₂ : b₁✝ ≅ b₂✝
⊢ (fun X Y => Nonempty (X ⟶ Y)) a₁✝ b₁✝ = (fun X Y => Nonempty (X ⟶ Y)) a₂✝ b₂✝
[PROOFSTEP]
exact propext ⟨Nonempty.map fun f => i₁.inv ≫ f ≫ i₂.hom, Nonempty.map fun f => i₁.hom ≫ f ≫ i₂.inv⟩
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
⊢ ∀ (a : ThinSkeleton C), a ≤ a
[PROOFSTEP]
refine' Quotient.ind fun a => _
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
a : C
⊢ Quotient.mk (isIsomorphicSetoid C) a ≤ Quotient.mk (isIsomorphicSetoid C) a
[PROOFSTEP]
exact ⟨𝟙 _⟩
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
x✝¹ x✝ : ThinSkeleton C
⊢ ∀ (a b : x✝¹ ⟶ x✝), a = b
[PROOFSTEP]
rintro ⟨⟨f₁⟩⟩ ⟨⟨_⟩⟩
[GOAL]
case up.up.up.up
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
x✝¹ x✝ : ThinSkeleton C
f₁ down✝ : x✝¹ ≤ x✝
⊢ { down := { down := f₁ } } = { down := { down := down✝ } }
[PROOFSTEP]
rfl
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : Quiver.IsThin C
src✝ : Preorder (ThinSkeleton C) := preorder C
⊢ ∀ (a b : C),
    Quotient.mk (isIsomorphicSetoid C) a ≤ Quotient.mk (isIsomorphicSetoid C) b →
      Quotient.mk (isIsomorphicSetoid C) b ≤ Quotient.mk (isIsomorphicSetoid C) a →
        Quotient.mk (isIsomorphicSetoid C) a = Quotient.mk (isIsomorphicSetoid C) b
[PROOFSTEP]
rintro _ _ ⟨f⟩ ⟨g⟩
[GOAL]
case intro.intro
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
E : Type u₃
inst✝¹ : Category.{v₃, u₃} E
inst✝ : Quiver.IsThin C
src✝ : Preorder (ThinSkeleton C) := preorder C
a✝ b✝ : C
f : a✝ ⟶ b✝
g : b✝ ⟶ a✝
⊢ Quotient.mk (isIsomorphicSetoid C) a✝ = Quotient.mk (isIsomorphicSetoid C) b✝
[PROOFSTEP]
apply Quotient.sound (equiv_of_both_ways f g)
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
R : D ⥤ C
L : C ⥤ D
h : L ⊣ R
X : ThinSkeleton C
⊢ (𝟭 (ThinSkeleton C)).obj X ⟶ (map L ⋙ map R).obj X
[PROOFSTEP]
letI := isIsomorphicSetoid C
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
R : D ⥤ C
L : C ⥤ D
h : L ⊣ R
X : ThinSkeleton C
this : Setoid C := isIsomorphicSetoid C
⊢ (𝟭 (ThinSkeleton C)).obj X ⟶ (map L ⋙ map R).obj X
[PROOFSTEP]
refine' Quotient.recOnSubsingleton X fun x => homOfLE ⟨h.unit.app x⟩
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
R : D ⥤ C
L : C ⥤ D
h : L ⊣ R
X : ThinSkeleton D
⊢ (map R ⋙ map L).obj X ⟶ (𝟭 (ThinSkeleton D)).obj X
[PROOFSTEP]
letI := isIsomorphicSetoid D
[GOAL]
C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
R : D ⥤ C
L : C ⥤ D
h : L ⊣ R
X : ThinSkeleton D
this : Setoid D := isIsomorphicSetoid D
⊢ (map R ⋙ map L).obj X ⟶ (𝟭 (ThinSkeleton D)).obj X
[PROOFSTEP]
refine' Quotient.recOnSubsingleton X fun x => homOfLE ⟨h.counit.app x⟩