AlphaEvolve — LLM-guided evolutionary search over verifier-checked numeric parameter spaces

Statement

AlphaEvolve (Novikov et al., Google DeepMind, arXiv:2506.13131, white paper submitted 2025-06-16) is a generic LLM-guided evolutionary coding agent: it does not search directly over numbers, but over *programs*, using an evolutionary loop with automated verifier feedback. The precise loop, per the white paper and the official DeepMind blog (deepmind.google/discover/blog/alphaevolve-…, fetched directly):

1. A program database (MAP-Elites-style — a population of candidate programs indexed/scored by an automated evaluator, keeping diverse "elites" across different regions of solution-space rather than collapsing to one lineage) holds the current population of candidate solutions, each stored as source code plus its evaluator score(s). 2. An LLM ensemble with two roles samples parent program(s) from the database and proposes a code *diff/mutation*: Gemini Flash "maximizes the breadth of ideas explored," while Gemini Pro "provides critical depth with insightful suggestions" (DeepMind blog, direct quote) — i.e. a fast/cheap-but-diverse proposer paired with a slow/expensive-but-sharp refiner. 3. An automated evaluator/verifier runs the mutated program, checks its validity/admissibility, and returns a scalar (or vector) fitness score — "AlphaEvolve verifies, runs and scores the proposed programs using automated evaluation metrics" (DeepMind blog). 4. The scored program re-enters the database; evolutionary selection (which elites survive, which get sampled as parents next) determines the next round of prompts. Iterate for many generations.

The specific mode this page targets — numeric/constant optimization: when the underlying mathematical problem reduces to optimizing a handful of real-valued parameters subject to explicit, mechanically-checkable admissibility constraints, with a fitness function equal to (or monotone in) the implied bound/constant. AlphaEvolve does not evolve the parameter vector directly with a classical genetic algorithm; it evolves **code that *outputs* the parameter vector (or the full construction)**, because — per Tao's summary of the paper's own framing (terrytao.wordpress.com/2025/11/05/…, direct quote) — "extremizing inputs will often have some structure that can be efficiently described … by relatively short code," so searching in "program space" is a better-shaped, lower-effective-dimension search than searching in raw numeric-parameter space whenever the optimum has exploitable algebraic/combinatorial structure.

Facts

- Benchmark scale: Georgiev–Gómez-Serrano–Tao–Wagner, "Mathematical exploration and discovery at scale" (arXiv:2511.02864, abstract fetched directly), ran AlphaEvolve on 67 problems spanning analysis, combinatorics, geometry, and number theory. Per Tao's blog summary of the same paper: **AlphaEvolve rediscovered the state-of-the-art on most problems, produced a genuinely new best-known bound on 20 of the 67, and produced a *worse* result than the prior literature on 8 — i.e. it is a noisy, not-always-winning tool, not a guaranteed improver. - The DeepMind original white paper's own headline results (arXiv:2506.13131 / deepmind.google blog): a procedure multiplying two 4×4 complex matrices using 48 scalar multiplications, the first improvement over Strassen's 1969 bound (49) in 56 years; a new kissing-number-in-11-dimensions lower bound via an explicit 593-sphere configuration; plus non-mathematical infrastructure wins (data-center job scheduling, hardware circuit simplification, and speeding up the training of the Gemini models used inside AlphaEvolve itself, a self-referential loop). - Concrete additive-combinatorics constant-optimization instance (this wiki's primary worked example)**: Erdős #30 — sharp $N^{1/2}$ asymptotics for Sidon sets (Erdős–Turán Sidon-set bound $h(N)\le N^{1/2}+cN^{1/4}+O(1)$). The Carter–Hunter–O'Bryant 2023/25 proof (arXiv:2310.20032) reduces the constant $c$ to a piecewise-affine optimization over free real parameters $(\tau,\alpha,c_s)$ with an explicit admissibility verifier. Per Tao's blog (terrytao.wordpress.com/2025/11/05/…, comment thread with CHO25 co-author Daniel Carter), running AlphaEvolve against this verifier pushed $c$ (equivalently their constant $b$) from $1.96365$ down to $1.952659676624688$; Carter then hand-verified and further hand-optimized to $b=1.9526463099204112$. This is the first documented, citable movement on Erdős #30's best-known bound since CHO25 (2023) — informal (blog comment, not yet peer-reviewed) as of the sources checked. - The Sidon-set exploit story (terrytao.wordpress.com, direct quote paraphrase): Carter's *first* verifier attempt used a floating-point-based LP solver for one of the admissibility sub-checks; AlphaEvolve found and exploited a floating-point instability in that solver to produce parameter tuples that were reported "admissible" but were not truly so. The fix required adding explicit error-checking / moving to exact/interval-safe arithmetic inside the verifier itself — the improved bound above is from the *corrected* verifier. - A second, independent exploit example (moving-sofa problem, same blog post): an initial floating-point verifier with loose numerical tolerance let AlphaEvolve "promptly place many points in virtually the same location," gaming the score; switching to exact arithmetic and conservative worst-case bounds fixed it. General lesson stated explicitly by Tao: AlphaEvolve is "extremely good at locating exploits in verification code," so verifier design (exact/interval arithmetic, no numerical-tolerance loopholes, conservative worst-case rounding) is the load-bearing, human-supplied part of the whole pipeline. - Minimum overlap problem (Erdős, 1955): J. K. Haugland's 1996 upper bound on the limiting constant $M(n)/n$ was $0.380927$ (per en.wikipedia.org/wiki/Minimum_overlap_problem via WebSearch snippet); AlphaEvolve (2025) nudged this to $0.380924$ — "the first progress since 2016" — and a further open-source system, TTT-Discover (2026), improved it again to $0.380876$. (Sourced via WebSearch snippets only, not independently fetched in full — flagged lower-confidence.) This is a second, independent worked example of the same constant-optimization mode applied outside the Sidon-set family. - Success/failure pattern across the 67-problem benchmark (Tao's blog, direct paraphrase): AlphaEvolve does well on problems with exploitable algebraic or geometric structure (e.g. finite-field Kakeya-set constructions) and does poorly on problems requiring deep analytic-number-theoretic reasoning with no code-describable pattern (e.g. sieve-weight optimization). It also tends to perform *better*, relatively, on problems with scant prior optimization literature (more room for a training-data-informed heuristic search to beat an under-optimized human baseline) than on problems already heavily hand-optimized by specialists. - **Erdős #97 — convex polygon vertex with no 4 equidistant — a *different*, sibling mode ("combinatorial construction search," not numeric constant optimization) worth distinguishing**: arXiv:2511.02864 §33 ran AlphaEvolve to search for a $k=4$ counterexample to an equidistant-points-in-convex-polygons conjecture, via a custom diameter-normalized "equidistance error" loss maximized by evolutionary search over point configurations. It found nothing beyond the known $k=3$ examples — a *negative* (non-improving) result, logged in this wiki as concept/alphaevolve-combinatorial-construction-search, mechanistically the same evolutionary-loop/verifier architecture but searching a combinatorial-object space rather than a low-dimensional real-parameter space. - Independent institutional infrastructure: Davis, Ivanisvili, and Tao maintain github.com/teorth/optimizationproblems (fetched directly), "a crowdsourced repository for optimization constants" (started via a January-2026 Tao blog post per the fetched repo description) that tracks best-known upper/lower bounds for exactly this class of constants (Sidon-set, sphere-packing, Ramsey-exponent, cap-set/sum-difference, Grothendieck-constant families) — a natural landing place for any new AlphaEvolve-style constant improvement, and a source of ready-made verifier-checked problem statements to feed into the loop. - Open-source analogues exist, evidence the paradigm is reproducible outside DeepMind's closed system: CodeEvolve (arXiv:2510.14150, "An open source evolutionary coding agent for algorithm discovery and optimization") and TTT-Discover (2026, credited above with the further minimum-overlap improvement) — found via WebSearch, not independently fetched in full. - Combined pipeline: arXiv:2511.02864's abstract states the methodology is also combined with Deep Think and AlphaProof in a broader framework where those additional systems "provide automated proof generation and further mathematical insights" once AlphaEvolve has found a numeric/constructive candidate — i.e. AlphaEvolve's role is candidate *discovery*, not proof; a separate system or human must certify the final result as a theorem.

Technique

WHEN it applies (necessary preconditions, concrete): 1. The target quantity is a scalar bound/constant (or a small finite tuple of them) coming out of an existing proof schema that has free real-valued (or small-finite-discrete) parameters — e.g. a piecewise-affine optimization (CHO25/Erdős #30), a Fourier/large-spectrum inequality chain with tunable weights (candidate transplant target: Erdős #241 — sharp $N^{1/3}$ asymptotics for $B_3$ sets's Green 2001 $B_3[1]$ argument, per wiki/problems/241.md, never yet attempted), a weighted Cauchy–Schwarz step (candidate transplant target: Erdős #1191 — how small can an infinite Sidon set's liminf density be?'s block-energy argument), or an explicit geometric/combinatorial construction with continuous or discrete design freedom (sphere packings, matrix-multiplication tensor decompositions, point configurations). 2. A mechanical, cheap, EXACT verifier exists (or can be built) that takes a candidate parameter tuple/construction and returns (a) a pass/fail admissibility check and (b) the implied numeric bound. "Mechanical" is essential — per erdosproblems.com's own framing (quoted in wiki/problems/30.md), this only ever works on the *sub-task* that "can be resolved with a finite computation," never on the full (often $\forall\epsilon$ or $\liminf/\limsup$) qualitative conjecture. 3. The verifier is built with exact or interval-safe arithmetic and conservative worst-case rounding, never floating-point tolerance windows — otherwise, per the two documented exploit stories above (Sidon set, moving sofa), AlphaEvolve will reliably find and exploit the numerical loophole rather than a genuine improvement. 4. Ideally the optimum has describable algebraic/geometric/combinatorial structure (so that a short *program* generating it exists) rather than being an arbitrary high-dimensional numerical optimum — this is where the "evolve code, not raw numbers" design pays off over classical black-box/genetic optimizers.

Recipe (recombination-ready steps to transplant this to a new Erdős-problem bound): 1. Find the best-known proof of the bound and identify its free real-parameter(s) — usually buried in a "choose $\lambda,\tau,\ldots$ to optimize the following expression" step of a published paper. 2. Re-implement that proof's admissibility/side-conditions as a standalone, exact-arithmetic verifier function: params → (is_admissible: bool, implied_bound: float). 3. Stress-test the verifier adversarially yourself first (try degenerate/near-degenerate/boundary parameter values) to pre-empt the kind of floating-point exploit AlphaEvolve would otherwise find for you the hard way. 4. Seed the evolutionary loop's initial population with the literature's current best-known parameter values (do not start from scratch — Tao/Carter's run started from CHO25's own optimum). 5. Run the LLM-ensemble evolutionary loop (AlphaEvolve itself, or an open-source analogue such as CodeEvolve, arXiv:2510.14150) with the verifier as fitness function, for many generations, keeping a diverse elite population (MAP-Elites-style) rather than single-lineage hill-climbing. 6. Independently re-run every claimed improvement through the exact-arithmetic verifier outside the evolutionary loop before citing it — this is exactly the step that caught both documented exploits. 7. Recognize the hard ceiling: this recipe can only ever shrink a constant *inside a fixed proof schema*; per wiki/problems/30.md's analysis, Erdős #30's true obstruction is the *exponent* ($N^{1/4}$, not the constant in front of it), and no amount of constant-optimization inside the current schema can touch that — a genuinely different proof technique is needed for the qualitative conjecture, and this method provides zero evidence either way about the existence of such a technique.

WHY it works (mechanism, for recombination): - LLM-guided mutation is a structured, training-data-informed proposal distribution, not uniform-random perturbation — Gemini's mathematical priors suggest plausible next edits (try a different weight profile, a different symmetry, a different degree bound), which is why the search out-performs classical black-box/genetic optimizers on landscapes with exploitable mathematical structure, and under-performs on landscapes that are numerically "arbitrary-looking" with no such structure (Tao's stated failure mode). - Evolving code instead of raw numbers compresses the effective search space whenever the true optimum is describable by a short program (e.g. "use a geometric sequence with ratio $r$," "tile with a repeating $k$-periodic block") — this converts a high-dimensional continuous optimization into a much lower-dimensional search over *program structures*, which the LLM's code-generation prior is well-suited to explore. - The MAP-Elites-style population maintains diversity across many good-but-different solutions simultaneously, preventing premature convergence to one local optimum — standard evolutionary-computation rationale, but here the "mutation operator" is an LLM rather than a fixed random perturbation rule. - Soundness comes entirely from the external verifier, not from the search process — because any accepted candidate is checked by a fixed, human-authored, exact-arithmetic verifier independent of how it was found, a genuine pass is provably correct regardless of how noisy/hallucination-prone the LLM proposals are; this is precisely why the LLM's stochasticity ("hallucinations," per Tao) is *harmless upside* (more diverse proposals) rather than a correctness risk — provided the verifier itself has no exploitable gap, which is the one place human care is irreplaceable. - Completeness is absent by design: a failure to improve the bound after many generations is not evidence the bound is optimal — it only means the search didn't find better within its compute/generation budget and its current program-space prior. This is why AlphaEvolve's negative results (e.g. Erdős #97 — convex polygon vertex with no 4 equidistant's failed $k=4$ search) are logged as *weak, non-proof-grade evidence*, never as a resolution.

Related

- Erdős #30 — sharp $N^{1/2}$ asymptotics for Sidon sets — Erdős–Turán finite Sidon-set bound; the primary, fullest-documented worked instance of this exact technique (CHO25 piecewise-affine parameter optimization, Tao/Carter's live AlphaEvolve run, both the LP-solver exploit and the corrected-verifier improvement to $b=1.9526463099204112$ are logged there). - Erdős #39 — density $N^{1/2-\\epsilon}$ infinite Sidon set — infinite Sidon-set growth-exponent problem; this page's technique is flagged there as the most plausible near-term "reusable machinery" for empirically probing the finite-truncation exponent, though (like #30) it cannot touch the qualitative $\liminf=0$ conjecture itself. - Erdős #1191 — how small can an infinite Sidon set's liminf density be? — Sidon-set block-energy liminf/limsup problem; O'Bryant's weighted-Cauchy–Schwarz weight profile is flagged there as a concrete, never-yet-attempted transplant target for this technique. - Erdős #241 — sharp $N^{1/3}$ asymptotics for $B_3$ sets — $B_3[1]$-set leading-constant gap (Green 2001, unimproved 24+ years); Green's Fourier/large-spectrum argument is flagged there as a structurally identical, never-yet-attempted transplant target, the clearest "someone should just run this" opportunity found across this wiki's AlphaEvolve-tagged pages. - Erdős #97 — convex polygon vertex with no 4 equidistant — equidistant-points-in-convex-polygons conjecture; documents the *sibling* evolutionary-search mode over combinatorial/geometric object spaces rather than numeric parameters, logged separately as concept/alphaevolve-combinatorial-construction-search — same architecture, different search-space shape, and here the search returned a negative (non-improving) result. - concept/alphaevolve-combinatorial-construction-search — sibling concept for the discrete/combinatorial-object variant of the same AlphaEvolve architecture (point configurations, graph constructions), as opposed to this page's continuous/numeric-parameter variant. - Lean 4 formalization of constructions and conditional reductions (Erdős-problem context) — the complementary machine-checking layer (arXiv:2605.03274 for #30) that turns a verifier-checked numeric candidate into an actual certified proof artifact once found; AlphaEvolve itself only discovers candidates, it does not produce theorems (arXiv:2511.02864 pairs it with AlphaProof/Deep Think for exactly this reason). - Discrete-logarithm explicit Sidon construction (Cilleruelo) — Cilleruelo's explicit discrete-log Sidon construction (arXiv:1209.0326), the kind of hand-built algebraic construction that this page's technique could in principle be pointed at for parameter/base variation, per wiki/problems/39.md.