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

Proof steps:
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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: obtain ⟨s, hs, e⟩ := (isCompactOpen_iff_eq_finset_affine_union U.1).mp ⟨hU, U.2⟩
state_before: case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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: replace e : U = iSup fun i : s => (i : X.Opens) := by
    ext1; simpa using e
state_before: case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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₁ : ∀ i : s, i.1.1 ≤ U := by
    intro i
    change (i : X.Opens) ≤ U
    rw [e]
    -- Porting note: `exact le_iSup _ _` no longer works
    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 : X.Opens
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 : X.Opens
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 : X.Opens
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: 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.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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 : X.Opens
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 : X.Opens
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: swap
state_before: case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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: choose n hn using H'
state_before: case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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: haveI := hs.to_subtype
state_before: case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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: cases nonempty_fintype s
state_before: case intro.intro.refine_2.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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: use Finset.univ.sup n
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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: 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 : X.Opens)
    intro i
    rw [map_zero]
    apply this
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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 : X.Opens
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 : X.Opens
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: 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 : X.Opens
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 : X.Opens
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: dsimp at hn
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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: simp only [← map_mul, ← map_pow] at hn
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : X.Opens
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 : X.Opens
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: 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 : X.Opens
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: apply Finset.le_sup (Finset.mem_univ i)