Theorem: AlgebraicGeometry.exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isCompact
File: Mathlib/AlgebraicGeometry/Morphisms/QuasiCompact.lean

tactic: obtain ⟨s, hs, e⟩ := (isCompactOpen_iff_eq_finset_affine_union U.1).mp ⟨hU, U.2⟩
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
⊢ ∃ n, f ^ n * x = 0
state_after: case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U.carrier = ⋃ i ∈ s, ↑↑i
⊢ ∃ n, f ^ n * x = 0

tactic: replace e : U = iSup fun i : s => (i : Opens X) := by
  ext1; simpa using e
state_before: case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U.carrier = ⋃ i ∈ s, ↑↑i
⊢ ∃ n, f ^ n * x = 0
state_after: case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
⊢ ∃ n, f ^ n * x = 0

tactic: have h₁ : ∀ i : s, i.1.1 ≤ U := by
  intro i
  change (i : Opens X) ≤ U
  rw [e]
  exact le_iSup (fun (i : s) => (i : Opens (X.toPresheafedSpace))) _
state_before: case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
⊢ ∃ n, f ^ n * x = 0
state_after: case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
⊢ ∃ n, f ^ n * x = 0

tactic: have H' := fun i : s =>
  exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isAffineOpen X i.1.2
    (X.presheaf.map (homOfLE (h₁ i)).op x) (X.presheaf.map (homOfLE (h₁ i)).op f) ?_
state_before: case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
⊢ ∃ n, f ^ n * x = 0
state_after: case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
H' : ∀ (i : ↑s), ∃ n, (X.presheaf.map (homOfLE ⋯).op) f ^ n * (X.presheaf.map (homOfLE ⋯).op) x = 0
⊢ ∃ n, f ^ n * x = 0

case intro.intro.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ ((X.presheaf.map (homOfLE ⋯).op) x |_ X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) f)) ⋯ = 0

tactic: swap
state_before: case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
H' : ∀ (i : ↑s), ∃ n, (X.presheaf.map (homOfLE ⋯).op) f ^ n * (X.presheaf.map (homOfLE ⋯).op) x = 0
⊢ ∃ n, f ^ n * x = 0

case intro.intro.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ ((X.presheaf.map (homOfLE ⋯).op) x |_ X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) f)) ⋯ = 0
state_after: case intro.intro.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ ((X.presheaf.map (homOfLE ⋯).op) x |_ X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) f)) ⋯ = 0

case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
H' : ∀ (i : ↑s), ∃ n, (X.presheaf.map (homOfLE ⋯).op) f ^ n * (X.presheaf.map (homOfLE ⋯).op) x = 0
⊢ ∃ n, f ^ n * x = 0

tactic: choose n hn using H'
state_before: case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
H' : ∀ (i : ↑s), ∃ n, (X.presheaf.map (homOfLE ⋯).op) f ^ n * (X.presheaf.map (homOfLE ⋯).op) x = 0
⊢ ∃ n, f ^ n * x = 0
state_after: case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
⊢ ∃ n, f ^ n * x = 0

tactic: haveI := hs.to_subtype
state_before: case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
⊢ ∃ n, f ^ n * x = 0
state_after: case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : Finite ↑s
⊢ ∃ n, f ^ n * x = 0

tactic: cases nonempty_fintype s
state_before: case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : Finite ↑s
⊢ ∃ n, f ^ n * x = 0
state_after: case intro.intro.refine_2.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
⊢ ∃ n, f ^ n * x = 0

tactic: use Finset.univ.sup n
state_before: case intro.intro.refine_2.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
⊢ ∃ n, f ^ n * x = 0
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
⊢ f ^ Finset.univ.sup n * x = 0

tactic: suffices ∀ i : s, X.presheaf.map (homOfLE (h₁ i)).op (f ^ Finset.univ.sup n * x) = 0 by
  subst e
  apply TopCat.Sheaf.eq_of_locally_eq X.sheaf fun i : s => (i : Opens X)
  intro i
  rw [map_zero]
  apply this
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
⊢ f ^ Finset.univ.sup n * x = 0
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
⊢ ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0

tactic: intro i
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
⊢ ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0

tactic: replace hn :=
  congr_arg (fun x => X.presheaf.map (homOfLE (h₁ i)).op (f ^ (Finset.univ.sup n - n i)) * x)
    (hn i)
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn :
  (fun x => (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i)) * x)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x) =
    (fun x => (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i)) * x) 0
⊢ (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0

tactic: dsimp at hn
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn :
  (fun x => (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i)) * x)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x) =
    (fun x => (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i)) * x) 0
⊢ (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn :
  (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i)) *
      ((X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i)) * 0
⊢ (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0

tactic: simp only [← map_mul, ← map_pow] at hn
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn :
  (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i)) *
      ((X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i)) * 0
⊢ (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn :
  (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i) * (f ^ n i * x)) =
    (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i)) * 0
⊢ (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0

tactic: rwa [mul_zero, ← mul_assoc, ← pow_add, tsub_add_cancel_of_le] at hn
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn :
  (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i) * (f ^ n i * x)) =
    (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i)) * 0
⊢ (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn : (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i + n i) * x) = 0
⊢ n i ≤ Finset.univ.sup n

tactic: apply Finset.le_sup (Finset.mem_univ i)
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn : (X.presheaf.map (homOfLE ⋯).op) (f ^ (Finset.univ.sup n - n i + n i) * x) = 0
⊢ n i ≤ Finset.univ.sup n
state_after: no goals

tactic: ext1
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U.carrier = ⋃ i ∈ s, ↑↑i
⊢ U = ⨆ i, ↑↑i
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U.carrier = ⋃ i ∈ s, ↑↑i
⊢ ↑U = ↑(⨆ i, ↑↑i)

tactic: simpa using e
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U.carrier = ⋃ i ∈ s, ↑↑i
⊢ ↑U = ↑(⨆ i, ↑↑i)
state_after: no goals

tactic: intro i
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
⊢ ∀ (i : ↑s), ↑↑i ≤ U
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
i : ↑s
⊢ ↑↑i ≤ U

tactic: rw [e]
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
i : ↑s
⊢ ↑↑i ≤ U
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
i : ↑s
⊢ ↑↑i ≤ ⨆ i, ↑↑i

tactic: exact le_iSup (fun (i : s) => (i : Opens (X.toPresheafedSpace))) _
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
i : ↑s
⊢ ↑↑i ≤ ⨆ i, ↑↑i
state_after: no goals

tactic: delta TopCat.Presheaf.restrictOpen TopCat.Presheaf.restrict at H ⊢
state_before: case intro.intro.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ ((X.presheaf.map (homOfLE ⋯).op) x |_ X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) f)) ⋯ = 0
state_after: case intro.intro.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) x) = 0

tactic: convert congr_arg (X.presheaf.map (homOfLE _).op) H
state_before: case intro.intro.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) x) = 0
state_after: case h.e'_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ?intro.intro.refine_1.convert_1).op) ((X.presheaf.map (homOfLE ⋯).op) x)

case h.e'_3
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ 0 = (X.presheaf.map (homOfLE ?intro.intro.refine_1.convert_1).op) 0

case intro.intro.refine_1.convert_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) f) ≤ X.basicOpen f

tactic: rw [← comp_apply, ← comp_apply]
state_before: case h.e'_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ?intro.intro.refine_1.convert_1).op) ((X.presheaf.map (homOfLE ⋯).op) x)
state_after: case h.e'_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) x =
    (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ?intro.intro.refine_1.convert_1).op) x

tactic: simp only [← Functor.map_comp]
state_before: case h.e'_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) x =
    (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ?intro.intro.refine_1.convert_1).op) x
state_after: case h.e'_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ (X.presheaf.map ((homOfLE ⋯).op ≫ (homOfLE ⋯).op)) x =
    (X.presheaf.map ((homOfLE ⋯).op ≫ (homOfLE ?intro.intro.refine_1.convert_1).op)) x

tactic: rfl
state_before: case h.e'_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ (X.presheaf.map ((homOfLE ⋯).op ≫ (homOfLE ⋯).op)) x =
    (X.presheaf.map ((homOfLE ⋯).op ≫ (homOfLE ?intro.intro.refine_1.convert_1).op)) x
state_after: no goals

tactic: rw [map_zero]
state_before: case h.e'_3
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ 0 = (X.presheaf.map (homOfLE ?intro.intro.refine_1.convert_1).op) 0
state_after: no goals

tactic: simp only [Scheme.basicOpen_res, ge_iff_le, inf_le_right]
state_before: case intro.intro.refine_1.convert_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (X.presheaf.map (homOfLE ⋯).op) x = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) f) ≤ X.basicOpen f
state_after: no goals

tactic: subst e
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑Γ(X, U)
H : (x |_ X.basicOpen f) ⋯ = 0
s : Set ↑X.affineOpens
hs : s.Finite
e : U = ⨆ i, ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this✝ : Finite ↑s
val✝ : Fintype ↑s
this : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
⊢ f ^ Finset.univ.sup n * x = 0
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑X.affineOpens
hs : s.Finite
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ i, ↑↑i).carrier
x f : ↑Γ(X, ⨆ i, ↑↑i)
H : (x |_ X.basicOpen f) ⋯ = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ i, ↑↑i
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
⊢ f ^ Finset.univ.sup n * x = 0

tactic: apply TopCat.Sheaf.eq_of_locally_eq X.sheaf fun i : s => (i : Opens X)
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑X.affineOpens
hs : s.Finite
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ i, ↑↑i).carrier
x f : ↑Γ(X, ⨆ i, ↑↑i)
H : (x |_ X.basicOpen f) ⋯ = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ i, ↑↑i
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
⊢ f ^ Finset.univ.sup n * x = 0
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑X.affineOpens
hs : s.Finite
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ i, ↑↑i).carrier
x f : ↑Γ(X, ⨆ i, ↑↑i)
H : (x |_ X.basicOpen f) ⋯ = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ i, ↑↑i
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
⊢ ∀ (i : ↑s),
    (X.sheaf.val.map (Opens.leSupr (fun i => ↑↑i) i).op) (f ^ Finset.univ.sup n * x) =
      (X.sheaf.val.map (Opens.leSupr (fun i => ↑↑i) i).op) 0

tactic: intro i
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑X.affineOpens
hs : s.Finite
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ i, ↑↑i).carrier
x f : ↑Γ(X, ⨆ i, ↑↑i)
H : (x |_ X.basicOpen f) ⋯ = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ i, ↑↑i
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
⊢ ∀ (i : ↑s),
    (X.sheaf.val.map (Opens.leSupr (fun i => ↑↑i) i).op) (f ^ Finset.univ.sup n * x) =
      (X.sheaf.val.map (Opens.leSupr (fun i => ↑↑i) i).op) 0
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑X.affineOpens
hs : s.Finite
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ i, ↑↑i).carrier
x f : ↑Γ(X, ⨆ i, ↑↑i)
H : (x |_ X.basicOpen f) ⋯ = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ i, ↑↑i
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
i : ↑s
⊢ (X.sheaf.val.map (Opens.leSupr (fun i => ↑↑i) i).op) (f ^ Finset.univ.sup n * x) =
    (X.sheaf.val.map (Opens.leSupr (fun i => ↑↑i) i).op) 0

tactic: rw [map_zero]
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑X.affineOpens
hs : s.Finite
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ i, ↑↑i).carrier
x f : ↑Γ(X, ⨆ i, ↑↑i)
H : (x |_ X.basicOpen f) ⋯ = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ i, ↑↑i
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
i : ↑s
⊢ (X.sheaf.val.map (Opens.leSupr (fun i => ↑↑i) i).op) (f ^ Finset.univ.sup n * x) =
    (X.sheaf.val.map (Opens.leSupr (fun i => ↑↑i) i).op) 0
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑X.affineOpens
hs : s.Finite
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ i, ↑↑i).carrier
x f : ↑Γ(X, ⨆ i, ↑↑i)
H : (x |_ X.basicOpen f) ⋯ = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ i, ↑↑i
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
i : ↑s
⊢ (X.sheaf.val.map (Opens.leSupr (fun i => ↑↑i) i).op) (f ^ Finset.univ.sup n * x) = 0

tactic: apply this
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑X.affineOpens
hs : s.Finite
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ i, ↑↑i).carrier
x f : ↑Γ(X, ⨆ i, ↑↑i)
H : (x |_ X.basicOpen f) ⋯ = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ i, ↑↑i
hn : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) f ^ n i * (X.presheaf.map (homOfLE ⋯).op) x = 0
this : ∀ (i : ↑s), (X.presheaf.map (homOfLE ⋯).op) (f ^ Finset.univ.sup n * x) = 0
i : ↑s
⊢ (X.sheaf.val.map (Opens.leSupr (fun i => ↑↑i) i).op) (f ^ Finset.univ.sup n * x) = 0
state_after: no goals