FormalConjectures.ErdosProblems.«951»

/-
Copyright 2026 The Formal Conjectures Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-/

import FormalConjecturesUtil

Erdős Problem 951

References:

erdosproblems.com/951

[Er77c] Erdős, Paul, Problems and results on combinatorial number theory. III. Number theory day (Proc. Conf., Rockefeller Univ., New York, 1976) (1977), 43-72.


open scoped Finsupp Nat.Prime Topology

open Filter


namespace Erdos951

A sequence a : ℕ → ℝ is said to have property Erdos951Prop if for any pair of distinct finitely supported sequences k l : ℕ →₀ ℕ their corresponding Beurling integers are of distance at least one apart.

def Erdos951Prop (a : ℕ → ℝ) : Prop :=
  ∀ (k ℓ : ℕ →₀ ℕ), k ≠ ℓ → |beurlingInteger a k - beurlingInteger a ℓ| ≥ 1

If a has property Erdos951Prop and 1 < a 0, then a is a set of Beurling prime numbers.

@[category API, AMS 11]
theorem erdos_951.variants.isBeurlingPrimes {a : ℕ → ℝ} (ha : 1 < a 0)
    (hm : StrictMono a) (he : Erdos951Prop a) :
    IsBeurlingPrimes a := bya:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop a⊢ IsBeurlingPrimes a
  refine ⟨ha, hm, tendsto_atTop_atTop.2 fun x => ?_⟩a:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop ax:ℝ⊢ ∃ i, ∀ (a_1 : ℕ), i ≤ a_1 → x ≤ a a_1
  by_contra h_contraa:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop ax:ℝh_contra:¬∃ i, ∀ (a_1 : ℕ), i ≤ a_1 → x ≤ a a_1⊢ False
  obtain ⟨L, hL⟩ : ∃ L, Filter.Tendsto a Filter.atTop (𝓝 L) :=
    ⟨_, tendsto_atTop_isLUB hm.monotone (isLUB_ciSup ⟨x, Set.forall_mem_range.2 fun n =>
    le_of_not_ge fun hn => h_contra ⟨n, fun m hm' => hn.trans (hm.monotone hm')⟩⟩)⟩a:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop ax:ℝh_contra:¬∃ i, ∀ (a_1 : ℕ), i ≤ a_1 → x ≤ a a_1L:ℝhL:Tendsto a atTop (𝓝 L)⊢ False
  obtain ⟨N, hN⟩ := Metric.tendsto_atTop.mp hL (1 / 2) (bya:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop ax:ℝh_contra:¬∃ i, ∀ (a_1 : ℕ), i ≤ a_1 → x ≤ a a_1L:ℝhL:Tendsto a atTop (𝓝 L)⊢ 1 / 2 > 0 norm_numAll goals completed! 🐙)
  have := hm (bya:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop ax:ℝh_contra:¬∃ i, ∀ (a_1 : ℕ), i ≤ a_1 → x ≤ a a_1L:ℝhL:Tendsto a atTop (𝓝 L)N:ℕhN:∀ n ≥ N, dist (a n) L < 1 / 2⊢ N < N + 1 linarithAll goals completed! 🐙 : N < N + 1)
  have h_diff : a (N + 1) - a N ≥ 1 := bya:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop a⊢ IsBeurlingPrimes a
    rw [← abs_of_nonneg (by linarith : 0 ≤ a _ - _)]a:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop ax:ℝh_contra:¬∃ i, ∀ (a_1 : ℕ), i ≤ a_1 → x ≤ a a_1L:ℝhL:Tendsto a atTop (𝓝 L)N:ℕhN:∀ n ≥ N, dist (a n) L < 1 / 2this:a N < a (N + 1) := 
  hm
    (lt_of_not_ge fun a =>
      Mathlib.Tactic.Linarith.lt_irrefl
        (Eq.mp
          (congrArg (fun _a => _a < 0)
            (Mathlib.Tactic.Ring.of_eq
              (Mathlib.Tactic.Ring.add_congr
                (Mathlib.Tactic.Ring.neg_congr
                  (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                  (Mathlib.Tactic.Ring.neg_add
                    (Mathlib.Tactic.Ring.neg_one_mul
                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                          (Eq.refl (Int.negOfNat 1)))))
                    Mathlib.Tactic.Ring.neg_zero))
                (Mathlib.Tactic.Ring.sub_congr
                  (Mathlib.Tactic.Ring.add_congr (Mathlib.Tactic.Ring.atom_pf ↑N)
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                    (Mathlib.Tactic.Ring.add_pf_add_gt (Nat.rawCast 1)
                      (Mathlib.Tactic.Ring.add_pf_add_zero (↑N ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                  (Mathlib.Tactic.Ring.atom_pf ↑N)
                  (Mathlib.Tactic.Ring.sub_pf
                    (Mathlib.Tactic.Ring.neg_add
                      (Mathlib.Tactic.Ring.neg_mul (↑N) (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                              (Eq.refl (Int.negOfNat 1))))))
                      Mathlib.Tactic.Ring.neg_zero)
                    (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Tactic.Ring.add_overlap_pf_zero (↑N) (Nat.rawCast 1)
                          (Mathlib.Meta.NormNum.IsInt.to_isNat
                            (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0)))))
                        (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                  (Mathlib.Meta.NormNum.IsInt.to_isNat
                    (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                      (Eq.refl (Int.ofNat 0))))
                  (Mathlib.Tactic.Ring.add_pf_zero_add 0)))
              (Mathlib.Tactic.Ring.cast_zero (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 0)))))
          (Mathlib.Tactic.Linarith.add_lt_of_neg_of_le (neg_neg_of_pos Mathlib.Tactic.Linarith.zero_lt_one)
            (Mathlib.Tactic.Linarith.sub_nonpos_of_le
              (id
                (Eq.mp
                  (Eq.trans (Mathlib.Tactic.Zify.natCast_le._simp_1 (N + 1) N)
                    (congrArg (fun x => x ≤ ↑N) (Eq.trans (Nat.cast_add N 1) (congrArg (HAdd.hAdd ↑N) Nat.cast_one))))
                  a))))))⊢ |a (N + 1) - a N| ≥ 1
    simpa using he (.single (N + 1) 1) (.single N 1) (bya:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop ax:ℝh_contra:¬∃ i, ∀ (a_1 : ℕ), i ≤ a_1 → x ≤ a a_1L:ℝhL:Tendsto a atTop (𝓝 L)N:ℕhN:∀ n ≥ N, dist (a n) L < 1 / 2this:a N < a (N + 1) := 
  hm
    (lt_of_not_ge fun a =>
      Mathlib.Tactic.Linarith.lt_irrefl
        (Eq.mp
          (congrArg (fun _a => _a < 0)
            (Mathlib.Tactic.Ring.of_eq
              (Mathlib.Tactic.Ring.add_congr
                (Mathlib.Tactic.Ring.neg_congr
                  (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                  (Mathlib.Tactic.Ring.neg_add
                    (Mathlib.Tactic.Ring.neg_one_mul
                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                          (Eq.refl (Int.negOfNat 1)))))
                    Mathlib.Tactic.Ring.neg_zero))
                (Mathlib.Tactic.Ring.sub_congr
                  (Mathlib.Tactic.Ring.add_congr (Mathlib.Tactic.Ring.atom_pf ↑N)
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                    (Mathlib.Tactic.Ring.add_pf_add_gt (Nat.rawCast 1)
                      (Mathlib.Tactic.Ring.add_pf_add_zero (↑N ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                  (Mathlib.Tactic.Ring.atom_pf ↑N)
                  (Mathlib.Tactic.Ring.sub_pf
                    (Mathlib.Tactic.Ring.neg_add
                      (Mathlib.Tactic.Ring.neg_mul (↑N) (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                              (Eq.refl (Int.negOfNat 1))))))
                      Mathlib.Tactic.Ring.neg_zero)
                    (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Tactic.Ring.add_overlap_pf_zero (↑N) (Nat.rawCast 1)
                          (Mathlib.Meta.NormNum.IsInt.to_isNat
                            (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0)))))
                        (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                  (Mathlib.Meta.NormNum.IsInt.to_isNat
                    (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                      (Eq.refl (Int.ofNat 0))))
                  (Mathlib.Tactic.Ring.add_pf_zero_add 0)))
              (Mathlib.Tactic.Ring.cast_zero (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 0)))))
          (Mathlib.Tactic.Linarith.add_lt_of_neg_of_le (neg_neg_of_pos Mathlib.Tactic.Linarith.zero_lt_one)
            (Mathlib.Tactic.Linarith.sub_nonpos_of_le
              (id
                (Eq.mp
                  (Eq.trans (Mathlib.Tactic.Zify.natCast_le._simp_1 (N + 1) N)
                    (congrArg (fun x => x ≤ ↑N) (Eq.trans (Nat.cast_add N 1) (congrArg (HAdd.hAdd ↑N) Nat.cast_one))))
                  a))))))⊢ (fun₀ | N + 1 => 1) ≠ fun₀ | N => 1 simpa [Finsupp.ext_iff] using ⟨N, bya:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop ax:ℝh_contra:¬∃ i, ∀ (a_1 : ℕ), i ≤ a_1 → x ≤ a a_1L:ℝhL:Tendsto a atTop (𝓝 L)N:ℕhN:∀ n ≥ N, dist (a n) L < 1 / 2this:a N < a (N + 1) := 
  hm
    (lt_of_not_ge fun a =>
      Mathlib.Tactic.Linarith.lt_irrefl
        (Eq.mp
          (congrArg (fun _a => _a < 0)
            (Mathlib.Tactic.Ring.of_eq
              (Mathlib.Tactic.Ring.add_congr
                (Mathlib.Tactic.Ring.neg_congr
                  (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                  (Mathlib.Tactic.Ring.neg_add
                    (Mathlib.Tactic.Ring.neg_one_mul
                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                          (Eq.refl (Int.negOfNat 1)))))
                    Mathlib.Tactic.Ring.neg_zero))
                (Mathlib.Tactic.Ring.sub_congr
                  (Mathlib.Tactic.Ring.add_congr (Mathlib.Tactic.Ring.atom_pf ↑N)
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                    (Mathlib.Tactic.Ring.add_pf_add_gt (Nat.rawCast 1)
                      (Mathlib.Tactic.Ring.add_pf_add_zero (↑N ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                  (Mathlib.Tactic.Ring.atom_pf ↑N)
                  (Mathlib.Tactic.Ring.sub_pf
                    (Mathlib.Tactic.Ring.neg_add
                      (Mathlib.Tactic.Ring.neg_mul (↑N) (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                              (Eq.refl (Int.negOfNat 1))))))
                      Mathlib.Tactic.Ring.neg_zero)
                    (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Tactic.Ring.add_overlap_pf_zero (↑N) (Nat.rawCast 1)
                          (Mathlib.Meta.NormNum.IsInt.to_isNat
                            (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0)))))
                        (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                  (Mathlib.Meta.NormNum.IsInt.to_isNat
                    (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                      (Eq.refl (Int.ofNat 0))))
                  (Mathlib.Tactic.Ring.add_pf_zero_add 0)))
              (Mathlib.Tactic.Ring.cast_zero (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 0)))))
          (Mathlib.Tactic.Linarith.add_lt_of_neg_of_le (neg_neg_of_pos Mathlib.Tactic.Linarith.zero_lt_one)
            (Mathlib.Tactic.Linarith.sub_nonpos_of_le
              (id
                (Eq.mp
                  (Eq.trans (Mathlib.Tactic.Zify.natCast_le._simp_1 (N + 1) N)
                    (congrArg (fun x => x ≤ ↑N) (Eq.trans (Nat.cast_add N 1) (congrArg (HAdd.hAdd ↑N) Nat.cast_one))))
                  a))))))⊢ ¬(fun₀ | N + 1 => 1) N = (fun₀ | N => 1) N simpAll goals completed! 🐙⟩)
  linarith [abs_lt.1 (hN N le_rfl), abs_lt.1 (hN (N + 1) (bya:ℕ → ℝha:1 < a 0hm:StrictMono ahe:Erdos951Prop ax:ℝh_contra:¬∃ i, ∀ (a_1 : ℕ), i ≤ a_1 → x ≤ a a_1L:ℝhL:Tendsto a atTop (𝓝 L)N:ℕhN:∀ n ≥ N, dist (a n) L < 1 / 2this:a N < a (N + 1) := 
  hm
    (lt_of_not_ge fun a =>
      Mathlib.Tactic.Linarith.lt_irrefl
        (Eq.mp
          (congrArg (fun _a => _a < 0)
            (Mathlib.Tactic.Ring.of_eq
              (Mathlib.Tactic.Ring.add_congr
                (Mathlib.Tactic.Ring.neg_congr
                  (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                  (Mathlib.Tactic.Ring.neg_add
                    (Mathlib.Tactic.Ring.neg_one_mul
                      (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                        (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                          (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                          (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                          (Eq.refl (Int.negOfNat 1)))))
                    Mathlib.Tactic.Ring.neg_zero))
                (Mathlib.Tactic.Ring.sub_congr
                  (Mathlib.Tactic.Ring.add_congr (Mathlib.Tactic.Ring.atom_pf ↑N)
                    (Mathlib.Tactic.Ring.cast_pos (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 1)))
                    (Mathlib.Tactic.Ring.add_pf_add_gt (Nat.rawCast 1)
                      (Mathlib.Tactic.Ring.add_pf_add_zero (↑N ^ Nat.rawCast 1 * Nat.rawCast 1 + 0))))
                  (Mathlib.Tactic.Ring.atom_pf ↑N)
                  (Mathlib.Tactic.Ring.sub_pf
                    (Mathlib.Tactic.Ring.neg_add
                      (Mathlib.Tactic.Ring.neg_mul (↑N) (Nat.rawCast 1)
                        (Mathlib.Tactic.Ring.neg_one_mul
                          (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                            (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                              (Eq.refl (Int.negOfNat 1))))))
                      Mathlib.Tactic.Ring.neg_zero)
                    (Mathlib.Tactic.Ring.add_pf_add_lt (Nat.rawCast 1)
                      (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                        (Mathlib.Tactic.Ring.add_overlap_pf_zero (↑N) (Nat.rawCast 1)
                          (Mathlib.Meta.NormNum.IsInt.to_isNat
                            (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                              (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                              (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0)))))
                        (Mathlib.Tactic.Ring.add_pf_zero_add 0)))))
                (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                  (Mathlib.Meta.NormNum.IsInt.to_isNat
                    (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                      (Mathlib.Meta.NormNum.IsInt.of_raw ℤ (Int.negOfNat 1))
                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℤ 1))
                      (Eq.refl (Int.ofNat 0))))
                  (Mathlib.Tactic.Ring.add_pf_zero_add 0)))
              (Mathlib.Tactic.Ring.cast_zero (Mathlib.Meta.NormNum.isNat_ofNat ℤ (Eq.refl 0)))))
          (Mathlib.Tactic.Linarith.add_lt_of_neg_of_le (neg_neg_of_pos Mathlib.Tactic.Linarith.zero_lt_one)
            (Mathlib.Tactic.Linarith.sub_nonpos_of_le
              (id
                (Eq.mp
                  (Eq.trans (Mathlib.Tactic.Zify.natCast_le._simp_1 (N + 1) N)
                    (congrArg (fun x => x ≤ ↑N) (Eq.trans (Nat.cast_add N 1) (congrArg (HAdd.hAdd ↑N) Nat.cast_one))))
                  a))))))h_diff:a (N + 1) - a N ≥ 1 := 
  Eq.mpr
    (id
      (congrArg (fun _a => _a ≥ 1)
        (Eq.symm
          (abs_of_nonneg
            (le_of_not_gt fun a_1 =>
              Mathlib.Tactic.Linarith.lt_irrefl
                (Eq.mp
                  (congrArg (fun _a => _a < 0)
                    (Mathlib.Tactic.Ring.of_eq
                      (Mathlib.Tactic.Ring.add_congr
                        (Mathlib.Tactic.Ring.sub_congr (Mathlib.Tactic.Ring.atom_pf (a N))
                          (Mathlib.Tactic.Ring.atom_pf (a (N + 1)))
                          (Mathlib.Tactic.Ring.sub_pf
                            (Mathlib.Tactic.Ring.neg_add
                              (Mathlib.Tactic.Ring.neg_mul (a (N + 1)) (Nat.rawCast 1)
                                (Mathlib.Tactic.Ring.neg_one_mul
                                  (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                    (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                      (Mathlib.Meta.NormNum.IsInt.of_raw ℝ (Int.negOfNat 1))
                                      (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℝ 1))
                                      (Eq.refl (Int.negOfNat 1))))))
                              Mathlib.Tactic.Ring.neg_zero)
                            (Mathlib.Tactic.Ring.add_pf_add_lt (a N ^ Nat.rawCast 1 * Nat.rawCast 1)
                              (Mathlib.Tactic.Ring.add_pf_zero_add
                                (a (N + 1) ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast + 0)))))
                        (Mathlib.Tactic.Ring.sub_congr
                          (Mathlib.Tactic.Ring.sub_congr (Mathlib.Tactic.Ring.atom_pf (a (N + 1)))
                            (Mathlib.Tactic.Ring.atom_pf (a N))
                            (Mathlib.Tactic.Ring.sub_pf
                              (Mathlib.Tactic.Ring.neg_add
                                (Mathlib.Tactic.Ring.neg_mul (a N) (Nat.rawCast 1)
                                  (Mathlib.Tactic.Ring.neg_one_mul
                                    (Mathlib.Meta.NormNum.IsInt.to_raw_eq
                                      (Mathlib.Meta.NormNum.isInt_mul (Eq.refl HMul.hMul)
                                        (Mathlib.Meta.NormNum.IsInt.of_raw ℝ (Int.negOfNat 1))
                                        (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℝ 1))
                                        (Eq.refl (Int.negOfNat 1))))))
                                Mathlib.Tactic.Ring.neg_zero)
                              (Mathlib.Tactic.Ring.add_pf_add_gt (a N ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast)
                                (Mathlib.Tactic.Ring.add_pf_add_zero (a (N + 1) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0)))))
                          (Mathlib.Tactic.Ring.cast_zero (Mathlib.Meta.NormNum.isNat_ofNat ℝ Nat.cast_zero))
                          (Mathlib.Tactic.Ring.sub_pf Mathlib.Tactic.Ring.neg_zero
                            (Mathlib.Tactic.Ring.add_pf_add_zero
                              (a N ^ Nat.rawCast 1 * (Int.negOfNat 1).rawCast +
                                (a (N + 1) ^ Nat.rawCast 1 * Nat.rawCast 1 + 0)))))
                        (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                          (Mathlib.Tactic.Ring.add_overlap_pf_zero (a N) (Nat.rawCast 1)
                            (Mathlib.Meta.NormNum.IsInt.to_isNat
                              (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                                (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℝ 1))
                                (Mathlib.Meta.NormNum.IsInt.of_raw ℝ (Int.negOfNat 1)) (Eq.refl (Int.ofNat 0)))))
                          (Mathlib.Tactic.Ring.add_pf_add_overlap_zero
                            (Mathlib.Tactic.Ring.add_overlap_pf_zero (a (N + 1)) (Nat.rawCast 1)
                              (Mathlib.Meta.NormNum.IsInt.to_isNat
                                (Mathlib.Meta.NormNum.isInt_add (Eq.refl HAdd.hAdd)
                                  (Mathlib.Meta.NormNum.IsInt.of_raw ℝ (Int.negOfNat 1))
                                  (Mathlib.Meta.NormNum.IsNat.to_isInt (Mathlib.Meta.NormNum.IsNat.of_raw ℝ 1))
                                  (Eq.refl (Int.ofNat 0)))))
                            (Mathlib.Tactic.Ring.add_pf_zero_add 0))))
                      (Mathlib.Tactic.Ring.cast_zero (Mathlib.Meta.NormNum.isNat_ofNat ℝ Nat.cast_zero))))
                  (Mathlib.Tactic.Linarith.add_neg (Mathlib.Tactic.Linarith.sub_neg_of_lt this)
                    (Mathlib.Tactic.Linarith.sub_neg_of_lt a_1))))))))
    (Eq.mpr (id ge_iff_le._simp_1)
      (Eq.mp
        (Eq.trans
          (congrArg (fun x => |x| ≥ 1)
            (congr
              (congrArg HSub.hSub
                (Eq.trans
                  (Finsupp.prod_single_index
                    (of_eq_true (Eq.trans (congrArg (fun x => x = 1) (pow_zero (a (N + 1)))) (eq_self 1))))
                  (pow_one (a (N + 1)))))
              (Eq.trans
                (Finsupp.prod_single_index
                  (of_eq_true (Eq.trans (congrArg (fun x => x = 1) (pow_zero (a N))) (eq_self 1))))
                (pow_one (a N)))))
          ge_iff_le._simp_1)
        (he (fun₀ | N + 1 => 1) (fun₀ | N => 1)
          (Eq.mpr (id (Eq.trans (congrArg Not isBeurlingPrimes._simp_1) Classical.not_forall._simp_1))
            (Exists.intro N
              (of_eq_true
                (Eq.trans
                  (congrArg Not
                    (Eq.trans
                      (congr
                        (congrArg Eq
                          (Finsupp.single_eq_of_ne
                            (of_eq_true
                              (Eq.trans (congrArg Not (Eq.trans Nat.left_eq_add._simp_1 one_ne_zero._simp_1))
                                not_false_eq_true))))
                        Finsupp.single_eq_same)
                      zero_ne_one._simp_1))
                  not_false_eq_true)))))))⊢ N + 1 ≥ N grindAll goals completed! 🐙))]

If 1 < a 0 < ... has property Erdos951Prop, is it true that #{a i ≤ x} ≤ π x?

@[category research open, AMS 11]
theorem declaration uses 'sorry'erdos_951 : answer(sorry) ↔
    ∀ a : ℕ → ℝ, 1 < a 0 → StrictMono a → Erdos951Prop a →
      ∀ᶠ (x : ℝ) in Filter.atTop, {i : ℕ | a i ≤ x}.ncard ≤ π ⌊x⌋₊ := by⊢ True ↔ ∀ (a : ℕ → ℝ), 1 < a 0 → StrictMono a → Erdos951Prop a → ∀ᶠ (x : ℝ) in atTop, {i | a i ≤ x}.ncard ≤ π ⌊x⌋₊
  sorryAll goals completed! 🐙

Beurling conjectured that if the number of Beurling integer in [1, x] is x + o(log x), then a must be the sequence of primes.

@[category research solved, AMS 11]
theorem declaration uses 'sorry'erdos_951.variants.beurling :
    ∀ a : ℕ → ℝ, IsBeurlingPrimes a →
    ((fun x => (BeurlingIntegers a ∩ .Iic x).ncard - x) =o[atTop] Real.log) →
    a = Nat.cast ∘ Nat.nth Nat.Prime := by⊢ ∀ (a : ℕ → ℝ),
  IsBeurlingPrimes a →
    (fun x => ↑(BeurlingIntegers a ∩ Set.Iic x).ncard - x) =o[atTop] Real.log → a = Nat.cast ∘ Nat.nth Nat.Prime
  sorryAll goals completed! 🐙


end Erdos951