Every account of what FunSearch found in December 2023 agrees on the number: a construction of 512 points in an eight-dimensional cap set, replacing a smaller one of 496 — a figure DeepMind’s own supplementary material states directly in prose and marks a second way, as a dashed “Previous SOTA” line at 496 on a histogram of the cap sizes found across 140 independent runs, with a third-party encyclopedia entry with no stake in either independently landing on the same 512-point figure [2, 4]. Fewer accounts ask what the search that found it ever had to touch to get there. A robot trained by evolutionary search touches a simulated body falling under simulated gravity. A circuit shaped by evolutionary search touches actual silicon, with all its real, unmodeled physical quirks. A scheduling heuristic shaped by evolutionary search touches a live data center’s actual, contended load. FunSearch’s search touched a single arithmetic rule: do any three points in a candidate set sum to zero, coordinate by coordinate, modulo three [6]. Nothing about checking that rule required a body, a chip, or a fleet. That is a different kind of place for evolutionary search to run than anywhere it had run before — not a harder problem in a familiar kind of world, but the first result of this kind found in a domain with no world in it at all.
Every Earlier Search Needed Something to Push Against
Call the axis this article is measuring substrate independence, and state it as a question rather than a slogan: how much of the world outside a written specification does a fitness function have to consult before it can return a score at all? At one extreme, selection runs directly on uncontrolled physical matter. Frances Arnold’s directed evolution of enzymes — honored with half of the 2018 Nobel Prize in Chemistry “for pioneering the use of directed evolution to engineer enzymes” [10] — mutates real genes, expresses real proteins inside real cells, and scores each variant with an assay run on an actual folded molecule; nothing about that fitness function is representable in software alone, because the quantity it measures is a real chemical reaction rate, not a number a computer could derive from a gene sequence by itself. Adrian Thompson’s 1996 evolved field-programmable gate array sits almost as close to that extreme, from the opposite direction: his search configured actual silicon, not a simulation of it, and the winning circuit — “a tone discriminator that used fewer than 40 programmable logic gates, and had no clock signal” — worked by “exploiting peculiarities of the hardware that engineers normally avoid,” including a cluster of gates “with no logical connection to the rest of the circuit, yet crucial to its function” [8]. Move that exact configuration to a second, nominally identical chip and it can simply stop working, because what it evolved to depend on was never the circuit’s logical design — it was one physical chip’s own manufacturing variance, a substrate no circuit diagram can capture.
One rung up from raw physical matter is hardware built to survive contact with the world exactly once, checked beforehand by simulation and afterward by use. NASA’s Space Technology 5 mission, launched 22 March 2006, flew an antenna whose shape a genetic algorithm generated rather than an engineer — credited to Jason Lohn, Gregory Hornby, Derek Linden and Al Globus, and described as “the world’s first artificially-evolved object to fly in space” [9]. Its evaluator during the search was an electromagnetic simulation standing in for orbit; its real verification happened only once, in the vacuum that simulation was built to approximate. Google DeepMind’s AlphaEvolve keeps an even more literal version of that live dependency for its best-known infrastructure result: a scheduling heuristic for Google’s Borg cluster manager, reported on 14 May 2025, has been “in production for over a year” and “continuously recovers, on average, 0.7% of Google’s worldwide compute resources” [7]. That percentage cannot be computed from the heuristic’s code by itself. It has to run against Google’s actual, contended, unpredictable fleet to mean anything at all, the same way Arnold’s enzyme has to run inside a real cell.
A further rung up removes the live world but keeps a stand-in detailed enough to model it convincingly. Tim Salimans and colleagues’ 2017 evolution-strategies paper solved three-dimensional humanoid locomotion in ten minutes and reached competitive Atari play within an hour, coordinating past a thousand parallel workers, with every fitness evaluation a rollout inside a simulated body obeying simulated gravity and simulated contact forces [12]. No real robot and no real joint motor is touched anywhere in that search. But a physics simulator’s entire reason for existing is to approximate a physical world closely enough that a policy trained inside it stands some chance of transferring outside it — the substrate is synthetic, but its content is still physics, imported wholesale from outside the search itself. This publication’s own account of the same terrain, Software That Breeds When AI Stops Being Designed, already narrates Salimans and colleagues’ result alongside FunSearch’s cap-set and bin-packing work and several of AlphaEvolve’s case studies, but asks a different question of them — whether code produced this way counts as designed or bred. This article is not re-running that question. It is asking, of the same handful of cases, what world the fitness function had to consult to return a score at all — an axis that article does not measure.
FunSearch’s evaluator for the cap set problem has none of this, at any remove. The discovered function — reproduced in full in DeepMind’s own supplementary material — is nine lines long, and every one of those lines is arithmetic on the candidate point’s own coordinates: a dot product of the vector with itself, reduced modulo three; two overlapping partial sums treated the same way; a count of how many coordinates equal a fixed reference coordinate, reduced modulo three again; and a weighted sum of those quantities that ranks the point for inclusion [2]. Nothing in that function, or in the closure check that scores its output, refers to anything outside
The Record It Beat Was a Website, Not a Landmark Paper
Run the counterfactual the domain-boundary claim invites. Suppose evolutionary search over code had always been considered fair game for pure combinatorics, available the moment the tools existed. It would not have had to wait for anything resembling FunSearch’s technology to get started, because every technical precondition for it was already in place decades earlier. John Holland’s population-and-selection procedure dates to 1975. John Koza’s genetic programming — populations not of numeric vectors but of executable code, represented as syntax trees, mutated and recombined and scored by running each candidate — became an established field with the first of his books in 1992, more than three decades before FunSearch existed [11]. A graduate student in 1993 could have written the identical evaluator FunSearch uses today in perhaps twenty lines of code: build a set greedily, check the closure rule after every addition, count what survives. Nothing about that check needed a laboratory, a launch, or a fleet then any more than it does now.
What makes the counterfactual sharper than a generic “the tools existed” observation is what the record FunSearch actually beat turns out to be. The working mathematical literature’s own citation for the previous best-known 496-point construction in eight dimensions is not a landmark paper at all — Ernie Croot, Vsevolod Lev and Péter Pál Pach’s 2024 survey of the field cites it, in their own numbered reference list, as an entry attributed to Yves Edel with no publication year given, pointing directly to a running table of best-known cap sizes Edel maintained on his own university web page [5]. That is worth sitting with. The number FunSearch’s search dethroned in December 2023 was not a monument another mathematician had built and defended in a proof — it was a live, informally kept scoreboard, exactly the kind of record that persists because nobody has yet organized a systematic challenge to it, not because anyone has shown it is hard to beat. Nobody organized one, by any method, general or specialized, until FunSearch did.
The problem’s ceiling, meanwhile, moved by a route with no evolutionary search in it at all. Meshulam’s finite-field version of Roth’s 1953 density-increment argument, tightened by Bateman and Katz, and then reset by Jordan Ellenberg and Dion Gijswijt’s application of the polynomial method — adapting, by the surveying authors’ own account, “the algebraic argument” Croot, Lev and Pach had introduced one step earlier — delivered the field’s best-known ceiling on how large a cap set can possibly be [5]. That sequence of results, and the lower-bound sequence beside it, is the independent confirmation this article needed that FunSearch’s contribution is recognized by the field on its own mathematical terms, not only by DeepMind’s own announcement: Croot, Lev and Pach’s 2024 survey, written by three mathematicians with no stake in FunSearch’s success, places it directly in the working record. “Lower bounds were proved by Edel… giving the existence of a set
What Actually Changed Was the Proposal Operator, Not the Checker
If the evaluator was always cheap and the search procedure was always available, the honest next question is why three decades of genetic programming never turned this specific crank. This article’s answer is a proposal, not a settled fact, and it rests on the part of an evolutionary loop that gets the least attention: not the checker, but the operator that suggests what to try next. Classical genetic programming mutates and recombines syntax trees using edits chosen mostly at random from a fixed set of primitives — swap this subtree for a randomly generated one, splice two trees at a randomly chosen point — with no sense of which random edit is more likely to help, relying on selection alone to discover that sense empirically, one generation at a time. Against a search space as large and unstructured as arbitrary short programs, and a target as narrow as one priority function that happens to build a 512-point set, undirected syntactic mutation has to find the right neighborhood by sheer volume of attempts. FunSearch’s own account of its design treats the language model’s role as filling exactly that gap: it samples a small number of previously scored programs from the population and is asked, in effect, to propose a plausible next version, drawing on everything a model trained on real, human-written code already knows about what a well-formed, purposeful function tends to look like [1].
That is a narrower claim than “the model understood the mathematics,” and this is not the article making the wider claim. It is a claim about timing: general-purpose language models fluent enough in code to propose a syntactically sound, structurally plausible next version of an arbitrary short program — not a model fine-tuned for one narrow domain, but one carrying a broad, transferable sense of what working code looks like — did not exist as a mature, reachable technology for most of genetic programming’s three-decade history. The proposal operator a search like this one needed to make headway against a space this unstructured was not a discovery anyone could have made by trying harder with 1993’s tools; it required a class of model that had not been trained yet. FunSearch’s own paper names Codey, an internal descendant of Google’s code-focused language models, as the sampler it used by default [1] — and the sampler, on this article’s reading, not the evaluator, is the component whose absence is the real explanation for why this domain-boundary event landed in December 2023 rather than at any point in the preceding thirty years.
AlphaEvolve Proves the Same Method Can Sit at Both Ends of the Axis
The cap set result is not even the only zero-substrate case inside FunSearch’s own single paper, which is worth establishing before reaching outside it for confirmation. The same search procedure, retargeted at the Shannon capacity of cycle graphs, discovered a program that recovers the best known lower bound on the seven-node cycle graph’s capacity via an independent set of size 367, and a second, simpler program that reproduces the best known bounds across five different powers of the nine-node cycle graph at once — sizes 81, 324, 1,458, 6,561 and 26,244 — before finding a new best lower bound on the eleven-node case via an independent set of 754 [2]. Retargeted again at the corners problem, a close relative of the cap set problem concerned with corner-free sets rather than progression-free ones, it improved the best known construction size from 39 to 137 in one setting and reported new constructions of size 53 and 370 in another, each verified the identical way: count, confirm no forbidden pattern, done [2]. DeepMind’s own public code release organizes these as separate, named problem directories — cap_set, admissible_set, corner_free_set, alongside bin_packing and cyclic_graphs — one search implementation retargeted across each [3]. Every one of those evaluators has the same property the cap set evaluator has — nothing in any of them references a body, a chip, an orbit, or a fleet. Four zero-substrate results from one paper is a considerably stronger claim than one, and it is the claim this article is actually making before it ever needs to look at a second lab’s work to confirm it.
FunSearch is not, however, the only paper to reach this publication’s desk with a zero-substrate result, and a second instance is useful because it comes from an overlapping team under a different name, less than seventeen months later, and complicates a too-easy reading of the first. AlphaEvolve’s own report, alongside its Borg scheduling heuristic and its Gemini kernel speedups, includes a second pure-mathematics result: a configuration of 593 spheres establishing a new lower bound on the kissing number in eleven dimensions [7]. Checking a kissing-number configuration is the same kind of closed, physics-free arithmetic as checking a cap set — confirm a minimum pairwise separation among the configuration’s points, count how many fit, done. The same underlying idea, a code-pretrained language model proposing candidates inside an evolutionary loop, produced a zero-substrate mathematics result twice, from the same lab, in well under two years.
That recurrence supports this article’s claim, but it also sharpens what the claim actually is. It is not that FunSearch or AlphaEvolve, as systems, live permanently at the zero-substrate end of the axis — AlphaEvolve’s own headline result, the Borg heuristic, sits at the opposite, maximally physical end, meaningless without Google’s live global fleet to run against [7]. It is that the method itself, an evolutionary loop with a code-pretrained language model in its proposal step, is substrate-agnostic in a way no earlier evolutionary method has been — able to produce, within the same reporting period and without changing the search’s structure at all, a result that needs a data center’s actual global load and a result that needs nothing but a closed arithmetic check. The boundary this article is describing was crossed once, by FunSearch, in December 2023. What AlphaEvolve’s kissing number shows, seventeen months on, is that the boundary stays open rather than closing behind the system that first found it.
A Formal Checker Is Still a World, Just an Unusually Thin One
State the objection this claim earns honestly, because it is real and not a rhetorical concession offered for balance. A formal proof-checker is, in an important sense, still an environment a search has to survive contact with: the mod-three closure rule is deterministic and almost universally hostile to a randomly generated candidate, the same way a real chemical assay is almost universally hostile to a randomly mutated enzyme. Calling that environment “no substrate at all” overstates what is actually true. The precise version of the claim is narrower: the cap set evaluator requires no reference to anything outside the formal system that defines the problem — no measurement of a molecule, no orbit, no fleet, no simulated body, not even a proxy for one — while every other evaluator surveyed in this article requires exactly that kind of external reference to return a meaningful score at all. FunSearch’s search happened entirely inside a closed formal system, verifiable by pure computation with nothing imported from the physical or simulated world anywhere in the loop — a genuinely different kind of thinness than “ran on a computer,” which is true of every method in this article and therefore not the distinction doing any work here.
The thinness of the substrate did not, however, make the discovered object itself illegible to a human mathematician once the search was done — a fact DeepMind’s own team found by looking closely at what they had produced. Puzzled that the 512-point set “exhibited some obvious regularities,” their supplementary material reports, they decomposed it by hand into four 128-element pieces, each defined by a distinct symmetry condition on how many of a vector’s coordinates mirror each other around its center — a property they named “reflections” after noticing the discovered priority function depended heavily on exactly this kind of coordinate symmetry [2]. Having reconstructed that structure, they noted plainly that “these ideas are strikingly similar to the construction of the Hill cap,” an older, hand-derived construction that gives the optimal 112-point cap in six dimensions [2]. A search that touched no world at all still produced an object with enough mathematical texture that a human, working backward from the code, could recognize its kinship with existing, hand-built mathematics. That is not evidence against this article’s claim — the search itself never consulted the Hill cap, or anything like it, while running — but it is the honest complement to it: an empty substrate does not guarantee an alien result, only an unassisted one.
One Named Co-Author Is the Kill Criterion’s Whole Weight
There is a second, more specific way this claim can fail, and it does not require doubting anything reported above. Jordan Ellenberg — one of the two mathematicians credited with the field’s best-known upper bound on cap set sizes, alongside Dion Gijswijt [5] — is a named co-author on FunSearch’s own paper, confirmed independently in Croot, Lev and Pach’s own bibliography as well as DeepMind’s [1, 5]. A domain-boundary claim about a search touching no world at all has to reckon honestly with the fact that one of the handful of people alive with the deepest personal command of this exact problem chose the representation the search operated over — the greedy, point-by-point construction a priority function scores — and then verified what came out. If that representation itself smuggled in enough of Ellenberg’s own accumulated intuition about where a good cap set tends to live, rather than being a generic encoding any programmer could have written with no special expertise in this problem, then some of what looks like a search finding a world-free result was actually the search filling in a narrow, human-shaped gap inside a much larger amount of human-supplied structure — and the honest label for the outcome shifts from a domain-expansion event to an unusually well-instrumented assisted proof.
That distinction is testable, not merely rhetorical, and stating what would settle it is this article’s own falsifier: run the identical search procedure, unchanged, on a different closed combinatorial problem, encoded by a mathematician with no comparable personal history with that specific target, and see whether a comparably record-breaking construction still emerges. If it reliably does, the representation Ellenberg chose was doing generic mathematical work rather than encoding a personal near-solution, and the domain-boundary claim holds as stated. If FunSearch-class systems only ever produce results this dramatic on problems where a deeply expert co-author has hand-picked the representation and stood ready to verify the output, the honest reading narrows to exactly the alternative this section names.
The Bottleneck Just Moved From a Lab to a Checker
None of the four physical or simulated substrates surveyed above are obsolete, and nothing here argues they will be. Arnold’s directed evolution still needs a real cell; Salimans and colleagues’ evolution strategies still need a physics engine faithful enough to transfer; AlphaEvolve’s own Borg heuristic still needs Google’s actual fleet to mean anything. What changes, once a fitness function can be a closed formal check with nothing physical or simulated behind it, is which problems are even candidates for this method at all. Before FunSearch, the practical gate on applying an evolutionary search to a new domain was mostly: does a lab, a simulator, or a live deployment already exist to score a candidate? After it, a second, cheaper gate opens beside the first: does this problem have any exact, closed, cheaply computable way to check a candidate answer, with no laboratory or simulator required? Formal verification, program correctness against a written specification, other combinatorial constructions with a closure rule as simple as this one’s — an entire category of problems that never needed a wet lab or a physics engine, because they were never about the physical world to begin with, is now a legitimate target for the identical search procedure that found a cap set.
The bottleneck for trying this method on the next such problem is no longer whether anyone can build a world for the search to run in. It is only whether anyone can write, in closed form, the rule a correct answer has to satisfy — and mathematics has been stating rules like that for over a century, waiting, until a mathematician on the search’s own byline and a language model that had never seen a cap set sat down together in December 2023, for a search that finally needed nothing else.
