How Does AI Solve Erdős Problems?
AI
AI solves Erdős problems through a combination of Large Language Models (LLMs) for generating creative proofs and formal verification tools like Lean 4 to ensure mathematical correctness. [1, 2, 3]
Recent breakthroughs, such as the resolution of Erdős Problem #728 and #1196, have used specialized workflows where AI acts as a "junior co-author" to discover novel connections that human mathematicians had previously overlooked. [1, 2, 3, 4, 5]
The Core Solving Process
Solving these open conjectures typically involves a "loop" between a reasoning model and a formal verifier:
- Creative Brainstorming: A model (like GPT-5.2 or GPT-5.4) is prompted to research the problem and brainstorm novel mathematical strategies.
- Generating informal Proofs: The AI writes a mathematical paper in LaTeX, often discovering "elegant" methods, such as using the von Mangoldt function in unexpected ways to solve problems in analytic number theory.
- Formalization: Tools like Aristotle (by Harmonic) translate the LaTeX proof into Lean 4, a language that can be computer-verified for 100% accuracy.
- Auto-Correction: If the formal verifier finds a logical gap, the AI re-processes the error until a complete, verified proof is produced. [1, 2, 3, 4, 5, 6, 7]
Notable Solved Erdős Problems
Several problems from the Erdős Problems database have been recently resolved: [1, 2]
| Problem # [1, 2, 3, 4, 5, 6, 7] | Focus Area | AI Contribution |
|---|---|---|
| #1196 | Primitive Sets | Discovered a new "opening line" in the arithmetic realm using von Mangoldt weights. |
| #728 | Set Patterns | Fully resolved autonomously by a combination of GPT-5.2 and Aristotle. |
| #1026 | Monotone Subsequences | Converted the conjecture into a rectangle-packing problem for an autonomous resolution. |
| #397 | Central Binomial Coefficients | Generated a proof that infinitely many solutions exist for a specific equation. |
Impact on Mathematics
Renowned mathematician Terence Tao has noted that while AI sometimes "dredges up" existing solutions, it has begun contributing genuine "new understanding" by highlighting tighter connections between different fields, such as the anatomy of integers and Markov processes. This has led to the era of "vibe proving," where AI provides the conceptual intuition that humans then help formalize. [1, 2, 3, 4, 5]
Would you like to see a breakdown of the specific mathematical identity GPT-5.4 used to crack the primitive set problem?
AI
The AI (GPT-5.4) solved Erdős Problem #1196 by utilizing a fundamental identity involving the von Mangoldt function (\(\Lambda \)), a tool typically reserved for the distribution of prime numbers. [1, 2]
The Breakthrough Identity
While human mathematicians traditionally approached primitive set problems by converting them into continuous "real analysis" problems, the AI stayed within the discrete "arithmetic realm". It focused on the identity: [1]
\(\sum _{q|n}\Lambda (q)=\log n\)
This formula states that the sum of von Mangoldt weights over all divisors (\(q\)) of a number (\(n\)) exactly equals the natural logarithm of \(n\). This identity is equivalent to the unique factorization of integers into primes. [1, 2, 3]
Why This Identity Worked
In the context of primitive sets (where no number in the set divides another), human experts had struggled with "analytic noise"—complex errors that appear when using real analysis tools. The AI used the von Mangoldt function as a "substitute" for these tools in the following way: [1, 2]
- Local Precision: The identity provided an exact match for \(\log n\), effectively "dissolving" the analytic difficulties that had blocked previous proofs.
- Discrete Flow: It allowed the AI to treat divisibility like a flow on a graph. The identity ensured the "outflow" from any number \(n\) was perfectly balanced, making the proof much cleaner and more "elegant" than human attempts. [1, 2, 3, 4, 5]
Significance
Mathematician Jared Lichtman described this as a "Book Proof"—a term Erdős used for the most beautiful and perfect version of a mathematical truth. The AI's choice to use von Mangoldt weights was seen as an "opening move" in a chess game that humans had overlooked for 90 years because it seemed "unmotivated" and counter-intuitive. [1, 2, 3, 4]
Do you want to explore the Lean 4 code used to verify this proof, or should we look at other Erdős problems AI has tackled?
AI
In April 2026, GPT-5.4 Pro solved Erdős Problem #1196, a 60-year-old conjecture on primitive sets. The proof was then formalized into Lean 4 code—a process that initially produced 7.2k lines of code before being "golfed" down to approximately 4k lines for efficiency. [1, 2]
Lean 4 Verification: The Proof in Code
The verification process used formal language to ensure the logic was "sorry-free" (meaning no unproven gaps). The key structural logic in the Lean code revolves around a "downward Markov process". [1, 2, 3]
- Weighted Edges: The code defines a weighted directed edge from an integer \(nq\) to \(n\) using the von Mangoldt function (\(\Lambda \)).
- Divergence Theorem: It treats the divisibility relation as a flow on a graph. The Lean proof verifies that the flow is almost "divergence-free" for large integers, which allows a discrete version of the divergence theorem to prove the upper bound.
- The Invariant Measure: The code formally confirms that the probability of jumping from \(n\) to \(n/q\) is proportional to \(\Lambda(q)/\log n\). This keeps the "inflow" and "outflow" of the mathematical sum perfectly balanced. [1, 2]
Other AI-Tackled Erdős Problems
Since late 2025, a wave of autonomous and semi-autonomous AI solves has occurred, often verified by systems like Harmonic’s Aristotle. [1, 2]
- Problem #728 (Factorial Divisibility): Solved in January 2026 by GPT-5.2 and Aristotle. It addressed a "logarithmic-gap" phenomenon in how factorials divide each other. This was the first problem regarded as fully resolved autonomously by an AI.
- Problem #1026 (Monotone Subsequences): Resolved through a collaboration where AI reimagined a sequence problem as a "rectangle-packing" or "square-packing" geometric argument. This provided a "weighted form" of the Erdős-Szekeres theorem.
- Problem #397 (Binomial Coefficients): Solved by GPT-5.2 Pro. It proved that specific binomial divisibility equations have infinitely many solutions, a result later accepted by Terence Tao.
- Problem #729: Another autonomous solve by GPT-5.2 Pro in early 2026. [1, 2, 3, 4, 5]
These videos detail how AI systems like Aristotle and GPT models are accelerating breakthroughs in the Erdős problem catalog:
Would you like to look at the step-by-step reasoning for one of these specific problems, or explore the Erdős Problems database for open conjectures?
AI
The AI's reasoning for Erdős Problem #1196 (Primitive Sets) shifted the focus from continuous analysis to a discrete "flow" model on the integers.
Step-by-Step Reasoning
- Define the Graph: View the set of integers as nodes in a graph, where an edge exists from \(n\) to \(d\) if \(d\) is a divisor of \(n\).
- Apply von Mangoldt Weights: Assign a weight to each edge based on the identity \(\sum_{d|n} \Lambda(d) = \log n\).
- Establish Conservativity: For any integer \(n > 1\), define the probability of "jumping" to a divisor \(d\) as \(\frac{\Lambda (n/d)}{\log n}\). Because the weights sum to 1, the flow is "conservative" (the total probability mass is preserved).
- Enforce Primitivity: In a primitive set \(S\), no element divides another. This means a path in the graph can hit at most one element of \(S\).
- Calculate the Bound: By tracking the "mass" of the flow from large \(n\) down to \(1\), the AI proved that the sum \(\sum_{n \in S} \frac{1}{n \log n}\) is bounded, resolving the conjecture.
Lean 4 Formalization
The Lean 4 code ensures that every step—especially the transition from the discrete sum to the final bound—is logically sound. Here is the structural skeleton of that proof:
lean
import Mathlib.NumberTheory.VonMangoldt
import Mathlib.Analysis.SpecialFunctions.Log.Basic
open Nat Real
/--
Defines the 'Transition Probability' between nodes.
This represents the 'Flow' the AI discovered.
--/
def flow_weight (n d : ℕ) : ℝ :=
if d ∣ n ∧ d 1 must be 1.
This confirms the 'conservative' nature of the flow.
--/
theorem flow_conservation (n : ℕ) (hn : 1 < n) :
∑ d in divisors n, flow_weight n d = 1 := by
unfold flow_weight
-- The AI uses the Mangoldt-Log identity here
rw [← sum_vonMangoldt_divisors n]
simp [hn]
sorry -- Full formal proof fills this gap
/--
Main Result for Erdős #1196:
Proves the upper bound for any primitive set S.
--/
theorem erdos_primitive_bound (S : Finset ℕ) (hS : IsPrimitive S) :
∑ n in S, 1 / (n * log n) ≤ constant_C := by
-- Uses the flow_conservation theorem to bound the sum
sorry
Use code with caution.
The use of "sorry" in draft code is where the AI iteratively works with the Lean compiler to fill in tactical proofs until the entire file is "sorry-free", indicating a verified discovery.
Would you like to explore another Erdős problem where AI used a different branch of math, like graph theory or combinatorics?
~***~
Comments
Post a Comment