Theorem: AlgebraicGeometry.StructureSheaf.normalize_finite_fraction_representation
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: have fractions_eq :
  ∀ i j : ι,
    IsLocalization.mk' (Localization.Away (h i * h j))
      (a i * h j) ⟨h i * h j, Submonoid.mem_powers _⟩ =
    IsLocalization.mk' _ (h i * a j) ⟨h i * h j, Submonoid.mem_powers _⟩ := by
  intro i j
  let D := PrimeSpectrum.basicOpen (h i * h j)
  let iDi : D ⟶ PrimeSpectrum.basicOpen (h i) := homOfLE (PrimeSpectrum.basicOpen_mul_le_left _ _)
  let iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
    homOfLE (PrimeSpectrum.basicOpen_mul_le_right _ _)
  apply toBasicOpen_injective R (h i * h j)
  rw [toBasicOpen_mk', toBasicOpen_mk']
  simp only []
  trans
  convert congr_arg ((structureSheaf R).1.map iDj.op) (hs j).symm using 1
  convert congr_arg ((structureSheaf R).1.map iDi.op) (hs i) using 1; swap
  all_goals rw [res_const]; apply const_ext; ring
  exacts [PrimeSpectrum.basicOpen_mul_le_right _ _, PrimeSpectrum.basicOpen_mul_le_left _ _]
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
⊢ ∃ a' h' iDh',
    (U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h' i)) ∧
      (∀ (i : ι), i ∈ t → ∀ (j : ι), j ∈ t → a' i * h' j = h' i * a' j) ∧
        ∀ (i : ι),
          i ∈ t →
            ↑((structureSheaf R).val.map (iDh' i).op) s =
              const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i))
                (_ :
                  ∀ (y : ↑(PrimeSpectrum.Top R)),
                    y ∈ PrimeSpectrum.basicOpen (h' i) → y ∈ PrimeSpectrum.basicOpen (h' i))

tactic: have exists_power :
  ∀ i j : ι, ∃ n : ℕ, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n := by
  intro i j
  obtain ⟨⟨c, n, rfl⟩, hc⟩ := IsLocalization.eq.mp (fractions_eq i j)
  use n + 1
  rw [pow_succ]
  dsimp at hc
  convert hc using 1 <;> ring
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }
⊢ ∃ a' h' iDh',
    (U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h' i)) ∧
      (∀ (i : ι), i ∈ t → ∀ (j : ι), j ∈ t → a' i * h' j = h' i * a' j) ∧
        ∀ (i : ι),
          i ∈ t →
            ↑((structureSheaf R).val.map (iDh' i).op) s =
              const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i))
                (_ :
                  ∀ (y : ↑(PrimeSpectrum.Top R)),
                    y ∈ PrimeSpectrum.basicOpen (h' i) → y ∈ PrimeSpectrum.basicOpen (h' i))

tactic: let n := fun p : ι × ι => (exists_power p.1 p.2).choose
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h' i)) ∧
      (∀ (i : ι), i ∈ t → ∀ (j : ι), j ∈ t → a' i * h' j = h' i * a' j) ∧
        ∀ (i : ι),
          i ∈ t →
            ↑((structureSheaf R).val.map (iDh' i).op) s =
              const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i))
                (_ :
                  ∀ (y : ↑(PrimeSpectrum.Top R)),
                    y ∈ PrimeSpectrum.basicOpen (h' i) → y ∈ PrimeSpectrum.basicOpen (h' i))

tactic: have n_spec := fun p : ι × ι => (exists_power p.fst p.snd).choose_spec
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
⊢ ∃ a' h' iDh',
    (U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h' i)) ∧
      (∀ (i : ι), i ∈ t → ∀ (j : ι), j ∈ t → a' i * h' j = h' i * a' j) ∧
        ∀ (i : ι),
          i ∈ t →
            ↑((structureSheaf R).val.map (iDh' i).op) s =
              const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i))
                (_ :
                  ∀ (y : ↑(PrimeSpectrum.Top R)),
                    y ∈ PrimeSpectrum.basicOpen (h' i) → y ∈ PrimeSpectrum.basicOpen (h' i))

tactic: let N := (t ×ˢ t).sup n
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
⊢ ∃ a' h' iDh',
    (U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h' i)) ∧
      (∀ (i : ι), i ∈ t → ∀ (j : ι), j ∈ t → a' i * h' j = h' i * a' j) ∧
        ∀ (i : ι),
          i ∈ t →
            ↑((structureSheaf R).val.map (iDh' i).op) s =
              const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i))
                (_ :
                  ∀ (y : ↑(PrimeSpectrum.Top R)),
                    y ∈ PrimeSpectrum.basicOpen (h' i) → y ∈ PrimeSpectrum.basicOpen (h' i))

tactic: have basic_opens_eq : ∀ i : ι, PrimeSpectrum.basicOpen (h i ^ (N + 1)) =
  PrimeSpectrum.basicOpen (h i) := fun i => PrimeSpectrum.basicOpen_pow _ _ (by linarith)
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
⊢ ∃ a' h' iDh',
    (U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h' i)) ∧
      (∀ (i : ι), i ∈ t → ∀ (j : ι), j ∈ t → a' i * h' j = h' i * a' j) ∧
        ∀ (i : ι),
          i ∈ t →
            ↑((structureSheaf R).val.map (iDh' i).op) s =
              const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i))
                (_ :
                  ∀ (y : ↑(PrimeSpectrum.Top R)),
                    y ∈ PrimeSpectrum.basicOpen (h' i) → y ∈ PrimeSpectrum.basicOpen (h' i))

tactic: refine'
  ⟨fun i => a i * h i ^ N, fun i => h i ^ (N + 1), fun i => eqToHom (basic_opens_eq i) ≫ iDh i,
    _, _, _⟩
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
⊢ ∃ a' h' iDh',
    (U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h' i)) ∧
      (∀ (i : ι), i ∈ t → ∀ (j : ι), j ∈ t → a' i * h' j = h' i * a' j) ∧
        ∀ (i : ι),
          i ∈ t →
            ↑((structureSheaf R).val.map (iDh' i).op) s =
              const R (a' i) (h' i) (PrimeSpectrum.basicOpen (h' i))
                (_ :
                  ∀ (y : ↑(PrimeSpectrum.Top R)),
                    y ∈ PrimeSpectrum.basicOpen (h' i) → y ∈ PrimeSpectrum.basicOpen (h' i))

tactic: intro i _
state_before: case refine'_3
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
⊢ ∀ (i : ι),
    i ∈ t →
      ↑((structureSheaf R).val.map
              ((fun i => eqToHom (_ : PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)) ≫ 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))
          (_ :
            ∀ (y : ↑(PrimeSpectrum.Top R)),
              y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i) →
                y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i))

tactic: rw [op_comp, Functor.map_comp]
state_before: case refine'_3
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) 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 (_ : PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)) ≫ 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))
      (_ :
        ∀ (y : ↑(PrimeSpectrum.Top R)),
          y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i) →
            y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i))

tactic: change (structureSheaf R).1.map (eqToHom (basic_opens_eq _)).op
  ((structureSheaf R).1.map (iDh i).op s) = _
state_before: case refine'_3
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ ↑((structureSheaf R).val.map (iDh i).op ≫
          (structureSheaf R).val.map
            (eqToHom (_ : PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h 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))
      (_ :
        ∀ (y : ↑(PrimeSpectrum.Top R)),
          y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i) →
            y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i))

tactic: rw [← hs, res_const]
state_before: case refine'_3
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ ↑((structureSheaf R).val.map
          (eqToHom (_ : PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i))).op)
      (↑((structureSheaf R).val.map (iDh 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))
      (_ :
        ∀ (y : ↑(PrimeSpectrum.Top R)),
          y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i) →
            y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i))

tactic: swap
state_before: case refine'_3
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ const R (a i) (h i) (PrimeSpectrum.basicOpen (h i ^ (N + 1))) ?refine'_3.hv =
    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))
      (_ :
        ∀ (y : ↑(PrimeSpectrum.Top R)),
          y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i) →
            y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i))

case refine'_3.hv
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ PrimeSpectrum.basicOpen (h i ^ (N + 1)) → h i ∈ Ideal.primeCompl x.asIdeal

tactic: exact (basic_opens_eq i).le
state_before: case refine'_3.hv
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ PrimeSpectrum.basicOpen (h i ^ (N + 1)) → h i ∈ Ideal.primeCompl x.asIdeal

case refine'_3
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ const R (a i) (h i) (PrimeSpectrum.basicOpen (h i ^ (N + 1))) ?refine'_3.hv =
    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))
      (_ :
        ∀ (y : ↑(PrimeSpectrum.Top R)),
          y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i) →
            y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i))

tactic: apply const_ext
state_before: case refine'_3
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ const R (a i) (h i) (PrimeSpectrum.basicOpen (h i ^ (N + 1)))
      (_ : PrimeSpectrum.basicOpen (h i ^ (N + 1)) ≤ PrimeSpectrum.basicOpen (h i)) =
    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))
      (_ :
        ∀ (y : ↑(PrimeSpectrum.Top R)),
          y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i) →
            y ∈ PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i))

tactic: dsimp
state_before: case refine'_3.h
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ a i * (fun i => h i ^ (N + 1)) i = (fun i => a i * h i ^ N) i * h i

tactic: rw [pow_succ]
state_before: case refine'_3.h
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ a i *
      h i ^
        ((Finset.sup (t ×ˢ t) fun p =>
            Exists.choose
              (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)) +
          1) =
    (a i *
        h i ^
          Finset.sup (t ×ˢ t) fun p =>
            Exists.choose
              (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)) *
      h i

tactic: ring
state_before: case refine'_3.h
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
a✝ : i ∈ t
⊢ a i *
      (h i *
        h i ^
          Finset.sup (t ×ˢ t) fun p =>
            Exists.choose
              (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)) =
    (a i *
        h i ^
          Finset.sup (t ×ˢ t) fun p =>
            Exists.choose
              (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)) *
      h i

tactic: intro i j
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
⊢ ∀ (i j : ι),
    IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }

tactic: let D := PrimeSpectrum.basicOpen (h i * h j)
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
⊢ IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j)
      { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
    IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
      { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }

tactic: let iDi : D ⟶ PrimeSpectrum.basicOpen (h i) := homOfLE (PrimeSpectrum.basicOpen_mul_le_left _ _)
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
⊢ IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j)
      { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
    IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
      { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }

tactic: let iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (PrimeSpectrum.basicOpen_mul_le_right _ _)
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
⊢ IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j)
      { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
    IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
      { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }

tactic: apply toBasicOpen_injective R (h i * h j)
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j)
      { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
    IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
      { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }

tactic: rw [toBasicOpen_mk', toBasicOpen_mk']
state_before: case a
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ ↑(toBasicOpen R (h i * h j))
      (IsLocalization.mk' (Localization.Away (h i * h j)) (a i * h j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }) =
    ↑(toBasicOpen R (h i * h j))
      (IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) })

tactic: simp only []
state_before: case a
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ const R (a i * h j) (↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) })
      (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal) =
    const R (h i * a j) (↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) })
      (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal)

tactic: trans
state_before: case a
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ const R (a i * h j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal) =
    const R (h i * a j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal)

tactic: convert congr_arg ((structureSheaf R).1.map iDj.op) (hs j).symm using 1
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ const R (a i * h j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal) =
    ?m.863124

R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ ?m.863124 =
    const R (h i * a j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal)

R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ ↑((structureSheaf R).val.obj (PrimeSpectrum.basicOpen (h i * h j)).op)

tactic: convert congr_arg ((structureSheaf R).1.map iDi.op) (hs i) using 1
state_before: case h.e'_2
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ const R (a i * h j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal) =
    ↑((structureSheaf R).val.map iDj.op) (↑((structureSheaf R).val.map (iDh j).op) s)

R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ ↑((structureSheaf R).val.map iDj.op)
      (const R (a j) (h j) (PrimeSpectrum.basicOpen (h j))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h j) → y ∈ PrimeSpectrum.basicOpen (h j))) =
    const R (h i * a j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal)

tactic: swap
state_before: case h.e'_2
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ const R (a i * h j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal) =
    ↑((structureSheaf R).val.map iDi.op)
      (const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)))

R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ ↑((structureSheaf R).val.map iDj.op)
      (const R (a j) (h j) (PrimeSpectrum.basicOpen (h j))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h j) → y ∈ PrimeSpectrum.basicOpen (h j))) =
    const R (h i * a j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal)

tactic: all_goals rw [res_const]; apply const_ext; ring
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ ↑((structureSheaf R).val.map iDj.op)
      (const R (a j) (h j) (PrimeSpectrum.basicOpen (h j))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h j) → y ∈ PrimeSpectrum.basicOpen (h j))) =
    const R (h i * a j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal)

case h.e'_2
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ const R (a i * h j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal) =
    ↑((structureSheaf R).val.map iDi.op)
      (const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)))

tactic: exacts [PrimeSpectrum.basicOpen_mul_le_right _ _, PrimeSpectrum.basicOpen_mul_le_left _ _]
state_before: case hv
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ D → h j ∈ Ideal.primeCompl x.asIdeal

case h.e'_2.hv
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ D → h i ∈ Ideal.primeCompl x.asIdeal

tactic: rw [res_const]
state_before: case h.e'_2
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ const R (a i * h j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal) =
    ↑((structureSheaf R).val.map iDi.op)
      (const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)))

tactic: apply const_ext
state_before: case h.e'_2
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ const R (a i * h j) (h i * h j) (PrimeSpectrum.basicOpen (h i * h j))
      (_ :
        ∀ (x : ↑(PrimeSpectrum.Top R)),
          x ∈ PrimeSpectrum.basicOpen (h i * h j) →
            ↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } ∈
              Ideal.primeCompl x.asIdeal) =
    const R (a i) (h i) D ?h.e'_2.hv

case h.e'_2.hv
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ D → h i ∈ Ideal.primeCompl x.asIdeal

tactic: ring
state_before: case h.e'_2.h
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ a i * h j * h i = a i * (h i * h j)

case h.e'_2.hv
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ PrimeSpectrum.basicOpen (h i)) =
      ↑((structureSheaf R).val.map (iDh i).op) s
i j : ι
D : Opens (PrimeSpectrum R) := PrimeSpectrum.basicOpen (h i * h j)
iDi : D ⟶ PrimeSpectrum.basicOpen (h i) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h i))
iDj : D ⟶ PrimeSpectrum.basicOpen (h j) :=
  homOfLE (_ : PrimeSpectrum.basicOpen (h i * h j) ≤ PrimeSpectrum.basicOpen (h j))
⊢ ∀ (x : ↑(PrimeSpectrum.Top R)), x ∈ D → h i ∈ Ideal.primeCompl x.asIdeal

tactic: intro i j
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }
⊢ ∀ (i j : ι), ∃ n, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n

tactic: obtain ⟨⟨c, n, rfl⟩, hc⟩ := IsLocalization.eq.mp (fractions_eq i j)
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }
i j : ι
⊢ ∃ n, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n

tactic: use n + 1
state_before: case intro.mk.intro
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }
i j : ι
n : ℕ
hc :
  ↑{ val := (fun x x_1 => x ^ x_1) (h i * h j) n,
          property := (_ : ∃ y, (fun x x_1 => x ^ x_1) (h i * h j) y = (fun x x_1 => x ^ x_1) (h i * h j) n) } *
      (↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } * (a i * h j)) =
    ↑{ val := (fun x x_1 => x ^ x_1) (h i * h j) n,
          property := (_ : ∃ y, (fun x x_1 => x ^ x_1) (h i * h j) y = (fun x x_1 => x ^ x_1) (h i * h j) n) } *
      (↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } * (h i * a j))
⊢ ∃ n, a i * h j * (h i * h j) ^ n = h i * a j * (h i * h j) ^ n

tactic: rw [pow_succ]
state_before: case intro.mk.intro
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }
i j : ι
n : ℕ
hc :
  ↑{ val := (fun x x_1 => x ^ x_1) (h i * h j) n,
          property := (_ : ∃ y, (fun x x_1 => x ^ x_1) (h i * h j) y = (fun x x_1 => x ^ x_1) (h i * h j) n) } *
      (↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } * (a i * h j)) =
    ↑{ val := (fun x x_1 => x ^ x_1) (h i * h j) n,
          property := (_ : ∃ y, (fun x x_1 => x ^ x_1) (h i * h j) y = (fun x x_1 => x ^ x_1) (h i * h j) n) } *
      (↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } * (h i * a j))
⊢ a i * h j * (h i * h j) ^ (n + 1) = h i * a j * (h i * h j) ^ (n + 1)

tactic: dsimp at hc
state_before: case intro.mk.intro
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }
i j : ι
n : ℕ
hc :
  ↑{ val := (fun x x_1 => x ^ x_1) (h i * h j) n,
          property := (_ : ∃ y, (fun x x_1 => x ^ x_1) (h i * h j) y = (fun x x_1 => x ^ x_1) (h i * h j) n) } *
      (↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } * (a i * h j)) =
    ↑{ val := (fun x x_1 => x ^ x_1) (h i * h j) n,
          property := (_ : ∃ y, (fun x x_1 => x ^ x_1) (h i * h j) y = (fun x x_1 => x ^ x_1) (h i * h j) n) } *
      (↑{ val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } * (h i * a j))
⊢ a i * h j * (h i * h j * (h i * h j) ^ n) = h i * a j * (h i * h j * (h i * h j) ^ n)

tactic: convert hc using 1 <;> ring
state_before: case intro.mk.intro
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) }
i j : ι
n : ℕ
hc : (h i * h j) ^ n * (h i * h j * (a i * h j)) = (h i * h j) ^ n * (h i * h j * (h i * a j))
⊢ a i * h j * (h i * h j * (h i * h j) ^ n) = h i * a j * (h i * h j * (h i * h j) ^ n)

tactic: linarith
state_before: R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
i : ι
⊢ 0 < N + 1

tactic: simpa only [basic_opens_eq] using h_cover
state_before: case refine'_1
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
⊢ U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen ((fun i => h i ^ (N + 1)) i)

tactic: intro i hi j hj
state_before: case refine'_2
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
⊢ ∀ (i : ι),
    i ∈ t →
      ∀ (j : ι),
        j ∈ t →
          (fun i => a i * h i ^ N) i * (fun i => h i ^ (N + 1)) j =
            (fun i => h i ^ (N + 1)) i * (fun i => a i * h i ^ N) j

tactic: have n_le_N : n (i, j) ≤ N := Finset.le_sup (Finset.mem_product.mpr ⟨hi, hj⟩)
state_before: case refine'_2
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
hi : i ∈ t
j : ι
hj : j ∈ t
⊢ (fun i => a i * h i ^ N) i * (fun i => h i ^ (N + 1)) j = (fun i => h i ^ (N + 1)) i * (fun i => a i * h i ^ N) j

tactic: cases' Nat.le.dest n_le_N with k hk
state_before: case refine'_2
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
hi : i ∈ t
j : ι
hj : j ∈ t
n_le_N : n (i, j) ≤ N
⊢ (fun i => a i * h i ^ N) i * (fun i => h i ^ (N + 1)) j = (fun i => h i ^ (N + 1)) i * (fun i => a i * h i ^ N) j

tactic: simp only [← hk, pow_add, pow_one]
state_before: case refine'_2.intro
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
hi : i ∈ t
j : ι
hj : j ∈ t
n_le_N : n (i, j) ≤ N
k : ℕ
hk : n (i, j) + k = N
⊢ (fun i => a i * h i ^ N) i * (fun i => h i ^ (N + 1)) j = (fun i => h i ^ (N + 1)) i * (fun i => a i * h i ^ N) j

tactic: simp only [mul_pow]
state_before: case h.e'_3
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
hi : i ∈ t
j : ι
hj : j ∈ t
n_le_N : n (i, j) ≤ N
k : ℕ
hk : n (i, j) + k = N
⊢ h i ^
            Exists.choose
              (_ :
                ∃ n,
                  a (i, j).fst * h (i, j).snd * (h (i, j).fst * h (i, j).snd) ^ n =
                    h (i, j).fst * a (i, j).snd * (h (i, j).fst * h (i, j).snd) ^ n) *
          h i ^ k *
        h i *
      (a j *
        (h j ^
            Exists.choose
              (_ :
                ∃ n,
                  a (i, j).fst * h (i, j).snd * (h (i, j).fst * h (i, j).snd) ^ n =
                    h (i, j).fst * a (i, j).snd * (h (i, j).fst * h (i, j).snd) ^ n) *
          h j ^ k)) =
    h (i, j).fst * a (i, j).snd *
        (h (i, j).fst * h (i, j).snd) ^
          Exists.choose
            (_ :
              ∃ n,
                a (i, j).fst * h (i, j).snd * (h (i, j).fst * h (i, j).snd) ^ n =
                  h (i, j).fst * a (i, j).snd * (h (i, j).fst * h (i, j).snd) ^ n) *
      (h i * h j) ^ k

tactic: ring
state_before: case h.e'_3
R : Type u
inst✝ : CommRing R
U : Opens ↑(PrimeSpectrum.Top R)
s : ↑((structureSheaf R).val.obj U.op)
ι : Type u_1
t : Finset ι
a h : ι → R
iDh : (i : ι) → PrimeSpectrum.basicOpen (h i) ⟶ U
h_cover : U ≤ ⨆ (i : ι) (_ : i ∈ t), PrimeSpectrum.basicOpen (h i)
hs :
  ∀ (i : ι),
    const R (a i) (h i) (PrimeSpectrum.basicOpen (h i))
        (_ : ∀ (y : ↑(PrimeSpectrum.Top R)), y ∈ PrimeSpectrum.basicOpen (h i) → y ∈ 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)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (h i * h j)) } =
      IsLocalization.mk' (Localization.Away (h i * h j)) (h i * a j)
        { val := h i * h j, property := (_ : h i * h j ∈ Submonoid.powers (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 =>
    Exists.choose (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
n_spec :
  ∀ (p : ι × ι),
    a p.fst * h p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n) =
      h p.fst * a p.snd *
        (h p.fst * h p.snd) ^
          Exists.choose
            (_ : ∃ n, a p.fst * h p.snd * (h p.fst * h p.snd) ^ n = h p.fst * a p.snd * (h p.fst * h p.snd) ^ n)
N : ℕ := Finset.sup (t ×ˢ t) n
basic_opens_eq : ∀ (i : ι), PrimeSpectrum.basicOpen (h i ^ (N + 1)) = PrimeSpectrum.basicOpen (h i)
i : ι
hi : i ∈ t
j : ι
hj : j ∈ t
n_le_N : n (i, j) ≤ N
k : ℕ
hk : n (i, j) + k = N
⊢ h i ^ Exists.choose (_ : ∃ a_1, (fun n => a i * h j * (h i ^ n * h j ^ n) = h i * a j * (h i ^ n * h j ^ n)) a_1) *
          h i ^ k *
        h i *
      (a j *
        (h j ^
            Exists.choose
              (_ : ∃ a_1, (fun n => a i * h j * (h i ^ n * h j ^ n) = h i * a j * (h i ^ n * h j ^ n)) a_1) *
          h j ^ k)) =
    h i * a j *
        (h i ^
            Exists.choose
              (_ : ∃ a_1, (fun a_2 => a i * h j * (h i ^ a_2 * h j ^ a_2) = h i * a j * (h i ^ a_2 * h j ^ a_2)) a_1) *
          h j ^
            Exists.choose
              (_ : ∃ a_1, (fun a_2 => a i * h j * (h i ^ a_2 * h j ^ a_2) = h i * a j * (h i ^ a_2 * h j ^ a_2)) a_1)) *
      (h i ^ k * h j ^ k)