Theorem: AlgebraicGeometry.exists_eq_pow_mul_of_isCompact_of_isQuasiSeparated
File: Mathlib/AlgebraicGeometry/Morphisms/QuasiSeparated.lean

tactic: delta TopCat.Presheaf.restrictOpen TopCat.Presheaf.restrict
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU' : IsQuasiSeparated U.carrier
f : ↑Γ(X, U)
x : ↑Γ(X, X.basicOpen f)
⊢ ∃ n y, (y |_ X.basicOpen f) ⋯ = (f |_ X.basicOpen f) ⋯ ^ n * x
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU' : IsQuasiSeparated U.carrier
f : ↑Γ(X, U)
x : ↑Γ(X, X.basicOpen f)
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: revert hU' f x
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU' : IsQuasiSeparated U.carrier
f : ↑Γ(X, U)
x : ↑Γ(X, X.basicOpen f)
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
⊢ IsQuasiSeparated U.carrier →
    ∀ (f : ↑Γ(X, U)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: apply compact_open_induction_on (P := _) U hU
state_before: X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
⊢ IsQuasiSeparated U.carrier →
    ∀ (f : ↑Γ(X, U)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₁
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
⊢ IsQuasiSeparated ⊥.carrier →
    ∀ (f : ↑Γ(X, ⊥)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

case h₂
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
⊢ ∀ (S : Opens ↑↑X.toPresheafedSpace),
    IsCompact S.carrier →
      ∀ (U : ↑X.affineOpens),
        (IsQuasiSeparated S.carrier →
            ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
              ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x) →
          IsQuasiSeparated (S ⊔ ↑U).carrier →
            ∀ (f : ↑Γ(X, S ⊔ ↑U)) (x : ↑Γ(X, X.basicOpen f)),
              ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: intro _ f x
state_before: case h₁
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
⊢ IsQuasiSeparated ⊥.carrier →
    ∀ (f : ↑Γ(X, ⊥)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₁
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU'✝ : IsQuasiSeparated ⊥.carrier
f : ↑Γ(X, ⊥)
x : ↑Γ(X, X.basicOpen f)
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: use 0, f
state_before: case h₁
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU'✝ : IsQuasiSeparated ⊥.carrier
f : ↑Γ(X, ⊥)
x : ↑Γ(X, X.basicOpen f)
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU'✝ : IsQuasiSeparated ⊥.carrier
f : ↑Γ(X, ⊥)
x : ↑Γ(X, X.basicOpen f)
⊢ (X.presheaf.map (homOfLE ⋯).op) f = (X.presheaf.map (homOfLE ⋯).op) f ^ 0 * x

tactic: refine @Subsingleton.elim _
  (CommRingCat.subsingleton_of_isTerminal (X.sheaf.isTerminalOfEqEmpty ?_)) _ _
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU'✝ : IsQuasiSeparated ⊥.carrier
f : ↑Γ(X, ⊥)
x : ↑Γ(X, X.basicOpen f)
⊢ (X.presheaf.map (homOfLE ⋯).op) f = (X.presheaf.map (homOfLE ⋯).op) f ^ 0 * x
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU'✝ : IsQuasiSeparated ⊥.carrier
f : ↑Γ(X, ⊥)
x : ↑Γ(X, X.basicOpen f)
⊢ X.basicOpen f = ⊥

tactic: erw [eq_bot_iff]
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU'✝ : IsQuasiSeparated ⊥.carrier
f : ↑Γ(X, ⊥)
x : ↑Γ(X, X.basicOpen f)
⊢ X.basicOpen f = ⊥
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU'✝ : IsQuasiSeparated ⊥.carrier
f : ↑Γ(X, ⊥)
x : ↑Γ(X, X.basicOpen f)
⊢ X.basicOpen f ≤ ⊥

tactic: exact X.basicOpen_le f
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
hU'✝ : IsQuasiSeparated ⊥.carrier
f : ↑Γ(X, ⊥)
x : ↑Γ(X, X.basicOpen f)
⊢ X.basicOpen f ≤ ⊥
state_after: no goals

tactic: intro S hS U hU hSU f x
state_before: case h₂
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
⊢ ∀ (S : Opens ↑↑X.toPresheafedSpace),
    IsCompact S.carrier →
      ∀ (U : ↑X.affineOpens),
        (IsQuasiSeparated S.carrier →
            ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
              ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x) →
          IsQuasiSeparated (S ⊔ ↑U).carrier →
            ∀ (f : ↑Γ(X, S ⊔ ↑U)) (x : ↑Γ(X, X.basicOpen f)),
              ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: obtain ⟨n₁, y₁, hy₁⟩ :=
  hU (hSU.of_subset Set.subset_union_left) (X.presheaf.map (homOfLE le_sup_left).op f)
    (X.presheaf.map (homOfLE _).op x)
state_before: case h₂
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: obtain ⟨n₂, y₂, hy₂⟩ :=
  exists_eq_pow_mul_of_isAffineOpen X _ U.2 (X.presheaf.map (homOfLE le_sup_right).op f)
    (X.presheaf.map (homOfLE _).op x)
state_before: case h₂.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (y₂ |_ X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) f)) ⋯ =
    ((X.presheaf.map (homOfLE ⋯).op) f |_ X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) f)) ⋯ ^ n₂ *
      (X.presheaf.map (homOfLE ?m.129727).op) x
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: delta TopCat.Presheaf.restrictOpen TopCat.Presheaf.restrict at hy₂
state_before: case h₂.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (y₂ |_ X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) f)) ⋯ =
    ((X.presheaf.map (homOfLE ⋯).op) f |_ X.basicOpen ((X.presheaf.map (homOfLE ⋯).op) f)) ⋯ ^ n₂ *
      (X.presheaf.map (homOfLE ?m.129727).op) x
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: obtain ⟨s, hs', hs⟩ :=
  (isCompactOpen_iff_eq_finset_affine_union _).mp
    ⟨hSU _ _ Set.subset_union_left S.2 hS Set.subset_union_right U.1.2
        U.2.isCompact,
      (S ⊓ U.1).2⟩
state_before: case h₂.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
hs : ↑S ∩ ↑↑U = ⋃ i ∈ s, ↑↑i
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: haveI := hs'.to_subtype
state_before: case h₂.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
hs : ↑S ∩ ↑↑U = ⋃ i ∈ s, ↑↑i
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
hs : ↑S ∩ ↑↑U = ⋃ i ∈ s, ↑↑i
this : Finite ↑s
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: cases nonempty_fintype s
state_before: case h₂.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
hs : ↑S ∩ ↑↑U = ⋃ i ∈ s, ↑↑i
this : Finite ↑s
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
hs : ↑S ∩ ↑↑U = ⋃ i ∈ s, ↑↑i
this : Finite ↑s
val✝ : Fintype ↑s
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: replace hs : S ⊓ U.1 = iSup fun i : s => (i : Opens X) := by ext1; simpa using hs
state_before: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
hs : ↑S ∩ ↑↑U = ⋃ i ∈ s, ↑↑i
this : Finite ↑s
val✝ : Fintype ↑s
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: have hs₁ : ∀ i : s, i.1.1 ≤ S := by
  intro i; change (i : Opens X) ≤ S
  refine le_trans ?_ (inf_le_left (b := U.1))
  erw [hs]
  exact @le_iSup (Opens X) s _ (fun (i : s) => (i : Opens X)) i
state_before: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: have hs₂ : ∀ i : s, i.1.1 ≤ U.1 := by
  intro i; change (i : Opens X) ≤ U
  refine le_trans ?_ (inf_le_right (a := S))
  erw [hs]
  exact @le_iSup (Opens X) s _ (fun (i : s) => (i : Opens X)) i
state_before: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: have := fun i ↦ exists_eq_pow_mul_of_is_compact_of_quasi_separated_space_aux
  X i.1 S U (hs₁ i) (hs₂ i) hy₁ hy₂
state_before: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
this :
  ∀ (i : ↑s), ∃ n, ∀ (m : ℕ), n ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: choose n hn using this
state_before: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
this :
  ∀ (i : ↑s), ∃ n, ∀ (m : ℕ), n ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x

tactic: use Finset.univ.sup n + n₁ + n₂
state_before: case h₂.intro.intro.intro.intro.intro.intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ ∃ y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x

tactic: use (X.sheaf.objSupIsoProdEqLocus S U.1).inv ⟨⟨_ * _, _ * _⟩, this⟩
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ ∃ y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op)
      ((X.sheaf.objSupIsoProdEqLocus S ↑U).inv
        ⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
            (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
          this⟩) =
    (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x

tactic: refine (X.sheaf.objSupIsoProdEqLocus_inv_eq_iff _ _ _ (X.basicOpen_res _
  (homOfLE le_sup_left).op) (X.basicOpen_res _ (homOfLE le_sup_right).op)).mpr ⟨?_, ?_⟩
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op)
      ((X.sheaf.objSupIsoProdEqLocus S ↑U).inv
        ⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
            (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
          this⟩) =
    (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x
state_after: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.sheaf.val.map (homOfLE ⋯).op)
      (↑⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
              (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
            this⟩).1 =
    (X.sheaf.val.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x)

case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.sheaf.val.map (homOfLE ⋯).op)
      (↑⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
              (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
            this⟩).2 =
    (X.sheaf.val.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x)

tactic: ext1
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
hs : ↑S ∩ ↑↑U = ⋃ i ∈ s, ↑↑i
this : Finite ↑s
val✝ : Fintype ↑s
⊢ S ⊓ ↑U = ⨆ i, ↑↑i
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
hs : ↑S ∩ ↑↑U = ⋃ i ∈ s, ↑↑i
this : Finite ↑s
val✝ : Fintype ↑s
⊢ ↑(S ⊓ ↑U) = ↑(⨆ i, ↑↑i)

tactic: simpa using hs
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
hs : ↑S ∩ ↑↑U = ⋃ i ∈ s, ↑↑i
this : Finite ↑s
val✝ : Fintype ↑s
⊢ ↑(S ⊓ ↑U) = ↑(⨆ i, ↑↑i)
state_after: no goals

tactic: intro i
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
⊢ ∀ (i : ↑s), ↑↑i ≤ S
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
i : ↑s
⊢ ↑↑i ≤ S

tactic: refine le_trans ?_ (inf_le_left (b := U.1))
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
i : ↑s
⊢ ↑↑i ≤ S
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
i : ↑s
⊢ ↑↑i ≤ S ⊓ ↑U

tactic: erw [hs]
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
i : ↑s
⊢ ↑↑i ≤ S ⊓ ↑U
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
i : ↑s
⊢ ↑↑i ≤ ⨆ i, ↑↑i

tactic: exact @le_iSup (Opens X) s _ (fun (i : s) => (i : Opens X)) i
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
i : ↑s
⊢ ↑↑i ≤ ⨆ i, ↑↑i
state_after: no goals

tactic: intro i
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
⊢ ∀ (i : ↑s), ↑↑i ≤ ↑U
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
i : ↑s
⊢ ↑↑i ≤ ↑U

tactic: refine le_trans ?_ (inf_le_right (a := S))
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
i : ↑s
⊢ ↑↑i ≤ ↑U
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
i : ↑s
⊢ ↑↑i ≤ S ⊓ ↑U

tactic: erw [hs]
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
i : ↑s
⊢ ↑↑i ≤ S ⊓ ↑U
state_after: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
i : ↑s
⊢ ↑↑i ≤ ⨆ i, ↑↑i

tactic: exact @le_iSup (Opens X) s _ (fun (i : s) => (i : Opens X)) i
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ?m.129011).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ?m.129727).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
i : ↑s
⊢ ↑↑i ≤ ⨆ i, ↑↑i
state_after: no goals

tactic: fapply X.sheaf.eq_of_locally_eq' fun i : s => i.1.1
state_before: X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
state_after: case iUV
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
⊢ (i : ↑s) → ↑↑i ⟶ S ⊓ ↑U

case hcover
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
⊢ S ⊓ ↑U ≤ ⨆ i, ↑↑i

case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
⊢ ∀ (i : ↑s),
    (X.sheaf.val.map (?iUV i).op)
        ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁)) =
      (X.sheaf.val.map (?iUV i).op)
        ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂))

tactic: refine fun i => homOfLE ?_
state_before: case iUV
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
⊢ (i : ↑s) → ↑↑i ⟶ S ⊓ ↑U
state_after: case iUV
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ ↑↑i ≤ S ⊓ ↑U

tactic: erw [hs]
state_before: case iUV
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ ↑↑i ≤ S ⊓ ↑U
state_after: case iUV
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ ↑↑i ≤ ⨆ i, ↑↑i

tactic: exact @le_iSup (Opens X) s _ (fun (i : s) => (i : Opens X)) i
state_before: case iUV
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ ↑↑i ≤ ⨆ i, ↑↑i
state_after: no goals

tactic: exact le_of_eq hs
state_before: case hcover
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
⊢ S ⊓ ↑U ≤ ⨆ i, ↑↑i
state_after: no goals

tactic: intro i
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
⊢ ∀ (i : ↑s),
    (X.sheaf.val.map (homOfLE ⋯).op)
        ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁)) =
      (X.sheaf.val.map (homOfLE ⋯).op)
        ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂))
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ (X.sheaf.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁)) =
    (X.sheaf.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂))

tactic: delta Scheme.sheaf SheafedSpace.sheaf
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ (X.sheaf.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁)) =
    (X.sheaf.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂))
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁)) =
    ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂))

tactic: repeat rw [← comp_apply,]
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁)) =
    ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂))
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ { val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op ≫ { val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)

tactic: simp only [← Functor.map_comp, ← op_comp]
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ { val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op ≫ { val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯ ≫ homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯ ≫ homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)

tactic: apply hn
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯ ≫ homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯ ≫ homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
state_after: case h.a
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ n i ≤ Finset.univ.sup n

tactic: exact Finset.le_sup (Finset.mem_univ _)
state_before: case h.a
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ n i ≤ Finset.univ.sup n
state_after: no goals

tactic: rw [← comp_apply,]
state_before: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ { val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂))
state_after: case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
i : ↑s
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ { val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op ≫ { val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)

tactic: delta Scheme.sheaf SheafedSpace.sheaf
state_before: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.sheaf.val.map (homOfLE ⋯).op)
      (↑⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
              (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
            this⟩).1 =
    (X.sheaf.val.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x)
state_after: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      (↑⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
              (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
            this⟩).1 =
    ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x)

tactic: rw [add_assoc, add_comm n₁]
state_before: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      (↑⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
              (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
            this⟩).1 =
    ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x)
state_after: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      (↑⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
              (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
            this⟩).1 =
    ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + (n₂ + n₁)) * x)

tactic: simp only [pow_add, map_pow, map_mul]
state_before: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      (↑⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
              (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
            this⟩).1 =
    ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + (n₂ + n₁)) * x)
state_after: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
      (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
          (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁) *
      (X.presheaf.map (homOfLE ⋯).op) x

tactic: rw [hy₁]
state_before: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
      (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
          (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁) *
      (X.presheaf.map (homOfLE ⋯).op) x
state_after: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
          (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁) *
      (X.presheaf.map (homOfLE ⋯).op) x

tactic: repeat rw [← comp_apply]
state_before: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
          (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁) *
      (X.presheaf.map (homOfLE ⋯).op) x
state_after: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ *
      ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ *
          (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁) *
      (X.presheaf.map (homOfLE ⋯).op) x

tactic: simp only [← mul_assoc, ← Functor.map_comp, ← op_comp, homOfLE_comp]
state_before: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ *
      ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ *
          (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁) *
      (X.presheaf.map (homOfLE ⋯).op) x
state_after: no goals

tactic: rw [← comp_apply]
state_before: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ *
      ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
          (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁) *
      (X.presheaf.map (homOfLE ⋯).op) x
state_after: case h.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ *
      ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ *
          (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁) *
      (X.presheaf.map (homOfLE ⋯).op) x

tactic: delta Scheme.sheaf SheafedSpace.sheaf
state_before: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.sheaf.val.map (homOfLE ⋯).op)
      (↑⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
              (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
            this⟩).2 =
    (X.sheaf.val.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x)
state_after: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      (↑⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
              (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
            this⟩).2 =
    ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x)

tactic: simp only [pow_add, map_pow, map_mul]
state_before: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      (↑⟨((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁,
              (X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂),
            this⟩).2 =
    ({ val := X.presheaf, cond := ⋯ }.val.map (homOfLE ⋯).op)
      ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁ + n₂) * x)
state_after: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ *
      (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
          (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
      (X.presheaf.map (homOfLE ⋯).op) x

tactic: rw [hy₂]
state_before: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ *
      (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
          (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
      (X.presheaf.map (homOfLE ⋯).op) x
state_after: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ *
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
          (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
      (X.presheaf.map (homOfLE ⋯).op) x

tactic: repeat rw [← comp_apply]
state_before: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ *
      ((X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
          (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
      (X.presheaf.map (homOfLE ⋯).op) x
state_after: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ *
      ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
          (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ *
      (X.presheaf.map (homOfLE ⋯).op) x

tactic: simp only [← mul_assoc, ← Functor.map_comp, ← op_comp, homOfLE_comp]
state_before: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ *
      ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
          (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ *
      (X.presheaf.map (homOfLE ⋯).op) x
state_after: no goals

tactic: rw [← comp_apply]
state_before: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ *
      ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ Finset.univ.sup n *
          (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ *
        (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ *
      (X.presheaf.map (homOfLE ⋯).op) x
state_after: case h.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U✝ : Opens ↑↑X.toPresheafedSpace
hU✝ : IsCompact U✝.carrier
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
U : ↑X.affineOpens
hU :
  IsQuasiSeparated S.carrier →
    ∀ (f : ↑Γ(X, S)) (x : ↑Γ(X, X.basicOpen f)),
      ∃ n y, (X.presheaf.map (homOfLE ⋯).op) y = (X.presheaf.map (homOfLE ⋯).op) f ^ n * x
hSU : IsQuasiSeparated (S ⊔ ↑U).carrier
f : ↑Γ(X, S ⊔ ↑U)
x : ↑Γ(X, X.basicOpen f)
n₁ : ℕ
y₁ : ↑Γ(X, S)
hy₁ :
  (X.presheaf.map (homOfLE ⋯).op) y₁ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₁ * (X.presheaf.map (homOfLE ⋯).op) x
n₂ : ℕ
y₂ : ↑Γ(X, ↑U)
hy₂ :
  (X.presheaf.map (homOfLE ⋯).op) y₂ =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f) ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x
s : Set ↑X.affineOpens
hs' : s.Finite
this✝ : Finite ↑s
val✝ : Fintype ↑s
hs : S ⊓ ↑U = ⨆ i, ↑↑i
hs₁ : ∀ (i : ↑s), ↑↑i ≤ S
hs₂ : ∀ (i : ↑s), ↑↑i ≤ ↑U
n : ↑s → ℕ
hn : ∀ (i : ↑s) (m : ℕ), n i ≤ m → (((f |_ S) ⋯ ^ (m + n₂) * y₁) |_ ↑↑i) ⋯ = (((f |_ ↑U) ⋯ ^ (m + n₁) * y₂) |_ ↑↑i) ⋯
this :
  (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₂) * y₁) =
    (X.presheaf.map (homOfLE ⋯).op) ((X.presheaf.map (homOfLE ⋯).op) f ^ (Finset.univ.sup n + n₁) * y₂)
⊢ (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ *
      ((X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ * (X.presheaf.map (homOfLE ⋯).op) x) =
    (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ Finset.univ.sup n *
          (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₁ *
        (X.presheaf.map (homOfLE ⋯).op ≫ X.presheaf.map (homOfLE ⋯).op) f ^ n₂ *
      (X.presheaf.map (homOfLE ⋯).op) x