cf : Code
hf : ∀ {n x : ℕ}, x ∈ cf.eval n → ∃ k, x ∈ evaln (k + 1) cf n
n y : ℕ
IH :
  ∀ (m : ℕ),
    0 ∈ cf.eval (Nat.pair (unpair n).1 (y + m)) →
      (∀ {m_1 : ℕ}, m_1 < y → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m_1 + m)), ¬a = 0) →
        ∃ k, y + m ∈ evaln (k + 1) cf.rfind' (Nat.pair (unpair n).1 m)
m : ℕ
hy₁ : 0 ∈ cf.eval (Nat.pair (unpair n).1 (y + 1 + m))
hy₂ : ∀ {m_1 : ℕ}, m_1 < y + 1 → ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (m_1 + m)), ¬a = 0
a : ℕ
ha : a ∈ cf.eval (Nat.pair (unpair n).1 (0 + m))
a0 : ¬a = 0
k₁ : ℕ
hk₁ : a ∈ evaln (k₁ + 1) cf (Nat.pair (unpair n).1 (0 + m))
i : ℕ
hi : i < y
⊢ ∃ a ∈ cf.eval (Nat.pair (unpair n).1 (i + m.succ)), ¬a = 0


case right
n x : ℕ
h : x = (unpair n).2
⊢ (∃ x, n ≤ x) ∧ (unpair n).2 = x


R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
⊢ StructureSheaf.toStalk (↑(CommRingCat.of (A⁰_ f))) ((toSpec 𝒜 f).val.base x) ≫
      PresheafedSpace.stalkMap (toSpec 𝒜 f).val x =
    awayToΓ 𝒜 f ≫ (Proj.restrict ⋯).ΓToStalk x


R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
⊢ StructureSheaf.toOpen ↑(CommRingCat.of (A⁰_ f)) ⊤ ≫
      (Spec.structureSheaf ↑(CommRingCat.of (A⁰_ f))).presheaf.germ ⟨(toSpec 𝒜 f).val.base x, True.intro⟩ ≫
        PresheafedSpace.stalkMap (toSpec 𝒜 f).val x =
    awayToΓ 𝒜 f ≫ (Proj.restrict ⋯).ΓToStalk x


R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
⊢ StructureSheaf.toOpen (A⁰_ f) ⊤ ≫
      (Spec.structureSheaf (A⁰_ f)).presheaf.germ ⟨(toSpec 𝒜 f).val.base x, True.intro⟩ ≫
        PresheafedSpace.stalkMap (toSpec 𝒜 f).val x =
    awayToΓ 𝒜 f ≫ (Proj.restrict ⋯).ΓToStalk x


R : Type u_1
A : Type u_2
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ℕ → Submodule R A
inst✝ : GradedAlgebra 𝒜
f : A
x : ↑↑(Proj.restrict ⋯).toPresheafedSpace
⊢ StructureSheaf.toOpen (A⁰_ f) ⊤ ≫
      (toSpec 𝒜 f).val.c.app { unop := ⊤ } ≫ (Proj.restrict ⋯).presheaf.germ ⟨x, True.intro⟩ =
    awayToΓ 𝒜 f ≫ (Proj.restrict ⋯).ΓToStalk x


A B : Grp
f : A ⟶ B
x : ↑B
⊢ (h x) (fromCoset ⟨↑(MonoidHom.range f), ⋯⟩) = fromCoset ⟨↑(MonoidHom.range f), ⋯⟩


A B : Grp
f : A ⟶ B
x : ↑B
⊢ (((Equiv.symm τ).trans (g x)).trans τ) (fromCoset ⟨↑(MonoidHom.range f), ⋯⟩) = fromCoset ⟨↑(MonoidHom.range f), ⋯⟩


α : Type u
β : Type u_1
inst✝ : StrictOrderedSemiring α
a b c d : α
⊢ a < c → b < d → 0 ≤ a → 0 ≤ b → a * b < c * d


α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : CommGroupWithZero G₀
a b c d : G₀
h : a = 0 → b = 0
⊢ a * b / a = b


α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a (b - p) = toIocDiv hp a b - 1


case tfae_3_to_1.intro.intro
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Semiring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
h : Exact ⇑f ⇑g
tfae_1_to_3 : (Injective ⇑f ∧ ∃ l, g ∘ₗ l = LinearMap.id) → ∃ e, f = ↑e.symm ∘ₗ inl R M P ∧ g = snd R M P ∘ₗ ↑e
tfae_2_to_3 : (Surjective ⇑g ∧ ∃ l, l ∘ₗ f = LinearMap.id) → ∃ e, f = ↑e.symm ∘ₗ inl R M P ∧ g = snd R M P ∘ₗ ↑e
e : N ≃ₗ[R] M × P
e₁ : f = ↑e.symm ∘ₗ inl R M P
e₂ : g = snd R M P ∘ₗ ↑e
⊢ Injective ⇑f ∧ ∃ l, g ∘ₗ l = LinearMap.id


case tfae_3_to_1.intro.intro
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Semiring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
h : Exact ⇑f ⇑g
tfae_1_to_3 : (Injective ⇑f ∧ ∃ l, g ∘ₗ l = LinearMap.id) → ∃ e, f = ↑e.symm ∘ₗ inl R M P ∧ g = snd R M P ∘ₗ ↑e
tfae_2_to_3 : (Surjective ⇑g ∧ ∃ l, l ∘ₗ f = LinearMap.id) → ∃ e, f = ↑e.symm ∘ₗ inl R M P ∧ g = snd R M P ∘ₗ ↑e
e : N ≃ₗ[R] M × P
e₁ : f = ↑e.symm ∘ₗ inl R M P
e₂ : g = snd R M P ∘ₗ ↑e
this : Injective ⇑f
⊢ Injective ⇑f ∧ ∃ l, g ∘ₗ l = LinearMap.id


case tfae_3_to_2.intro.intro
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Semiring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
h : Exact ⇑f ⇑g
tfae_1_to_3 : (Injective ⇑f ∧ ∃ l, g ∘ₗ l = LinearMap.id) → ∃ e, f = ↑e.symm ∘ₗ inl R M P ∧ g = snd R M P ∘ₗ ↑e
tfae_2_to_3 : (Surjective ⇑g ∧ ∃ l, l ∘ₗ f = LinearMap.id) → ∃ e, f = ↑e.symm ∘ₗ inl R M P ∧ g = snd R M P ∘ₗ ↑e
tfae_3_to_1 : (∃ e, f = ↑e.symm ∘ₗ inl R M P ∧ g = snd R M P ∘ₗ ↑e) → Injective ⇑f ∧ ∃ l, g ∘ₗ l = LinearMap.id
e : N ≃ₗ[R] M × P
e₁ : f = ↑e.symm ∘ₗ inl R M P
e₂ : g = snd R M P ∘ₗ ↑e
⊢ Surjective ⇑g ∧ ∃ l, l ∘ₗ f = LinearMap.id


case tfae_3_to_2.intro.intro
R : Type u_1
M : Type u_2
M' : Type u_3
N : Type u_4
N' : Type u_5
P : Type u_6
P' : Type u_7
inst✝⁶ : Semiring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup N
inst✝³ : AddCommGroup P
inst✝² : Module R M
inst✝¹ : Module R N
inst✝ : Module R P
f : M →ₗ[R] N
g : N →ₗ[R] P
h : Exact ⇑f ⇑g
tfae_1_to_3 : (Injective ⇑f ∧ ∃ l, g ∘ₗ l = LinearMap.id) → ∃ e, f = ↑e.symm ∘ₗ inl R M P ∧ g = snd R M P ∘ₗ ↑e
tfae_2_to_3 : (Surjective ⇑g ∧ ∃ l, l ∘ₗ f = LinearMap.id) → ∃ e, f = ↑e.symm ∘ₗ inl R M P ∧ g = snd R M P ∘ₗ ↑e
tfae_3_to_1 : (∃ e, f = ↑e.symm ∘ₗ inl R M P ∧ g = snd R M P ∘ₗ ↑e) → Injective ⇑f ∧ ∃ l, g ∘ₗ l = LinearMap.id
e : N ≃ₗ[R] M × P
e₁ : f = ↑e.symm ∘ₗ inl R M P
e₂ : g = snd R M P ∘ₗ ↑e
this : Surjective ⇑g
⊢ Surjective ⇑g ∧ ∃ l, l ∘ₗ f = LinearMap.id


α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 6 → β
⊢ ∏ i : Fin 6, f i = f 0 * f 1 * f 2 * f 3 * f 4 * f 5


α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
f : Fin 7 → β
⊢ ∏ i : Fin 7, f i = f 0 * f 1 * f 2 * f 3 * f 4 * f 5 * f 6


R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
c : R
⊢ ((monomial s) c).totalDegree ≤ s.sum fun x => id


R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
c : R
hc : c = 0
⊢ ((monomial s) c).totalDegree ≤ s.sum fun x => id


R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
c : R
hc : ¬c = 0
⊢ ((monomial s) c).totalDegree ≤ s.sum fun x => id


R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s✝ : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
s : σ →₀ ℕ
c : R
hc : ¬c = 0
⊢ (s.sum fun x e => e) ≤ s.sum fun x => id


case neg.intro.intro
α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x y : α
h : ¬gcd x y = 0
x' : α
ex : x = gcd x y * x'
y' : α
ey : y = gcd x y * y'
⊢ ∃ x' y', x = gcd x y * x' ∧ y = gcd x y * y' ∧ IsUnit (gcd x' y')


case pos
α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
x y : α
h : gcd x y = 0
⊢ ∃ x' y', x = gcd x y * x' ∧ y = gcd x y * y' ∧ IsUnit (gcd x' y')


case pos.intro
α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
h : gcd 0 0 = 0
⊢ ∃ x' y', 0 = gcd 0 0 * x' ∧ 0 = gcd 0 0 * y' ∧ IsUnit (gcd x' y')


case pos.intro
α✝ : Type u_1
inst✝² : CancelCommMonoidWithZero α✝
α : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : GCDMonoid α
h : gcd 0 0 = 0
⊢ ∃ x' y', 0 = gcd 0 0 * x' ∧ 0 = gcd 0 0 * y' ∧ Associated (gcd x' y') 1


case tfae_1_to_4
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
H : targetAffineLocally P f
U : Scheme
g : U ⟶ Y
h₁ : IsAffine U
h₂ : IsOpenImmersion g
⊢ P pullback.snd


case tfae_1_to_4
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
U : Scheme
g : U ⟶ Y
h₁ : IsAffine U
h₂ : IsOpenImmersion g
H : P.toProperty (f ∣_ ↑⟨Scheme.Hom.opensRange g, ⋯⟩)
⊢ P.toProperty pullback.snd


case tfae_3_to_2
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
⊢ (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd


case tfae_2_to_1.intro.intro
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
𝒰 : Y.OpenCover
h𝒰 : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P pullback.snd
⊢ targetAffineLocally P f


case tfae_5_to_2.intro.intro.intro.intro
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
ι : Type u
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
hU' : ∀ (i : ι), IsAffineOpen (U i)
i : (Y.openCoverOfSuprEqTop U hU).J
H : P (f ∣_ U i)
⊢ P pullback.snd


case h.e'_2.h.e'_1.h.e'_6.h.e'_6
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
ι : Type u
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
hU' : ∀ (i : ι), IsAffineOpen (U i)
i : (Y.openCoverOfSuprEqTop U hU).J
H : P.toProperty (f ∣_ U i)
⊢ Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i) = U i

case h.e'_2.h.e'_3.e'_2.h.e'_6
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
ι : Type u
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
hU' : ∀ (i : ι), IsAffineOpen (U i)
i : (Y.openCoverOfSuprEqTop U hU).J
H : P.toProperty (f ∣_ U i)
e_1✝ :
  (Opens.toTopCat ↑X.toPresheafedSpace).obj (f ⁻¹ᵁ Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i)) =
    (Opens.toTopCat ↑X.toPresheafedSpace).obj (f ⁻¹ᵁ U i)
⊢ Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i) = U i

case h.e'_3.h.e'_1.h.e'_6
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
ι : Type u
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
hU' : ∀ (i : ι), IsAffineOpen (U i)
i : (Y.openCoverOfSuprEqTop U hU).J
H : P.toProperty (f ∣_ U i)
⊢ Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i) = U i

case h.e'_3.h.e'_3.e'_2
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
ι : Type u
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
hU' : ∀ (i : ι), IsAffineOpen (U i)
i : (Y.openCoverOfSuprEqTop U hU).J
H : P.toProperty (f ∣_ U i)
e_1✝ :
  (Opens.toTopCat ↑Y.toPresheafedSpace).obj (Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i)) =
    (Opens.toTopCat ↑Y.toPresheafedSpace).obj (U i)
⊢ Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i) = U i

case h.e'_4.e'_4
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
ι : Type u
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
hU' : ∀ (i : ι), IsAffineOpen (U i)
i : (Y.openCoverOfSuprEqTop U hU).J
H : P.toProperty (f ∣_ U i)
e_2✝ : X ∣_ᵤ f ⁻¹ᵁ Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i) = X ∣_ᵤ f ⁻¹ᵁ U i
e_3✝ : Y ∣_ᵤ Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i) = Y ∣_ᵤ U i
⊢ Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i) = U i


case h.e'_4.e'_4.h
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
ι : Type u
U : ι → Opens ↑↑Y.toPresheafedSpace
hU : iSup U = ⊤
hU' : ∀ (i : ι), IsAffineOpen (U i)
i : (Y.openCoverOfSuprEqTop U hU).J
H : P.toProperty (f ∣_ U i)
e_2✝ : X ∣_ᵤ f ⁻¹ᵁ Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i) = X ∣_ᵤ f ⁻¹ᵁ U i
e_3✝ : Y ∣_ᵤ Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i) = Y ∣_ᵤ U i
⊢ ↑(Scheme.Hom.opensRange ((Y.openCoverOfSuprEqTop U hU).map i)) = ↑(U i)


case tfae_1_to_5
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
tfae_5_to_2 :
  (∃ ι U, ∃ (_ : iSup U = ⊤) (hU' : ∀ (i : ι), IsAffineOpen (U i)), ∀ (i : ι), P (f ∣_ U i)) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
H : targetAffineLocally P f
⊢ ∃ ι U, ∃ (_ : iSup U = ⊤) (hU' : ∀ (i : ι), IsAffineOpen (U i)), ∀ (i : ι), P (f ∣_ U i)


case tfae_1_to_5.refine_1
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
tfae_5_to_2 :
  (∃ ι U, ∃ (_ : iSup U = ⊤) (hU' : ∀ (i : ι), IsAffineOpen (U i)), ∀ (i : ι), P (f ∣_ U i)) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
H : targetAffineLocally P f
⊢ ⨆ x, Scheme.Hom.opensRange (Y.affineCover.map x) = ⊤


case tfae_1_to_5.refine_1
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
tfae_5_to_2 :
  (∃ ι U, ∃ (_ : iSup U = ⊤) (hU' : ∀ (i : ι), IsAffineOpen (U i)), ∀ (i : ι), P (f ∣_ U i)) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
H : targetAffineLocally P f
x : ↑↑Y.toPresheafedSpace
a✝ : x ∈ ↑⊤
⊢ x ∈ ↑(⨆ x, Scheme.Hom.opensRange (Y.affineCover.map x))


case tfae_1_to_5.refine_2
P : AffineTargetMorphismProperty
hP : P.IsLocal
X Y : Scheme
f : X ⟶ Y
tfae_1_to_4 :
  targetAffineLocally P f → ∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd
tfae_4_to_3 :
  (∀ {U : Scheme} (g : U ⟶ Y) [inst : IsAffine U] [inst_1 : IsOpenImmersion g], P pullback.snd) →
    ∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd
tfae_3_to_2 :
  (∀ (𝒰 : Y.OpenCover) [inst : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)] (i : 𝒰.J), P pullback.snd) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
tfae_2_to_1 : (∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd) → targetAffineLocally P f
tfae_5_to_2 :
  (∃ ι U, ∃ (_ : iSup U = ⊤) (hU' : ∀ (i : ι), IsAffineOpen (U i)), ∀ (i : ι), P (f ∣_ U i)) →
    ∃ 𝒰, ∃ (x : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)), ∀ (i : 𝒰.J), P pullback.snd
H : targetAffineLocally P f
i : ↑↑Y.toPresheafedSpace
⊢ P (f ∣_ (fun x => Scheme.Hom.opensRange (Y.affineCover.map x)) i)


M : Type u
m₁ m₂ : Monoid M
h_mul : HMul.hMul = HMul.hMul
⊢ m₁ = m₂


M : Type u
m₁ m₂ : Monoid M
h_mul : HMul.hMul = HMul.hMul
this : toMulOneClass = toMulOneClass
h₁ : One.one = One.one
⊢ m₁ = m₂


M : Type u
m₁ m₂ : Monoid M
h_mul : HMul.hMul = HMul.hMul
this : toMulOneClass = toMulOneClass
h₁ : One.one = One.one
f : M →* M := { toFun := id, map_one' := h₁, map_mul' := ⋯ }
⊢ m₁ = m₂


case h.h
M : Type u
m₁ m₂ : Monoid M
h_mul : HMul.hMul = HMul.hMul
this : toMulOneClass = toMulOneClass
h₁ : One.one = One.one
f : M →* M := { toFun := id, map_one' := h₁, map_mul' := ⋯ }
n : ℕ
x : M
⊢ Monoid.npow n x = Monoid.npow n x


P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
⊢ sourceAffineLocally P f


P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)


case basicOpen
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)


case basicOpen.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P (X.presheaf.map (homOfLE ⋯).op)


case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ ↑(Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }) →+* ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })


case basicOpen.convert_1
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ ⋯.functor.obj ⊤ ≤ ⋯.functor.obj ⊤


case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op = comp (X.presheaf.map (homOfLE ⋯).op) (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)


case h.e'_5
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ Scheme.Γ.map f.op ≫ Scheme.Γ.map (X.ofRestrict ⋯).op =
    comp (X.presheaf.map (homOfLE ⋯).op) (Scheme.Γ.map f.op ≫ Scheme.Γ.map (X.ofRestrict ⋯).op)


case h.e'_5.e_a
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ X.presheaf.map (⋯.adjunction.counit.app ⊤).op =
    X.presheaf.map (⋯.adjunction.counit.app ⊤).op ≫ X.presheaf.map (homOfLE ⋯).op


case h.e'_5.h.h
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
e_1✝ : ↑(Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }) = ↑Γ(X, ⋯.functor.obj ⊤)
he✝ : (Scheme.Γ.obj { unop := X ∣_ᵤ ↑U }).instCommRingα = Γ(X, ⋯.functor.obj ⊤).instCommRingα
⊢ X.presheaf.map (homOfLE ⋯).op = algebraMap ↑Γ(X, ⋯.functor.obj ⊤) ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })


case basicOpen.convert_2.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ IsLocalization.Away ((X.presheaf.map (eqToHom ⋯).op) r) ↑(Scheme.Γ.obj { unop := X ∣_ᵤ X.basicOpen r })


case basicOpen.convert_2.convert_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ↑U ∈ X.affineOpens
⊢ IsLocalization.Away ((X.presheaf.map (eqToHom ⋯).op) r) ↑Γ(X, ⋯.functor.obj ⊤)


case h.e'_4.h.e'_2.h.e'_6.h.e'_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

case h.e'_5.e'_2.e'_1.h.e'_6.h.e'_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

case h.e'_6.e'_5.h.e'_7.h.e'_2
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)

case h.e'_6.e'_5.h.e'_8.e'_3
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_7✝ : { unop := ⋯.functor.obj ⊤ } = { unop := X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r) }
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)


case h.e'_6.e'_5.h.e'_8.e'_3
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_7✝ : { unop := ⋯.functor.obj ⊤ } = { unop := X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r) }
⊢ ⋯.functor.obj ⊤ = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)


case h.e'_6.e'_5.h.e'_8.e'_3
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H✝ : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
r : ↑Γ(X, ↑U)
H : P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
this : ⋯.functor.obj ⊤ ∈ X.affineOpens
e_4✝¹ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
e_5✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_1✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, ⋯.functor.obj ⊤)
e_2✝ : ↑Γ(X, ⋯.functor.obj ⊤) = ↑Γ(X, X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r))
he✝ : CommRing.toCommSemiring = CommRing.toCommSemiring
e_4✝ : HEq CommRing.toCommSemiring CommRing.toCommSemiring
e_7✝ : { unop := ⋯.functor.obj ⊤ } = { unop := X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r) }
⊢ X.basicOpen r = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)


case openCover
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
H : ∀ (i : 𝒰.J), P (Scheme.Γ.map (𝒰.map i ≫ f).op)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U✝ U : ↑X.affineOpens
s : Finset ↑Γ(X, ↑U)
hs : Ideal.span ↑s = ⊤
hs' : ∀ (f_1 : { x // x ∈ s }), P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)


case hU
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
i : 𝒰.J
H : P (Scheme.Γ.map (𝒰.map i ≫ f).op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)


case hU
P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop
hP : PropertyIsLocal P
X Y : Scheme
f : X ⟶ Y
inst✝¹ : IsAffine Y
𝒰 : X.OpenCover
inst✝ : ∀ (i : 𝒰.J), IsAffine (𝒰.obj i)
S : 𝒰.J → { x // x ∈ X.affineOpens } := fun i => ⟨{ carrier := Set.range ⇑(𝒰.map i).val.base, is_open' := ⋯ }, ⋯⟩
U : ↑X.affineOpens
i : 𝒰.J
H : P (Scheme.Γ.map (𝒰.map i ≫ f).op ≫ Scheme.Γ.map (IsOpenImmersion.isoOfRangeEq (𝒰.map i) (X.ofRestrict ⋯) ⋯).inv.op)
⊢ P (Scheme.Γ.map (X.ofRestrict ⋯ ≫ f).op)


α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f : CauSeq α abs
⊢ f.Pos ∨ f.LimZero ∨ (-f).Pos


case inr
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f : CauSeq α abs
h : ¬f.LimZero
⊢ f.Pos ∨ (-f).Pos


case inr.intro.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f : CauSeq α abs
h : ¬f.LimZero
K : α
K0 : K > 0
hK : ∃ i, ∀ j ≥ i, K ≤ |↑f j|
⊢ f.Pos ∨ (-f).Pos


case inr.intro.intro.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f : CauSeq α abs
h : ¬f.LimZero
K : α
K0 : K > 0
hK : ∃ i, ∀ j ≥ i, K ≤ |↑f j|
i : ℕ
hi : ∀ j ≥ i, K ≤ |↑f j| ∧ ∀ k ≥ j, |↑f k - ↑f j| < K
⊢ f.Pos ∨ (-f).Pos


case inr.intro.intro.intro.refine_1.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f : CauSeq α abs
h✝ : ¬f.LimZero
K : α
K0 : K > 0
hK : ∃ i, ∀ j ≥ i, K ≤ |↑f j|
i : ℕ
hi : ∀ j ≥ i, K ≤ |↑f j| ∧ ∀ k ≥ j, |↑f k - ↑f j| < K
h : 0 ≤ ↑f i
j : ℕ
ij : j ≥ i
this : K ≤ |↑f j|
h₁ : K ≤ ↑f i
h₂ : ∀ k ≥ i, |↑f k - ↑f i| < K
⊢ 0 ≤ ↑f j


case inr.intro.intro.intro.refine_2.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f : CauSeq α abs
h✝ : ¬f.LimZero
K : α
K0 : K > 0
hK : ∃ i, ∀ j ≥ i, K ≤ |↑f j|
i : ℕ
hi : ∀ j ≥ i, K ≤ |↑f j| ∧ ∀ k ≥ j, |↑f k - ↑f j| < K
h : ↑f i ≤ 0
j : ℕ
ij : j ≥ i
this : K ≤ |↑f j|
h₁ : K ≤ -↑f i
h₂ : ∀ k ≥ i, |↑f k - ↑f i| < K
⊢ ↑f j - ?inr.intro.intro.intro.refine_2.intro ≤ -?inr.intro.intro.intro.refine_2.intro

case inr.intro.intro.intro.refine_2.intro
α : Type u_1
β : Type u_2
inst✝ : LinearOrderedField α
f : CauSeq α abs
h✝ : ¬f.LimZero
K : α
K0 : K > 0
hK : ∃ i, ∀ j ≥ i, K ≤ |↑f j|
i : ℕ
hi : ∀ j ≥ i, K ≤ |↑f j| ∧ ∀ k ≥ j, |↑f k - ↑f j| < K
h : ↑f i ≤ 0
j : ℕ
ij : j ≥ i
this : K ≤ |↑f j|
h₁ : K ≤ -↑f i
h₂ : ∀ k ≥ i, |↑f k - ↑f i| < K
⊢ α


C : Type u_1
D : Type u_2
inst✝⁹ : Category.{u_3, u_1} C
inst✝⁸ : Category.{u_4, u_2} D
inst✝⁷ : HasZeroMorphisms C
inst✝⁶ : HasZeroMorphisms D
S : ShortComplex C
h₁✝ : S.LeftHomologyData
h₂✝ : S.RightHomologyData
F✝ : C ⥤ D
inst✝⁵ : F✝.PreservesZeroMorphisms
hl : S.LeftHomologyData
hr : S.RightHomologyData
S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
hl₁ : S₁.LeftHomologyData
hr₁ : S₁.RightHomologyData
hl₂ : S₂.LeftHomologyData
hr₂ : S₂.RightHomologyData
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
F : C ⥤ D
inst✝⁴ : F.PreservesZeroMorphisms
inst✝³ : S₁.HasLeftHomology
inst✝² : S₂.HasLeftHomology
inst✝¹ : F.PreservesLeftHomologyOf S₁
inst✝ : F.PreservesLeftHomologyOf S₂
⊢ F.map (leftHomologyMap φ) ≫ (S₂.mapLeftHomologyIso F).inv =
    (S₁.mapLeftHomologyIso F).inv ≫ leftHomologyMap (F.mapShortComplex.map φ)


R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
h : IsNilpotent R L (M ⧸ N)
⊢ ⨅ k, lowerCentralSeries R L M k ≤ N


case intro
R : Type u
L : Type v
M : Type w
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
k✝ : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
h : IsNilpotent R L (M ⧸ N)
k : ℕ
hk : lowerCentralSeries R L M k ≤ N
⊢ ⨅ k, lowerCentralSeries R L M k ≤ N


α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ |a - b| < c ↔ a - b < c ∧ b - a < c


α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocMod hp (a - p) b = toIocMod hp a b - p


ι : Sort u_1
G : Type u_2
inst✝ : Group G
s : Set Gᵐᵒᵖ
⊢ (closure s).unop = closure (MulOpposite.op ⁻¹' s)


α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ toIcoDiv hp a (b - c) = toIcoDiv hp (a + c) b


case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ b - c - toIcoDiv hp (a + c) b • p ∈ Set.Ico a (a + p)


case h
α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c✝ : α
n : ℤ
a b c : α
⊢ b - toIcoDiv hp (a + c) b • p ∈ Set.Ico (a + c) (a + c + p)


ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
⊢ (∅ ∪ s₂).lcm f = GCDMonoid.lcm (∅.lcm f) (s₂.lcm f)


ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizedGCDMonoid α
s✝ s₁ s₂ : Finset β
f : β → α
inst✝ : DecidableEq β
a : β
s : Finset β
x✝ : a ∉ s
ih : (s ∪ s₂).lcm f = GCDMonoid.lcm (s.lcm f) (s₂.lcm f)
⊢ (insert a s ∪ s₂).lcm f = GCDMonoid.lcm ((insert a s).lcm f) (s₂.lcm f)


α : Type u
inst✝³ : Group α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c : α
⊢ a⁻¹ < b / c ↔ c < a * b


R : Type u
inst✝¹ : CommRing R
E : EllipticCurve R
inst✝ : Invertible 3
⊢ (ofJ0 R).j = 0


case pos.h
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : Preadditive C
R : Type u_1
inst✝⁴ : Ring R
inst✝³ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
z z' : Cochain K L n
f : K ⟶ L
Φ : C ⥤ D
inst✝ : Φ.Additive
hnm : n + 1 = m
p q : ℤ
hpq : p + m = q
⊢ (δ n m (z.map Φ)).v p q hpq = Φ.map ((δ n m z).v p q hpq)


case neg
C : Type u
inst✝⁶ : Category.{v, u} C
inst✝⁵ : Preadditive C
R : Type u_1
inst✝⁴ : Ring R
inst✝³ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
D : Type u_2
inst✝² : Category.{u_3, u_2} D
inst✝¹ : Preadditive D
z z' : Cochain K L n
f : K ⟶ L
Φ : C ⥤ D
inst✝ : Φ.Additive
hnm : ¬n + 1 = m
⊢ δ n m (z.map Φ) = (δ n m z).map Φ


R : CommRingCat
M : Submonoid ↑R
x : PrimeSpectrum (Localization M)
⊢ IsIso
    (PresheafedSpace.stalkMap (Spec.toPresheafedSpace.map (CommRingCat.ofHom (algebraMap (↑R) (Localization M))).op) x)


R : CommRingCat
M : Submonoid ↑R
x : PrimeSpectrum (Localization M)
⊢ IsIso
    ((stalkIso (↑{ unop := CommRingCat.of ↑R }.unop)
          ((PrimeSpectrum.comap (CommRingCat.ofHom (algebraMap (↑R) (Localization M))).op.unop) x)).hom ≫
      Localization.localRingHom
          ((PrimeSpectrum.comap (CommRingCat.ofHom (algebraMap (↑R) (Localization M))).op.unop) x).asIdeal x.asIdeal
          (CommRingCat.ofHom (algebraMap (↑R) (Localization M))).op.unop ⋯ ≫
        (stalkIso (↑{ unop := CommRingCat.of (Localization M) }.unop) x).inv)


R : CommRingCat
M : Submonoid ↑R
x : PrimeSpectrum (Localization M)
⊢ IsIso
    (Localization.localRingHom
        ((PrimeSpectrum.comap (CommRingCat.ofHom (algebraMap (↑R) (Localization M))).op.unop) x).asIdeal x.asIdeal
        (CommRingCat.ofHom (algebraMap (↑R) (Localization M))).op.unop ⋯ ≫
      (stalkIso (↑{ unop := CommRingCat.of (Localization M) }.unop) x).inv)


R : CommRingCat
M : Submonoid ↑R
x : PrimeSpectrum (Localization M)
⊢ IsIso
    (Localization.localRingHom
      ((PrimeSpectrum.comap (CommRingCat.ofHom (algebraMap (↑R) (Localization M))).op.unop) x).asIdeal x.asIdeal
      (CommRingCat.ofHom (algebraMap (↑R) (Localization M))).op.unop ⋯)


ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
f g : M[ι]
⊢ (f * g).toDirectSum = f.toDirectSum * g.toDirectSum


ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
f g : M[ι]
to_hom : M[ι] →+ ⨁ (x : ι), M := { toFun := toDirectSum, map_zero' := ⋯, map_add' := ⋯ }
⊢ to_hom (f * g) = to_hom f * to_hom g


ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : M[ι] →+ ⨁ (x : ι), M := { toFun := toDirectSum, map_zero' := ⋯, map_add' := ⋯ }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
⊢ ∀ (f g : M[ι]), to_hom (f * g) = to_hom f * to_hom g


ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : M[ι] →+ ⨁ (x : ι), M := { toFun := toDirectSum, map_zero' := ⋯, map_add' := ⋯ }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
⊢ AddMonoidHom.mul.compr₂ to_hom = (AddMonoidHom.mul.comp to_hom).compl₂ to_hom


ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : M[ι] →+ ⨁ (x : ι), M := { toFun := toDirectSum, map_zero' := ⋯, map_add' := ⋯ }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
⊢ ((AddMonoidHom.mul.compr₂ to_hom).comp (Finsupp.singleAddHom xi)) xv =
    (((AddMonoidHom.mul.comp to_hom).compl₂ to_hom).comp (Finsupp.singleAddHom xi)) xv


ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : M[ι] →+ ⨁ (x : ι), M := { toFun := toDirectSum, map_zero' := ⋯, map_add' := ⋯ }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
yi : ι
yv : M
⊢ ((((AddMonoidHom.mul.compr₂ to_hom).comp (Finsupp.singleAddHom xi)) xv).comp (Finsupp.singleAddHom yi)) yv =
    (((((AddMonoidHom.mul.comp to_hom).compl₂ to_hom).comp (Finsupp.singleAddHom xi)) xv).comp
        (Finsupp.singleAddHom yi))
      yv


ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : M[ι] →+ ⨁ (x : ι), M := { toFun := toDirectSum, map_zero' := ⋯, map_add' := ⋯ }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
yi : ι
yv : M
⊢ { toFun := ⇑to_hom ∘ ⇑(AddMonoidHom.mul (Finsupp.single xi xv)), map_zero' := ⋯ } (Finsupp.single yi yv) =
    ((AddMonoidHom.mul.comp to_hom) (Finsupp.single xi xv)) (to_hom (Finsupp.single yi yv))


ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : M[ι] →+ ⨁ (x : ι), M := { toFun := toDirectSum, map_zero' := ⋯, map_add' := ⋯ }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
yi : ι
yv : M
⊢ to_hom (Finsupp.single xi xv * Finsupp.single yi yv) = to_hom (Finsupp.single xi xv) * to_hom (Finsupp.single yi yv)


ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : M[ι] →+ ⨁ (x : ι), M := { toFun := toDirectSum, map_zero' := ⋯, map_add' := ⋯ }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
yi : ι
yv : M
⊢ (DirectSum.of (fun i => M) (xi + yi)) (xv * yv) =
    toDirectSum (Finsupp.single xi xv) * toDirectSum (Finsupp.single yi yv)


ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝² : DecidableEq ι
inst✝¹ : AddMonoid ι
inst✝ : Semiring M
to_hom : M[ι] →+ ⨁ (x : ι), M := { toFun := toDirectSum, map_zero' := ⋯, map_add' := ⋯ }
x✝ : NonUnitalNonAssocSemiring (ι →₀ M) := nonUnitalNonAssocSemiring
xi : ι
xv : M
yi : ι
yv : M
⊢ (DirectSum.of (fun i => M) (xi + yi)) (xv * yv) =
    (DirectSum.of (fun i => M) xi) xv * (DirectSum.of (fun i => M) yi) yv


R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
⊢ P


case pos.intro.intro
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
p : ℕ
H : p > 0
hp : MixedCharZero R p
⊢ P


case neg
R : Type u_1
inst✝¹ : CommRing R
P : Prop
inst✝ : CharZero R
h_equal : Algebra ℚ R → P
h_mixed : ∀ (p : ℕ), Nat.Prime p → MixedCharZero R p → P
h : ¬∃ p > 0, MixedCharZero R p
⊢ Algebra ℚ R


α : Type u_1
xs ys : List α
p : α → Bool
⊢ findIdx? p (xs ++ ys) = HOrElse.hOrElse (findIdx? p xs) fun x => Option.map (fun i => i + xs.length) (findIdx? p ys)


case cons
α : Type u_1
ys : List α
p : α → Bool
head✝ : α
tail✝ : List α
tail_ih✝ :
  findIdx? p (tail✝ ++ ys) =
    HOrElse.hOrElse (findIdx? p tail✝) fun x => Option.map (fun i => i + tail✝.length) (findIdx? p ys)
⊢ (if p head✝ = true then some 0 else Option.map (fun i => i + 1) (findIdx? p (tail✝ ++ ys))) =
    HOrElse.hOrElse (if p head✝ = true then some 0 else Option.map (fun i => i + 1) (findIdx? p tail✝)) fun x =>
      Option.map (fun i => i + (tail✝.length + 1)) (findIdx? p ys)


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


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


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


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 = ⊥


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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 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


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 (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₂))


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₂))


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₂)


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


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₂))


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_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)


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


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


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


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)


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)


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


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


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


C : Type u
inst✝¹ : Category.{v, u} C
X Y Z : Scheme
𝒰 : X.OpenCover
f : X ⟶ Z
g : Y ⟶ Z
inst✝ : ∀ (i : 𝒰.J), HasPullback (𝒰.map i ≫ f) g
i j : 𝒰.J
⊢ t 𝒰 f g i j ≫ pullback.snd = pullback.fst ≫ pullback.fst


α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ max (a / b) (a / c) = a / min b c


V : Type u_1
inst✝¹ : Category.{?u.8360, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ g.unop ≫ f.unop = 0


V : Type u_1
inst✝¹ : Category.{?u.8360, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ f ≫ factorThruImage g = 0


case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ ≫ (kernelSubobject f.unop).arrow =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopUnop g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      (kernelSubobject f.unop).arrow


case h
V : Type u_1
inst✝¹ : Category.{u_2, u_1} V
inst✝ : Abelian V
X Y Z : Vᵒᵖ
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.unop f.unop ⋯ ≫ (kernelSubobject f.unop).arrow =
    ((imageSubobjectIso g.unop ≪≫ (imageUnopOp g).unop.symm).hom ≫
        (cokernel.desc f (factorThruImage g) ⋯).unop ≫ (kernelSubobjectIso f.unop ≪≫ kernelUnopUnop f).inv) ≫
      (kernelSubobject f.unop).arrow


R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj { unop := U })
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i)
hs : ∀ (i : ι), const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) ⋯ = ((structureSheaf R).val.map (iDh i).op) s
⊢ ∃ a' h' iDh',
    U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i) ∧
      (∀ i ∈ t, ∀ j ∈ t, a' i * h' j = h' i * a' j) ∧
        ∀ i ∈ t, ((structureSheaf R).val.map (iDh' i).op) s = const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) ⋯


R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj { unop := U })
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i)
hs : ∀ (i : ι), const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) ⋯ = ((structureSheaf R).val.map (iDh i).op) s
fractions_eq :
  ∀ (i j : ι),
    IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j) ⟨h i * h j, ⋯⟩ =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j) ⟨h i * h j, ⋯⟩
⊢ ∃ a' h' iDh',
    U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i) ∧
      (∀ i ∈ t, ∀ j ∈ t, a' i * h' j = h' i * a' j) ∧
        ∀ i ∈ t, ((structureSheaf R).val.map (iDh' i).op) s = const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) ⋯


R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj { unop := U })
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i)
hs : ∀ (i : ι), const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) ⋯ = ((structureSheaf R).val.map (iDh i).op) s
fractions_eq :
  ∀ (i j : ι),
    IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j) ⟨h i * h j, ⋯⟩ =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j) ⟨h i * h j, ⋯⟩
exists_power : ∀ (i j : ι), ∃ n, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n
⊢ ∃ a' h' iDh',
    U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i) ∧
      (∀ i ∈ t, ∀ j ∈ t, a' i * h' j = h' i * a' j) ∧
        ∀ i ∈ t, ((structureSheaf R).val.map (iDh' i).op) s = const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) ⋯


R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj { unop := U })
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i)
hs : ∀ (i : ι), const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) ⋯ = ((structureSheaf R).val.map (iDh i).op) s
fractions_eq :
  ∀ (i j : ι),
    IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j) ⟨h i * h j, ⋯⟩ =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j) ⟨h i * h j, ⋯⟩
exists_power : ∀ (i j : ι), ∃ n, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n
n : ι × ι → ℕ := fun p => ⋯.choose
⊢ ∃ a' h' iDh',
    U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i) ∧
      (∀ i ∈ t, ∀ j ∈ t, a' i * h' j = h' i * a' j) ∧
        ∀ i ∈ t, ((structureSheaf R).val.map (iDh' i).op) s = const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) ⋯


R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj { unop := U })
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i)
hs : ∀ (i : ι), const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) ⋯ = ((structureSheaf R).val.map (iDh i).op) s
fractions_eq :
  ∀ (i j : ι),
    IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j) ⟨h i * h j, ⋯⟩ =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j) ⟨h i * h j, ⋯⟩
exists_power : ∀ (i j : ι), ∃ n, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n
n : ι × ι → ℕ := fun p => ⋯.choose
n_spec : ∀ (p : ι × ι), a p.1 * h p.2 * (h p.1 * h p.2) ^ ⋯.choose = h p.1 * a p.2 * (h p.1 * h p.2) ^ ⋯.choose
⊢ ∃ a' h' iDh',
    U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i) ∧
      (∀ i ∈ t, ∀ j ∈ t, a' i * h' j = h' i * a' j) ∧
        ∀ i ∈ t, ((structureSheaf R).val.map (iDh' i).op) s = const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) ⋯


R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj { unop := U })
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i)
hs : ∀ (i : ι), const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) ⋯ = ((structureSheaf R).val.map (iDh i).op) s
fractions_eq :
  ∀ (i j : ι),
    IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j) ⟨h i * h j, ⋯⟩ =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j) ⟨h i * h j, ⋯⟩
exists_power : ∀ (i j : ι), ∃ n, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n
n : ι × ι → ℕ := fun p => ⋯.choose
n_spec : ∀ (p : ι × ι), a p.1 * h p.2 * (h p.1 * h p.2) ^ ⋯.choose = h p.1 * a p.2 * (h p.1 * h p.2) ^ ⋯.choose
N : ℕ := (t ×ˢ t).sup n
⊢ ∃ a' h' iDh',
    U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i) ∧
      (∀ i ∈ t, ∀ j ∈ t, a' i * h' j = h' i * a' j) ∧
        ∀ i ∈ t, ((structureSheaf R).val.map (iDh' i).op) s = const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) ⋯


R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj { unop := U })
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i)
hs : ∀ (i : ι), const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) ⋯ = ((structureSheaf R).val.map (iDh i).op) s
fractions_eq :
  ∀ (i j : ι),
    IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j) ⟨h i * h j, ⋯⟩ =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j) ⟨h i * h j, ⋯⟩
exists_power : ∀ (i j : ι), ∃ n, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n
n : ι × ι → ℕ := fun p => ⋯.choose
n_spec : ∀ (p : ι × ι), a p.1 * h p.2 * (h p.1 * h p.2) ^ ⋯.choose = h p.1 * a p.2 * (h p.1 * h p.2) ^ ⋯.choose
N : ℕ := (t ×ˢ t).sup n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
⊢ ∃ a' h' iDh',
    U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h' i) ∧
      (∀ i ∈ t, ∀ j ∈ t, a' i * h' j = h' i * a' j) ∧
        ∀ i ∈ t, ((structureSheaf R).val.map (iDh' i).op) s = const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i)) ⋯


case refine_3
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj { unop := U })
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ i ∈ t, PrimeSpectrum.basicOpen (h i)
hs : ∀ (i : ι), const R (a i) (h i) (PrimeSpectrum.basicOpen (h i)) ⋯ = ((structureSheaf R).val.map (iDh i).op) s
fractions_eq :
  ∀ (i j : ι),
    IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j) ⟨h i * h j, ⋯⟩ =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j) ⟨h i * h j, ⋯⟩
exists_power : ∀ (i j : ι), ∃ n, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n
n : ι × ι → ℕ := fun p => ⋯.choose
n_spec : ∀ (p : ι × ι), a p.1 * h p.2 * (h p.1 * h p.2) ^ ⋯.choose = h p.1 * a p.2 * (h p.1 * h p.2) ^ ⋯.choose
N : ℕ := (t ×ˢ t).sup n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ ((structureSheaf R).val.map ((fun i => eqToHom ⋯ ≫ iDh i) i).op) s =
    const R ((fun i => a i * h i ^ N) i) ((fun i => h i ^ (N + 1)) i)
      (PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i)) ⋯