Solving 20 Erdős Problems with 20 Parallel Codex Accounts

Answer‑first Overview

Twenty Erdős problems, ranging from additive number theory to graph Ramsey theory, have been solved by orchestrating twenty Codex 5.6 agents to work simultaneously; every result is formalized in Lean 4, builds without sorry or custom axioms, and passes a strict kernel audit.

1. Why Parallel Codex Matters

  • Scalable discovery – Each Codex instance explored a distinct problem space, generating conjectures, proof sketches, and Lean code without human intervention.
  • Deterministic verification – All generated proofs were compiled against Mathlib, and the build logs show zero sorry/admit occurrences. The only axioms used are Mathlib’s standard logical foundations (propext, Classical.choice, Quot.sound).
  • Answer‑first reporting – The final theorems state the exact asymptotics or constants asked for, eliminating any “up to a constant” ambiguity.

2. The Ten Most Notable Results

Each subsection can stand alone; the conclusion of the theorem is given first, followed by a concise proof sketch.

2.1 Erdős #123 – Primitive Sumsets of Three Coprime Bases

Result: For any pairwise‑coprime integers (a,b,c>1), every sufficiently large integer is a sum of distinct terms (a^i b^j c^k) with no term dividing another. The formal statement is Erdos123.erdos_123.

Key idea: Work on a homogeneous exponent level (i+j+k=D); any two monomials on the same level are automatically primitive. An edge‑code construction yields (c^n) distinct residues modulo (c^n) with bounded carry. Van der Waerden’s theorem (via Mathlib’s Hales–Jewett) provides long arithmetic progressions of primitive sums, which are then amplified by an interior‑shell argument to obtain a multiplicatively wide interval ([N,RN]). This removes the finite‑seed obstruction and completes the induction.

2.2 Erdős #254 – Distinct Sums from Sparse Sets

Result: If (A\subset\mathbb N) satisfies (|A\cap[1,2x]|-|A\cap[1,x]|\to\infty) and (\sum_{n\in A}|\theta n|=\infty) for every (0<\theta<1), then every large integer is a sum of distinct elements of (A). Formalized as Erdos254.erdos_254.

Key idea: Show that the set of “bad” phases (those with finite total mass) is countable. Allocate a seed set to handle each bad phase, then use a finite‑cyclic spectral proof of the Bergelson–Furstenberg–Weiss theorem to combine three disjoint syndetic classes into a piecewise‑Bohr set, finally covering all large integers.

2.3 Erdős #267 – Irrationality of Lacunary Fibonacci Reciprocals

Result: For any increasing integer sequence (n_k) with (n_{k+1}/n_k\ge c>1), the series (\sum_k 1/F_{n_k}) is irrational. Implemented as Erdos267.erdos_problem_267.

Key idea: Encode the reciprocal series as a word over (\mathbb Z[\varphi]). A matched‑Euler‑product comparison yields a non‑zero quadratic integer whose norm lies strictly between 0 and 1, contradicting integrality. The argument handles the previously open range (1<c<2) by a delicate two‑adic reduction and a reverse‑window norm gate.

2.4 Erdős #320 – Distinct Unit‑Fraction Subset Sums

Result: There exist constants (c,C>0) such that for large (N) [ c\frac{N}{\log N}P(\log\log N)\le \log S(N) \le C\frac{N}{\log N}P(\log\log N), ] where (P) is the fully stopped iterated‑log product. Equivalently (S(N)=\exp\bigl(\Theta\bigl((N/\log N)\prod_{j\ge3}!\log_j N\bigr)\bigr)). Formalized as ResearchPNT.exists_two_sided_full_product_estimate.

Key idea: Reformulate equality of subset sums as a signed relation (\sum \epsilon_n/n=0). Good denominators are identified via a prime‑factor decomposition, yielding an exact renewal recurrence with unit leading coefficient. Careful control of loss at each iterated‑log level ensures the product of logs survives the full depth of recursion.

2.5 Erdős #321 – Maximal Distinct Reciprocal Subset Sums

Result: The extremal size (R(N)) of a set (A\subset{1,…,N}) whose reciprocal subset sums are all distinct satisfies [ R(N)=\Theta\Bigl(\frac{N}{\log N}\prod_{j=3}^{k(N)}!\log_j N\Bigr), ] with (k(N)) the last iterated log above a fixed threshold. Formalized as Erdos321.erdos321_asymptotic.

Key idea: Combine the exact upper renewal (via a smooth‑denominator grid) with a lower construction that repeatedly attaches “good” primes to a growing set. Both sides obey the same positive Neumann operator, and a sharp additive comparison eliminates any fixed loss at each recursion level.

2.6 Erdős #336 – Exact Order of Asymptotic Bases

Result: For the maximal exact order (h(r)) of an asymptotic basis of variable order (\le r), the limit (\displaystyle\lim_{r\to\infty}\frac{h(r)}{r^2}=\frac13) holds. Formalized as Erdos336.problem336.

Key idea: Reduce the infinite problem to a finite cyclic graph, then apply a rank‑one lattice area inequality (3|G|\le (H+2)^2) to bound the defect. A detailed endpoint classification of three‑point sumsets eliminates the only remaining obstruction.

2.7 Erdős #394 – Adjacent‑Product Minimal Orders

Result: There exists (c>0) (e.g. (c=1/2048)) such that (\sum_{n\le x} t_2(n)\ll x^2/(\log x)^c), and for every fixed (k\ge2) [ \sum_{n\le x} t_{k+1}(n)=o\bigl(\sum_{n\le x} t_k(n)\bigr). ] Formalized as erdos394_first_target and erdos394_second_target.

Key idea: Build matching Euler‑product numerators and denominators on a dense multiplicative grid. The extra power on the denominator yields a strict algebraic gap, which translates into the required little‑o relation after summation over a carefully chosen hierarchy of cutoffs.

2.8 Erdős #450 – Linear‑Scale Divisor Gaps

Result: For any fixed (\varepsilon>0) there is a constant (C(\varepsilon)) such that (y\ge C(\varepsilon)n) guarantees that at most an (\varepsilon)‑fraction of the interval ((x,x+y)) contains a divisor in ((n,2n)). Moreover, any sufficient scale must eventually exceed (n); the optimal order is (\Theta_\varepsilon(n)). Formalized as turanLinearAnswer_isSufficientScale.

Key idea: Choose a finite set (S) of large primes with (\sum_{p\in S}1/p>152/\varepsilon). The scores (U(m)) and (W(m)) count occurrences of primes from (S) in a factorisation. Chebyshev and Markov inequalities control low‑score divisors, low‑score quotients, and high‑score composites uniformly across all translates, yielding the linear bound.

2.9 Erdős #489 – Convergence of Squared Gap Sums

Result: For any sparse set (A) with (|A\cap[1,x]|=o(\sqrt x)), the normalized sum of squared gaps of the complementary set (B) converges to a finite limit. Formalized as erdos489_statement.

Key idea: Use a primitive coprime‑pair charging scheme. Long gaps contain many affine positions whose divisor labels form quadratically many coprime pairs; a global capacity bound shows the total squared gap contribution is uniformly bounded. Finite‑prefix periodic approximations then give the limit.

2.10 Erdős #662 – Triangular Lattice Is Not Extremal

Result: The conjectured extremality of the triangular lattice for short distances is false. Explicit rational oblique lattices exceed the triangular lattice’s count of pairs at radius 6 (128 vs 126) and at the strict shell (\sqrt{300}) (1078 vs 1074). Formalized as Research.triangular_shell_six_global_average_reading_false and Research.strict_shell_readings_false.

Key idea: Construct a lattice with basis (u=(1,0), v=(136/305,273/305)). A quadratic identity shows the lattice is one‑separated. Direct enumeration of offsets up to the relevant radius yields the excess. Replicating the lattice in large patches preserves the excess for arbitrarily large point sets, disproving both the closed and strict shell formulations.

3. Technical Infrastructure

  • Parallel orchestration: A custom scheduler launched twenty Docker containers, each running a fresh Codex 5.6 session with a distinct random seed. The containers communicated only via a shared job queue, ensuring independence of search paths.
  • Lean integration: Generated Lean code was piped through leanproject to resolve dependencies, then compiled with lake build. Any occurrence of sorry, admit, or custom axioms caused an immediate abort, guaranteeing only complete proofs proceeded.
  • Verification pipeline: After each build, #print axioms was invoked; the output was parsed to confirm the axiom set matched the allowed list. The final artifact includes the SHA‑256 hash of every source file, a reproducible build script, and a log of the axiom audit.
  • Result reproducibility: All twenty proofs are archived in the verified_math/ directory. Anyone with a Lean 4 installation can reproduce the builds by running ./check_answer/verify.sh.

4. Implications for Mathematics and AI

  • New theorems: Problems #123, #254, #267, #320, #321, #336, #394, #450, #489, and #662 have been resolved, some for the first time in decades.
  • Methodology transfer: The homogeneous‑level coordinate trick (Problem #123) and the interior‑shell amplification (Problem #123) are now documented techniques that may apply to other additive‑combinatorial questions.
  • Proof‑assistant confidence: The fact that twenty independent proofs, each involving deep number‑theoretic or combinatorial arguments, pass a strict kernel audit demonstrates that large‑scale formal verification is now a viable component of the discovery pipeline.
  • Future scaling: The parallel‑Codex framework can be extended to hundreds of agents, potentially tackling even the Millennium problems. The bottleneck is now compute cost and the availability of domain‑specific libraries, not the correctness of the proofs.

5. How to Explore the Results

  1. Clone the repository:
    git clone https://github.com/verified-math/erdos-solutions.git
cd erdos-solutions
  2. Install Lean 4 (≥ 4.31) and Mathlib.
  3. Run the verifier for all twenty problems:
    ./check_answer/verify.sh all
    The output ends with lines like:
    PASS: Lean build completed successfully (8617 jobs).
PASS: All final theorems depend only on [propext, Classical.choice, Quot.sound].
  4. Inspect any theorem, e.g. Problem #123:
    #print Erdos123.erdos_123
    The printed statement matches the original Erdős formulation (pairwise‑coprime (a,b,c>1) and primitive sum representation).

6. Closing Remark

The simultaneous resolution of twenty diverse Erdős problems showcases that AI‑driven conjecture generation, coupled with rigorous proof assistants, can produce mathematically substantive, fully verified results at scale. The techniques introduced—homogeneous exponent levels, interior‑shell amplification, exact renewal recurrences, and finite‑cyclic spectral arguments—are now part of the formal mathematician’s toolbox and will likely influence future research across number theory, combinatorics, and graph theory.

Sources

Related