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

tactic: apply TopCat.Presheaf.section_ext X.sheaf U
state_before: X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
⊢ s = 0
state_after: case h
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
⊢ ∀ (x : ↥U), (X.sheaf.presheaf.germ x) s = (X.sheaf.presheaf.germ x) 0

tactic: intro x
state_before: case h
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
⊢ ∀ (x : ↥U), (X.sheaf.presheaf.germ x) s = (X.sheaf.presheaf.germ x) 0
state_after: case h
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
⊢ (X.sheaf.presheaf.germ x) s = (X.sheaf.presheaf.germ x) 0

tactic: rw [RingHom.map_zero]
state_before: case h
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
⊢ (X.sheaf.presheaf.germ x) s = (X.sheaf.presheaf.germ x) 0
state_after: case h
X✝ : Scheme
X : Scheme
hX : IsReduced X
U : Opens ↑↑X.toPresheafedSpace
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
⊢ (X.sheaf.presheaf.germ x) s = 0

tactic: obtain ⟨V, hx, i, H⟩ := hx x
state_before: case h.h₁
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
⊢ (X.sheaf.presheaf.germ x) s = 0
state_after: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
⊢ (X.sheaf.presheaf.germ x) s = 0

tactic: specialize H (X.presheaf.map i.op s)
state_before: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
⊢ (X.sheaf.presheaf.germ x) s = 0
state_after: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : X.basicOpen ((X.presheaf.map i.op) s) = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) ((X.presheaf.map i.op) s) = 0
⊢ (X.sheaf.presheaf.germ x) s = 0

tactic: erw [Scheme.basicOpen_res] at H
state_before: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : X.basicOpen ((X.presheaf.map i.op) s) = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) ((X.presheaf.map i.op) s) = 0
⊢ (X.sheaf.presheaf.germ x) s = 0
state_after: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : V ⊓ X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) ((X.presheaf.map i.op) s) = 0
⊢ (X.sheaf.presheaf.germ x) s = 0

tactic: rw [hs] at H
state_before: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : V ⊓ X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) ((X.presheaf.map i.op) s) = 0
⊢ (X.sheaf.presheaf.germ x) s = 0
state_after: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : V ⊓ ⊥ = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) ((X.presheaf.map i.op) s) = 0
⊢ (X.sheaf.presheaf.germ x) s = 0

tactic: specialize H (inf_bot_eq _) ⟨x, hx⟩
state_before: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : V ⊓ ⊥ = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) ((X.presheaf.map i.op) s) = 0
⊢ (X.sheaf.presheaf.germ x) s = 0
state_after: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : (X.sheaf.presheaf.germ ⟨↑x, hx⟩) ((X.presheaf.map i.op) s) = 0
⊢ (X.sheaf.presheaf.germ x) s = 0

tactic: erw [TopCat.Presheaf.germ_res_apply] at H
state_before: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : (X.sheaf.presheaf.germ ⟨↑x, hx⟩) ((X.presheaf.map i.op) s) = 0
⊢ (X.sheaf.presheaf.germ x) s = 0
state_after: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : (X.sheaf.presheaf.germ ((fun x => ⟨↑x, ⋯⟩) ⟨↑x, hx⟩)) s = 0
⊢ (X.sheaf.presheaf.germ x) s = 0

tactic: exact H
state_before: case h.h₁.intro.intro.intro
X✝¹ : Scheme
X✝ X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hx✝ :
  ∀ (x : ↥U),
    ∃ V,
      ∃ (_ : ↑x ∈ V),
        ∃ x, ∀ [hX : IsReduced X] (s : ↑Γ(X, V)), X.basicOpen s = ⊥ → ∀ (x : ↥V), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced X
s : ↑Γ(X, U)
hs : X.basicOpen s = ⊥
x : ↥U
V : Opens ↑↑X.toPresheafedSpace
hx : ↑x ∈ V
i : V ⟶ U
H : (X.sheaf.presheaf.germ ((fun x => ⟨↑x, ⋯⟩) ⟨↑x, hx⟩)) s = 0
⊢ (X.sheaf.presheaf.germ x) s = 0
state_after: no goals

tactic: have e : f.val.base ⁻¹' Set.range ↑f.val.base = Set.univ := by
  rw [← Set.image_univ, Set.preimage_image_eq _ ‹IsOpenImmersion f›.base_open.inj]
state_before: case h.h₂
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
⊢ ∃ U V,
    ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
      (∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := U, is_open' := ⋯ })),
          X.basicOpen s = ⊥ → ∀ (x : ↥{ carrier := U, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0) →
        ∀ [hX : IsReduced Y] (s : ↑Γ(Y, { carrier := V, is_open' := ⋯ })),
          Y.basicOpen s = ⊥ → ∀ (x : ↥{ carrier := V, is_open' := ⋯ }), (Y.sheaf.presheaf.germ x) s = 0
state_after: case h.h₂
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
⊢ ∃ U V,
    ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
      (∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := U, is_open' := ⋯ })),
          X.basicOpen s = ⊥ → ∀ (x : ↥{ carrier := U, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0) →
        ∀ [hX : IsReduced Y] (s : ↑Γ(Y, { carrier := V, is_open' := ⋯ })),
          Y.basicOpen s = ⊥ → ∀ (x : ↥{ carrier := V, is_open' := ⋯ }), (Y.sheaf.presheaf.germ x) s = 0

tactic: refine ⟨_, _, e, rfl, ?_⟩
state_before: case h.h₂
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
⊢ ∃ U V,
    ∃ (hU : U = ⊤) (hV : V = Set.range ⇑f.val.base),
      (∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := U, is_open' := ⋯ })),
          X.basicOpen s = ⊥ → ∀ (x : ↥{ carrier := U, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0) →
        ∀ [hX : IsReduced Y] (s : ↑Γ(Y, { carrier := V, is_open' := ⋯ })),
          Y.basicOpen s = ⊥ → ∀ (x : ↥{ carrier := V, is_open' := ⋯ }), (Y.sheaf.presheaf.germ x) s = 0
state_after: case h.h₂
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
⊢ (∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
      X.basicOpen s = ⊥ →
        ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0) →
    ∀ [hX : IsReduced Y] (s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })),
      Y.basicOpen s = ⊥ → ∀ (x : ↥{ carrier := Set.range ⇑f.val.base, is_open' := ⋯ }), (Y.sheaf.presheaf.germ x) s = 0

tactic: rintro H hX s hs ⟨_, x, rfl⟩
state_before: case h.h₂
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
⊢ (∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
      X.basicOpen s = ⊥ →
        ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0) →
    ∀ [hX : IsReduced Y] (s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })),
      Y.basicOpen s = ⊥ → ∀ (x : ↥{ carrier := Set.range ⇑f.val.base, is_open' := ⋯ }), (Y.sheaf.presheaf.germ x) s = 0
state_after: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0

tactic: haveI := isReduced_of_isOpenImmersion f
state_before: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0
state_after: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0

tactic: specialize H (f.app _ s) _ ⟨x, by rw [Opens.mem_mk, e]; trivial⟩
state_before: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0
state_after: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ X.basicOpen ((Scheme.Hom.app f { carrier := Set.range ⇑f.val.base, is_open' := ⋯ }) s) = ⊥

case h.h₂.mk.intro
X✝¹ : Scheme
X✝ 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, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
H : (X.sheaf.presheaf.germ ⟨x, ⋯⟩) ((Scheme.Hom.app f { carrier := Set.range ⇑f.val.base, is_open' := ⋯ }) s) = 0
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0

tactic: rw [← Set.image_univ, Set.preimage_image_eq _ ‹IsOpenImmersion f›.base_open.inj]
state_before: X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
⊢ ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
state_after: no goals

tactic: rw [Opens.mem_mk, e]
state_before: X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ x ∈ { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }
state_after: X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ x ∈ Set.univ

tactic: trivial
state_before: X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ x ∈ Set.univ
state_after: no goals

tactic: rw [← Scheme.preimage_basicOpen, hs]
state_before: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ X.basicOpen ((Scheme.Hom.app f { carrier := Set.range ⇑f.val.base, is_open' := ⋯ }) s) = ⊥
state_after: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ f ⁻¹ᵁ ⊥ = ⊥

tactic: ext1
state_before: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ f ⁻¹ᵁ ⊥ = ⊥
state_after: case h.h₂.mk.intro.h
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ ↑(f ⁻¹ᵁ ⊥) = ↑⊥

tactic: simp [Opens.map]
state_before: case h.h₂.mk.intro.h
X✝¹ : Scheme
X✝ X Y : Scheme
f : X ⟶ Y
hf✝ : IsOpenImmersion f
e : ⇑f.val.base ⁻¹' Set.range ⇑f.val.base = Set.univ
H :
  ∀ [hX : IsReduced X] (s : ↑Γ(X, { carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ })),
    X.basicOpen s = ⊥ →
      ∀ (x : ↥{ carrier := ⇑f.val.base ⁻¹' Set.range ⇑f.val.base, is_open' := ⋯ }), (X.sheaf.presheaf.germ x) s = 0
hX : IsReduced Y
s : ↑Γ(Y, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
⊢ ↑(f ⁻¹ᵁ ⊥) = ↑⊥
state_after: no goals

tactic: erw [← PresheafedSpace.stalkMap_germ_apply f.1 ⟨_, _⟩ ⟨x, _⟩] at H
state_before: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ 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, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
H : (X.sheaf.presheaf.germ ⟨x, ⋯⟩) ((Scheme.Hom.app f { carrier := Set.range ⇑f.val.base, is_open' := ⋯ }) s) = 0
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0
state_after: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ 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, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
H : (PresheafedSpace.stalkMap f.val ↑⟨x, ⋯⟩) ((Y.presheaf.germ ⟨f.val.base ↑⟨x, ⋯⟩, ⋯⟩) s) = 0
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0

tactic: apply_fun inv <| PresheafedSpace.stalkMap f.val x at H
state_before: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ 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, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
H : (PresheafedSpace.stalkMap f.val ↑⟨x, ⋯⟩) ((Y.presheaf.germ ⟨f.val.base ↑⟨x, ⋯⟩, ⋯⟩) s) = 0
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0
state_after: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ 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, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
H :
  (inv (PresheafedSpace.stalkMap f.val x))
      ((PresheafedSpace.stalkMap f.val ↑⟨x, ⋯⟩) ((Y.presheaf.germ ⟨f.val.base ↑⟨x, ⋯⟩, ⋯⟩) s)) =
    (inv (PresheafedSpace.stalkMap f.val x)) 0
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0

tactic: erw [CategoryTheory.IsIso.hom_inv_id_apply, map_zero] at H
state_before: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ 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, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
H :
  (inv (PresheafedSpace.stalkMap f.val x))
      ((PresheafedSpace.stalkMap f.val ↑⟨x, ⋯⟩) ((Y.presheaf.germ ⟨f.val.base ↑⟨x, ⋯⟩, ⋯⟩) s)) =
    (inv (PresheafedSpace.stalkMap f.val x)) 0
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0
state_after: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ 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, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
H : (Y.presheaf.germ ⟨f.val.base ↑⟨x, ⋯⟩, ⋯⟩) s = 0
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0

tactic: exact H
state_before: case h.h₂.mk.intro
X✝¹ : Scheme
X✝ 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, { carrier := Set.range ⇑f.val.base, is_open' := ⋯ })
hs : Y.basicOpen s = ⊥
x : ↑↑X.toPresheafedSpace
this : IsReduced X
H : (Y.presheaf.germ ⟨f.val.base ↑⟨x, ⋯⟩, ⋯⟩) s = 0
⊢ (Y.sheaf.presheaf.germ ⟨f.val.base x, ⋯⟩) s = 0
state_after: no goals

tactic: rw [basicOpen_eq_of_affine', PrimeSpectrum.basicOpen_eq_bot_iff] at hs
state_before: case h.h₃
X✝ : Scheme
X : Scheme
R : CommRingCat
hX : IsReduced (Spec R)
s : ↑Γ(Spec R, ⊤)
hs : (Spec R).basicOpen s = ⊥
x : ↥⊤
⊢ ((Spec R).sheaf.presheaf.germ x) s = 0
state_after: case h.h₃
X✝ : Scheme
X : Scheme
R : CommRingCat
hX : IsReduced (Spec R)
s : ↑Γ(Spec R, ⊤)
hs : IsNilpotent ((Scheme.ΓSpecIso R).hom s)
x : ↥⊤
⊢ ((Spec R).sheaf.presheaf.germ x) s = 0

tactic: replace hs := (hs.map (Scheme.ΓSpecIso R).inv).eq_zero
state_before: case h.h₃
X✝ : Scheme
X : Scheme
R : CommRingCat
hX : IsReduced (Spec R)
s : ↑Γ(Spec R, ⊤)
hs : IsNilpotent ((Scheme.ΓSpecIso R).hom s)
x : ↥⊤
⊢ ((Spec R).sheaf.presheaf.germ x) s = 0
state_after: case h.h₃
X✝ : Scheme
X : Scheme
R : CommRingCat
hX : IsReduced (Spec R)
s : ↑Γ(Spec R, ⊤)
x : ↥⊤
hs : (Scheme.ΓSpecIso R).inv ((Scheme.ΓSpecIso R).hom s) = 0
⊢ ((Spec R).sheaf.presheaf.germ x) s = 0

tactic: rw [Iso.hom_inv_id_apply] at hs
state_before: case h.h₃
X✝ : Scheme
X : Scheme
R : CommRingCat
hX : IsReduced (Spec R)
s : ↑Γ(Spec R, ⊤)
x : ↥⊤
hs : (Scheme.ΓSpecIso R).inv ((Scheme.ΓSpecIso R).hom s) = 0
⊢ ((Spec R).sheaf.presheaf.germ x) s = 0
state_after: case h.h₃
X✝ : Scheme
X : Scheme
R : CommRingCat
hX : IsReduced (Spec R)
s : ↑Γ(Spec R, ⊤)
x : ↥⊤
hs : s = 0
⊢ ((Spec R).sheaf.presheaf.germ x) s = 0

tactic: rw [hs, map_zero]
state_before: case h.h₃
X✝ : Scheme
X : Scheme
R : CommRingCat
hX : IsReduced (Spec R)
s : ↑Γ(Spec R, ⊤)
x : ↥⊤
hs : s = 0
⊢ ((Spec R).sheaf.presheaf.germ x) s = 0
state_after: no goals