Variational Evolution: How Quantum Computers Learn Their Answers

A classical optimizer is breeding quantum circuits, one generation at a time

Ask what a quantum computer running today actually executes, and the honest answer disappoints anyone hoping for Shor’s algorithm at scale. No machine built as of 2026 holds enough error-corrected logical qubits to factor an interesting integer, run a full quantum simulation of an industrially relevant catalyst end to end, or execute any of the textbook algorithms that motivated the field in the 1990s. What noisy intermediate-scale quantum (NISQ) hardware runs instead is a loop, and the loop is almost embarrassingly simple to describe: prepare a parametrized quantum circuit, measure something about the state it produces, hand the number to an ordinary classical computer, let that computer propose new circuit parameters, and repeat.

This is the variational algorithm, and by 2026 it is not one technique among several — it is close to the entire working repertoire of near-term quantum hardware. The archetype is the variational quantum eigensolver (VQE), first demonstrated in 2014 on a photonic quantum processor, where Alberto Peruzzo and coauthors used the loop to compute the ground-state molecular energy of the helium hydride cation, HeH+, to within chemical accuracy ^[1]. The demonstration used only a small photonic chip, but its structural claim was the important part: instead of demanding the long coherent evolution that quantum phase estimation requires, VQE splits the work. The quantum processor’s only job is to prepare a trial state, described by a vector of adjustable parameters $\theta$, and report the expectation value of the molecule’s Hamiltonian in that state,

Everything else — deciding whether that energy is good, and deciding what $\theta$ to try next — happens on an ordinary classical processor. The quantum device answers one question, over and over: how good was this guess. The classical processor never touches a qubit; it only ever sees numbers.

The same architecture, aimed at combinatorial optimization rather than chemistry, produced the quantum approximate optimization algorithm (QAOA) later that same year. Edward Farhi, Jeffrey Goldstone, and Sam Gutmann proposed a circuit built from alternating problem and mixing unitaries, controlled by a small number of classical parameters, whose measured output approximates the solution to a combinatorial problem such as MaxCut ^[2]. For MaxCut on 3-regular graphs at the shallowest depth ($p=1$), they proved the algorithm returns a cut at least 0.6924 times the size of the true optimum — a specific, checkable guarantee rather than a promise of “quantum speedup” in the abstract, and one that improves as the depth parameter $p$ is increased ^[2].

VQE and QAOA differ in what they compute, but they share the loop, and the loop is a recognizable pattern to anyone who has run an optimizer against a black-box objective: propose a candidate, evaluate it, use the evaluation to propose something better, repeat until the evaluations stop improving. A 2021 survey by Marco Cerezo and colleagues, gathering essentially the published literature on the technique, calls this family “variational quantum algorithms” and treats it as the leading strategy for extracting anything useful from hardware too noisy to run fault-tolerant algorithms, while cataloguing, in the same survey, the open problems of trainability, accuracy and efficiency that most of the rest of this article is about ^[5]. What that survey does not spend much time naming directly is what the loop actually is, structurally: a generate-test-select cycle running against an oracle that happens to be a quantum processor. The next section makes that identification exact, and says precisely how far it can be pushed before it becomes misleading.

Population, fitness and selection have literal referents — and real evolutionary algorithms already do the searching

Calling the variational loop “evolutionary” risks being either exactly right or merely decorative, depending on which optimizer sits in the classical half of the loop, and the distinction is worth making with some precision rather than waved past.

At the most general level, evolutionary computation is defined by a schema older than quantum computing or even electronic computing: blind variation followed by selective retention. A population of candidate solutions is generated, each is scored against a fitness function, and the scores determine which candidates survive, recombine, or get discarded, with the cycle repeating across generations. Read against that schema, the variational loop’s mapping is direct rather than metaphorical in its outline: the parameter vector $\theta$ is a genotype; the measured expectation value $E(\theta)$ is a fitness score, evaluated by a fitness oracle that happens to require physical qubits rather than a spreadsheet; and the classical update rule is a selection-and-variation operator proposing the next candidate.

Where the analogy is exact and where it is loose depends entirely on what that classical update rule does. Plain VQE, run with a gradient-based optimizer such as Adam or L-BFGS, is not literally an evolutionary algorithm: it maintains one candidate at a time, computes or estimates a local gradient, and takes a deterministic step downhill. There is no population, no recombination, no selection among competing individuals — only a single lineage climbing a slope. Describing that loop as “evolution” is a schema-level analogy: it shares the generate-test-select logic evolutionary computation is built from, but it does not share evolutionary computation’s mechanism.

The analogy stops being loose the moment a genuinely population-based optimizer, or a genuinely evolutionary ansatz search, replaces gradient descent in the loop — and by the late 2010s several groups had done exactly that, for a specific practical reason: a fixed ansatz, chosen by a chemist’s intuition about which excitations matter, routinely produces circuits that are either too shallow to reach the right answer or too deep for noisy hardware to run without decohering.

Two lines of work solved this by making the circuit structure itself the object of search, rather than just its parameters, and they differ instructively in how much genuine evolutionary machinery they use. Harper Grimsley and coauthors’ ADAPT-VQE grows the ansatz one operator at a time: at each step it evaluates the gradient of the energy with respect to adding each candidate operator from a fixed pool, adds the single operator with the largest gradient, and re-optimizes — a systematic, informed selection procedure, but a deterministic, single-lineage one, closer to steepest-ascent hill-climbing over circuit structures than to a population evolving under stochastic variation ^[4]. It is adaptive; it is not, strictly, genetic.

Arthur Rattew and colleagues’ EVQE goes further, framing ansatz construction explicitly as evolutionary programming: candidate circuit topologies mutate and compete across generations, and the resulting ansätze were shown to be up to 18.6 times shallower and to use up to twelve times fewer two-qubit gates than a fixed unitary-coupled-cluster ansatz solving the same molecular problem, while tolerating at least 3.6 times less error under simulated noise than any of the fixed ansätze tested ^[7]. Dmitry Chivilikhin and coauthors’ MoG-VQE goes further still, splitting the search into two literally evolutionary algorithms operating at two different levels at once: a genetic algorithm — specifically NSGA-II, a multi-objective genetic algorithm that maintains and recombines a population of circuit topologies, selecting along a Pareto front that trades energy accuracy against gate count — searches over circuit structure, while a covariance-matrix-adaptation evolution strategy (CMA-ES), a population-based, derivative-free optimizer that adapts its own search distribution generation over generation, tunes the rotation angles within each structure ^[8]. Here the word “evolutionary” is not standing in for something else. NSGA-II and CMA-ES are evolutionary algorithms in the field’s own technical sense, developed and named decades before anyone ran them against a quantum processor, imported into this setting because a noisy, non-differentiable, expensive-to-evaluate fitness landscape is exactly the setting evolutionary computation was built to handle.

So the honest statement has two clauses, not one. Every variational quantum algorithm is a generate-test-select loop with a quantum fitness oracle, and that structural fact is not a metaphor. Whether the “select” step is itself evolutionary in the field’s technical sense is a separate, checkable question, and for a meaningful and growing share of the ansatz-search literature the answer is yes, without qualification.

The fitness landscape goes flat exactly where evolutionary search goes blind too

Any search algorithm built on a gradient — or on a fitness signal a population can climb — depends on that signal existing somewhere above the noise floor. In 2018, Jarrod McClean and colleagues at Google showed that for a broad and practically important class of parametrized quantum circuits, it typically does not.

The result, now known throughout the field as the barren-plateau problem, is precise and unwelcome. For a parametrized circuit that forms an approximate unitary 2-design — informally, a circuit random enough, or deep enough, that its output statistics resemble those of a genuinely random unitary — the variance of the gradient of the cost function with respect to almost any parameter shrinks exponentially as the number of qubits $n$ grows:

The mean gradient is essentially zero and its variance collapses just as fast, so a classical optimizer sampling that gradient from a finite number of circuit measurements sees something statistically indistinguishable from flat, uninformative noise long before it sees a genuine downhill direction ^[3]. Doubling the qubit count does not make the problem twice as hard; each additional qubit roughly halves the useful signal.

Evolutionary computation has, independently, a name for a landscape with the same defining property: a broad, connected region of genotype space across which fitness barely varies, so selection has nothing reliable to act on and search reduces, in that region, to an undirected random walk until a rare mutation carries the population off the plateau. The parallel is not that the two phenomena share a proof — they do not, and nothing here claims the quantum result is a special case of, or reducible to, any specific result from evolutionary theory. The parallel is that both are the same generic failure of any generate-test-select search: when the dimensionality of the search space grows and the fitness function’s sensitivity to a single coordinate does not keep pace, the ratio of exploitable signal to sampling noise collapses, and no amount of population size, selection pressure, or clever recombination substitutes for a gradient that genuinely is not there. Whether the search runs on a strand of DNA or a rotation angle on a superconducting transmon, a sufficiently flat, sufficiently high-dimensional landscape defeats it by the same statistical mechanism.

For variational quantum algorithms this is a harder problem than it might sound, because the qubit counts where barren plateaus set in are not exotic — McClean and colleagues showed the effect appearing already for circuits built from unstructured, sufficiently expressive random gate sequences at qubit counts well within the range of hardware that already exists, well below where any of the field’s advantage claims are aimed ^[3]. A circuit expressive enough to represent an interesting quantum state is, by the same token, close enough to a random 2-design that its training landscape goes dark.

Every fix for the plateau narrows the circuit toward what a laptop can already simulate

The response to barren plateaus, as catalogued in Cerezo and colleagues’ 2021 review, has mostly taken one of two forms: restrict the ansatz so it never becomes expressive enough to approximate a 2-design in the first place — a “problem-informed” ansatz encoding known structure about the target Hamiltonian rather than a generic, hardware-efficient template — or restrict the cost function so it depends only on a small, local patch of qubits rather than a global property of the whole register, which keeps the relevant gradient’s variance from collapsing as fast with system size ^[5]. Both strategies work, in the specific sense that they measurably slow or avoid the exponential vanishing McClean’s result describes. Both strategies are also, in a sense that only became fully explicit several years later, a confession.

In December 2023, Cerezo, Martin Larocca and a large group of coauthors — several of them authors of the original barren-plateau results — published an argument that reframes the entire mitigation program as a warning rather than a solution. Their paper’s title states the claim as bluntly as the field allows: does provable absence of barren plateaus imply classical simulability, and their answer, worked through case after case of ansätze specifically engineered to avoid barren plateaus, is that it often does ^[6]. They found that the same structural restriction keeping the gradient alive — limited entanglement growth, a small effective dimension, a cost function depending on few enough degrees of freedom — tends to be exactly the restriction that makes the resulting circuit’s outputs efficiently reproducible on a classical computer, in many cases after an initial phase of collecting some classical data from the quantum device itself ^[6]. Barren plateaus, in their framing, are fundamentally a curse of dimensionality; the field’s standard fixes work by pushing the search into some smaller, classically tractable corner of the full circuit space, and a corner small enough for a classical optimizer to navigate is frequently a corner small enough for a classical computer to simulate directly.

This is not a proof that every trainable variational circuit is classically simulable, and the authors are careful to say so — the argument proceeds case by case, across a specific but not exhaustive catalogue of ansatz families, and leaves open the possibility of a trainable regime that resists classical simulation for reasons the current analysis does not capture ^[6]. But it is a genuinely uncomfortable result for the field it comes from, and it deserves to be stated as such rather than softened: the working assumption behind roughly a decade of ansatz design — that a well-behaved training landscape and a hard classical problem could be had in the same circuit — is now an open question rather than a background premise, argued by some of the same researchers who built the mitigation program in the first place. Whether a regime exists that is simultaneously trainable, useful, and classically hard is, as of 2026, the central unresolved question hanging over the entire variational paradigm — and it is worth stating explicitly that this is a crisis about the paradigm’s method, not about any single hardware vendor’s claims, which is why it stands independently of anything the rest of this article says about specific advantage demonstrations.

Annealing breeds on a spin glass by physically cooling it toward its own ground state

Everything in the previous three sections describes gate-model hardware: a circuit built from discrete unitary operations, controlled by a classical optimizer sitting entirely outside the quantum system. Quantum annealing, the approach commercialized by D-Wave, replaces the optimizer with physics. A problem is encoded as the coupling strengths between qubits realizing an Ising-model spin glass; the hardware is initialized in the ground state of a simple, uncoupled Hamiltonian; and the couplings are then ramped up slowly enough, in principle, that the system tracks its own instantaneous ground state all the way to the final, problem-encoding Hamiltonian, whose ground state is the answer. There is no measured fitness, no classical update, no generations in any literal sense — selection, if the word applies at all, is done by the relaxation of a physical system toward its lowest-energy configuration, aided or hindered by whatever combination of quantum tunneling and thermal noise the hardware actually realizes at millikelvin temperature. Reading the evolutionary lens onto annealing at the level of individual runs is where this article’s honesty commitment requires backing off: an anneal is a single physical trajectory relaxing toward one attractor, not a population under selection, and forcing the vocabulary further than that would be the cute reading this series exists to avoid, not the precise one.

The evolutionary reading works instead at the level of the research program’s central and recurring question, which has been asked, answered no, re-asked, and re-answered yes-but, for over a decade: whether any of this is actually faster than the best classical alternative, or whether the hardware’s design merely resembles a computation without doing anything a good classical heuristic could not match. In 2014, Troels Rønnow, Matthias Troyer and colleagues tested exactly this against a 503-qubit D-Wave Two processor using random spin-glass benchmark instances, and reported finding no evidence of quantum speedup once the entire benchmark set was considered, while carefully distinguishing several technically different notions of “speedup” that earlier claims had blurred together and noting explicitly that their negative result for this specific benchmark did not rule out speedup on a different problem class ^[9]. That paper set the methodological bar the field has argued about ever since: a speedup claim is only as strong as the classical competitor it was actually benchmarked against, and a classical competitor’s absence from a paper is not evidence it does not exist.

The most recent round of that argument opened in March 2025, when Andrew King and around sixty coauthors, almost all D-Wave employees, published a Science paper reporting that D-Wave’s roughly 5,000-qubit Advantage2 prototype reproduced Schrödinger-equation-accurate nonequilibrium dynamics of three-dimensional Ising spin glasses — including frustrated, strongly coupled and non-planar biclique lattice geometries — at scales where the leading approximate classical methods they tested, including tensor-network and neural-network approaches, could not match the same accuracy within a practical runtime, reporting stretched-exponential scaling of effort for matrix-product-state methods as system size grew ^[14]. D-Wave’s own newsroom did not hedge the way the paper does: its press release calls the result “quantum computational supremacy on a useful, real-world problem,” the first of its kind, and states that the classical supercomputer comparison — Oak Ridge National Laboratory’s Frontier system, consuming more than 100,000 GPU and CPU hours — would need nearly one million years to match what the Advantage2 prototype did in minutes ^[15]. That is a vendor marketing claim, built on top of a peer-reviewed result that is considerably more hedged about which classical methods it tested and where exactly their limits lay, and the two should not be quoted interchangeably.

Within weeks, two independent classical-simulation groups had narrowed the gap the Science paper reported, using two different methods. Joseph Tindall and coauthors applied lattice-specific tensor networks with belief-propagation contraction to the same spin-glass dynamics and reported state-of-the-art accuracy using what they describe as modest computational resources, directly challenging the claim that the demonstration lay beyond classical reach ^[16]. Separately, Linda Mauron and Giuseppe Carleo applied a different classical method — a time-dependent variational Monte Carlo algorithm built on a physically motivated Jastrow-Feenberg wavefunction — and reported handling three-dimensional spin glasses up to 128 spins with correlation errors below seven percent, using resources scaling only polynomially, arguing that classical variational techniques remain competitive at system sizes considerably larger than the original claim implied ^[17]. D-Wave responded specifically to the tensor-network rebuttal, arguing in published commentary that the belief-propagation approach had not attempted the most complex non-planar biclique topologies tested on the hardware, had not reproduced the largest three-dimensional geometries, failed to converge on the most strongly frustrated low-precision ensembles, and did not reproduce the full-state and fourth-order observables the Science paper reported — a rebuttal to the rebuttal that narrows the dispute to specific problem regimes rather than resolving it ^[18].

None of this is unusual, and that is the point worth making rather than eliding. It is the same argument Rønnow and Troyer were already running in 2014, with better hardware and sharper classical competitors on both sides eleven years later. What has changed is the sophistication of the classical methods deployed to chase each new hardware claim, not the underlying epistemic structure of the dispute: a “beyond-classical” claim is a bet against classical algorithms researchers have not yet tried, and the field’s track record says that bet gets contested, often within the same publication cycle it is made.

Error correction is advancing and variational advantage is still unproven — both are true in the same sentence

Two separate scorecards belong to two separate parts of quantum computing, and 2026 is a reasonable moment to read them side by side rather than letting either stand in for the field as a whole.

The error-correction scorecard looks genuinely good. In December 2024, Google’s Quantum AI team, using its Willow processor, reported the first clear demonstration of a surface-code logical qubit operating below the error-correction threshold — meaning that increasing the code distance, roughly the number of physical qubits devoted to protecting one logical qubit, measurably decreased the logical error rate rather than being swamped by the additional physical qubits’ own error contributions, the qualitative crossover the error-correction research program has been built toward since Peter Shor’s original 1995 proposal ^[13]. Concretely, increasing the code distance by two suppressed the logical error rate by a factor of 2.14 ± 0.02, and the largest code tested — a 101-qubit distance-7 surface code — reached a per-cycle logical error rate of 0.143% ± 0.003%, low enough that the logical qubit’s effective lifetime exceeded that of its best constituent physical qubit by a factor of 2.4 ± 0.3 ^[13]. This is a genuinely different kind of result from anything in the variational literature: it says nothing about solving a useful problem, but it demonstrates, with a real device rather than a projection, that adding more noisy hardware to an error-correcting code makes the logical result more reliable rather than less — the scaling law the entire fault-tolerant roadmap depends on.

The quantum-utility scorecard is far less settled, and the clearest illustration is a single, closely watched exchange. In June 2023, Youngseok Kim, Abhinav Kandala and coauthors at IBM reported measuring accurate expectation values for a kicked Ising model on a noisy 127-qubit superconducting processor at circuit volumes they characterized as beyond brute-force classical computation, framing the result as evidence for the utility of quantum computing in the pre-fault-tolerant era ^[10]. The paper explicitly named the classical methods it expected to fail — one- and two-dimensional tensor-network approximations such as matrix product states and isometric tensor network states — and reported that these broke down in the strongly entangled regime where the quantum processor still returned accurate results ^[10].

That specific, falsifiable claim was tested twice within months. Joseph Tindall and coauthors, using a belief-propagation tensor-network method tailored to the heavy-hexagon connectivity of IBM’s device, reported a classical simulation more accurate and more precise than the quantum processor’s own results for the same circuits ^[11]. Separately, Tomislav Begušić, Johnnie Gray and Garnet Chan combined sparse Pauli-dynamics and tensor-network methods and reported classical simulations running orders of magnitude faster than the quantum experiment, converging to an absolute accuracy below 0.01 in the reported observables without extrapolation, using an effective bond dimension exceeding sixteen million ^[12]. Neither rebuttal claims quantum processors are useless, and neither claims IBM fabricated anything: the 127-qubit device did what the paper said it did, and the specific tensor-network methods IBM named did break down exactly as reported. What the rebuttals show is that “beyond brute-force classical computation” was true only against the classical methods actually tried in the original paper, and a different, better-suited classical algorithm closed the gap almost immediately — the same pattern the previous section documented for D-Wave’s spin-glass claim, on different hardware and a different physics problem, on the same timescale.

Put the two scorecards next to each other and the honest sentence has to hold both halves at once: quantum error correction is advancing roughly on the schedule its proponents have long projected, with Willow supplying the clearest below-threshold demonstration to date, while every claim that a variational or annealing quantum processor has done something no classical computer can match has so far been walked back, sharply qualified, or actively contested by a classical rebuttal published within the same year. Both are true, neither cancels the other, and a reader served either half alone is being sold a cleaner story than the evidence supports.

Breeding on the unmodelable was the idea worth keeping

Strip away the specific hardware, the specific rebuttals, and the specific unresolved trainability question, and one claim from this article survives everything above intact: the way NISQ-era quantum computers are actually programmed is not a stopgap invented for lack of anything better, and it is not a coincidence that it converged on a schema evolutionary biology and evolutionary computation had already worked out. When a system is too complex, too high-dimensional, or too poorly understood to design for directly — when nobody can write down, in closed form, which circuit will best approximate a molecule’s ground state — the answer that keeps reappearing across very different domains is the same one: stop trying to derive the answer and start breeding it, generation over generation, against whatever fitness signal the real system will actually return.

That is not a claim that quantum computers work, in the sense of already outperforming classical machines at a task anyone needs solved. As of this writing they do not, on any application where the comparison has been run to completion against a well-resourced classical competitor. The scorecard above is the honest one: hardware is improving, error correction is crossing thresholds it has taken decades to reach, and every substantive “beyond-classical” claim in the variational and annealing literature has drawn a serious, sometimes decisive, classical response within the same publication cycle. Whether a regime exists that is simultaneously trainable, useful and classically hard remains genuinely open, and the 2023 trainability-simulability result means that regime might be narrower than the field originally hoped, or might not exist in the form it was originally imagined.

But the method question and the advantage question are separable, and only one of them has been settled. Confronted with hardware too noisy for the algorithms quantum computing was originally invented to run, the field did not wait for cleaner qubits. It built a loop — generate a candidate, measure how good it is against the real system, use that measurement to propose something better, repeat — and then, having built that loop, reached for the specific vocabulary and machinery of evolutionary search, genetic operators and evolution strategies included, precisely where the landscape got too strange, too flat, or too high-dimensional for anything else to find a foothold. That reach was not decoration. It was the correct diagnosis of what kind of problem a noisy quantum processor actually presents: a system you can only search by trying things on it directly and keeping what survives.