Clapton: Clifford Assisted Problem Transformation for Error Mitigation in Variational Quantum Algorithms

Lennart Maximilian Seifert, Siddharth Dangwal, Frederic T. Chong and Gokul Subramanian Ravi

Near-term quantum computers are too noisy to solve chemistry and physics problems as accurately as needed, and a leading class of algorithms searches for a problem's lowest-energy state on these noisy machines; this work from Chicago and Michigan notices that a device's noise is not random but biased toward certain states, and that a problem can be rewritten into an equivalent one with the same answer but whose good solution lands on the states the hardware handles most reliably — found entirely on a classical computer using efficiently-simulable quantum operations — giving a far better, noise-robust starting point that improves solution quality by up to 13 times.

The argument in one glance

Problem

Noisy quantum machines are too imprecise for variational algorithms

Variational quantum algorithms find a problem's lowest-energy state by tuning a quantum circuit on the hardware, but near-term devices are too noisy to reach the accuracy that chemistry and physics demand, and existing error mitigation is not enough.
What people did

Apply general error-mitigation techniques

Use error-mitigation methods to reduce the impact of device noise on the algorithm's results, treating the noise as something to suppress after the fact.
Why it fell short

The good solution may land on states the hardware runs poorly

Device noise is not random but biased — some quantum states run far more reliably than others. General mitigation ignores this structure, and nothing steers the algorithm's good solution toward the states the device handles well, so accuracy still falls short as problems grow.
This paper's idea

Rewrite the problem to match the device's noise (Clapton)

Clapton transforms the problem into an equivalent one with the same answer but whose known-good solution lands on noise-robust hardware states. It searches, entirely classically, over efficiently-simulable Clifford transformations to find the one that lowers the noisy energy of good states, guided by the variational principle — improving the VQA starting point by 1.7 to 3.7 times on average, up to 13.3 times.

Why this problem is worth solving

Variational quantum algorithms are the most credible way to get useful work out of today’s imperfect quantum machines, which makes their accuracy limits a central obstacle.

Near-term quantum computers are noisy and intermediate-scale (often called NISQ devices): they have relatively few qubits, and those qubits suffer from imperfect gates, limited coherence, faulty state preparation and measurement, and crosstalk, so they cannot run the huge, fully error-corrected algorithms envisioned for the future. What they can potentially do useful work on are variational quantum algorithms (VQAs), a hybrid family in which a parameterized quantum circuit runs on the hardware while a classical optimizer tunes its parameters over many iterations to minimize the energy of a target objective, encoded as a mathematical operator called the Hamiltonian. The lowest energy corresponds to the answer, and the quantum state achieving it is the problem’s ground state. VQAs power tasks like estimating the electronic energy of molecules or approximating optimization problems, and they have some built-in robustness to noise. But that robustness has limits: on real devices, even with error mitigation, VQA accuracy often falls notably short of the stringent precision that molecular chemistry and similar fields require, and the shortfall worsens as problems scale, so better error mitigation tailored to VQAs directly expands what these machines can usefully do.

The key that this work turns is that device noise is not a blank wall to endure but a structured bias that can be exploited.

The noise on a quantum device is not featureless randomness; it has structure rooted in the physics of the qubits and their environment. It varies over time and across qubits, but a significant part of it can be broken down into components that are well understood and can be modeled accurately and, importantly, scalably on a classical computer. A simple example of this structure is a state-dependent bias: on most qubits the all-zeros ground state is executed with higher fidelity than excited states, because qubits tend to decay toward the ground state. As a consequence, a circuit that mostly navigates through highly-excited states (states with many qubits in the excited configuration, a large so-called Hamming weight) tends to accumulate more error than a circuit that stays close to the all-zeros state throughout. This suggests a lever: if you know a device’s noise profile, and you know something about the state a circuit should produce, you might be able to transform the circuit so that its important computation happens on the states the hardware runs most reliably, then undo the transformation to recover the answer. The catch is doing this soundly and efficiently, which is exactly what Clapton works out.

What people did before, and where it broke

Rely on VQAs’ inherent noise robustness. Trust that variational algorithms tolerate some noise and run them directly. Where it broke. The tolerance is limited, so on real devices the accuracy falls short of chemistry-grade precision, and the gap widens as problems grow.
Apply general error-mitigation techniques. Use methods that suppress the effect of device noise on results after the fact. Where it broke. They help but not enough, and they treat noise as generic, ignoring that it is structured and biased toward certain states.
Find a good classical initialization with Clifford simulation (CAFQA). Use classically-simulable Clifford circuits to search discrete parameter settings for a good VQA starting point. Where it broke. It searches over circuit-parameter choices without transforming the problem to match the device’s noise, so it does not steer the good solution onto noise-robust hardware states.
Hand-tune circuits toward low-error states. Manually bias a circuit toward states the hardware runs well. Where it broke. Without a principled, automatic, noise-model-driven method that provably preserves the answer, this does not generalize across problems and devices.
The gap. No approach automatically rewrote the VQA problem into an equivalent one whose good solution lands on noise-robust states, verified classically and guaranteed to keep the same answer. Providing that is what Clapton does.

How Clapton works

From enduring device noise to reshaping the problem around it

↓ →
new
↓ →
new
↓ →
new
↓ →
new
↓ →
new

The idea

Reshape the problem to fit the device’s noise instead of fighting it. Clapton’s foundational move is to stop treating device noise as a fixed adversary to suppress and instead exploit its structure: since some quantum states run far more reliably than others, it transforms the VQA problem into an equivalent one whose good solution lands on those noise-robust states, so the computation naturally suffers less error. The problem is rewritten to match the hardware, rather than the hardware being asked to run an unfavorable problem. Tailoring how a variational quantum problem is executed to the specific error characteristics of the device, rather than applying a one-size-fits-all correction, is the same move the application-tailored VQA error-mitigation work covered elsewhere on this site makes, shaping the mitigation to the particular problem and device so that the correction targets the errors that actually matter instead of treating all noise generically.

Do the hard search classically, using efficiently-simulable operations. The transformations Clapton searches over are Clifford operations, a special class of quantum operations that can be simulated efficiently on a classical computer, and it pairs them with a classically-simulable model of the device noise. This lets Clapton evaluate, entirely on a classical machine and without spending scarce quantum runs, how noisy each candidate transformation makes the known-good states, and search for the best one before ever touching the device. Offloading the expensive exploration onto a classical model of the quantum error, so the quantum hardware is spared the search and used only for the final, improved execution, is the same discipline the classical error-modeling work covered elsewhere on this site follows, characterizing and simulating the device’s errors on a classical computer so the costly quantum resource is reserved for the work only it can do.

Transform the problem without changing its answer, guaranteed by a principle. The Clifford transformation conjugates the Hamiltonian, which produces a genuinely equivalent problem — the same minimum energy, hence the same solution — just expressed so that it behaves better under noise, and the inverse transformation recovers the original answer. Correctness is anchored by the variational principle: because any state’s energy is an upper bound on the true ground-state energy, driving the good states’ noisy energy lower can only move toward the true answer, never fabricate one below it. Rewriting a computation into an equivalent form that runs better on the target hardware while provably preserving the result is the same design the qubit-reuse compilation work covered elsewhere on this site is built on, transforming a quantum program into a hardware-friendlier equivalent that computes exactly the same thing, so the efficiency gain never comes at the cost of the answer.

Following a VQA problem through Clapton

Rewriting a molecular-energy problem to run better on noisy hardware

A trace of Clapton preparing a VQA problem, following the paper's Clifford-transformation and variational-principle design.

Step 1 of 5

Start from a VQA problem and its Hamiltonian

A scientific problem — say a molecule's energy — is expressed as a Hamiltonian whose lowest energy is the answer. Running the variational algorithm to find it on a noisy device gives poor accuracy.

The ground state of the Hamiltonian encodes the solution.

Why it works

Noise structure means some states run better. Because device noise is biased, favoring states like the all-zeros ground state → mapping the good solution onto such states reduces the error it accumulates → so the transformed problem is evaluated more faithfully on the hardware.
Conjugation preserves the answer exactly. Because a Clifford transformation conjugates the Hamiltonian into an equivalent operator with the same minimum energy → the solution is unchanged and the inverse recovers it → so the fidelity gain costs nothing in correctness.
Clifford operations keep the search classical. Because Cliffords and the noise model are efficiently simulable classically → Clapton can evaluate and search transformations without quantum runs → so the expensive optimization happens off the scarce quantum device.
The variational principle bounds the search soundly. Because any state’s energy is an upper bound on the true ground energy → lowering the good states’ noisy energy can only approach the true answer → so minimizing that energy is a safe objective, not a way to cheat.
A better start compounds through the optimizer. Because Clapton produces a far better, noise-robust initialization → the classical optimizer begins closer to the true ground state on hardware that runs it well → so the whole VQA reaches higher final accuracy.

What it costs (trade-offs and scope)

It relies on having good states and an accurate noise model. Clapton’s hypothesis is that the known-good states are close to the true ground state and the noise model is reasonably accurate. The paper argues both generally hold, but on problems where a good classical state is hard to find, or where noise is poorly modeled, the benefit shrinks.
It improves the initialization, not the entire run by itself. Clapton produces a much better, noise-robust VQA starting point; the classical optimizer still has to refine from there, and the final quality depends on that downstream process too, though a better start compounds.
The transformation search has a cost. Searching over Clifford transformations, even classically simulable ones, is an optimization with its own compute cost; it is far cheaper than quantum runs, but the search space and its exploration are part of the framework’s complexity.
It targets the noise components that are classically modelable. The approach exploits the portion of device noise that can be captured in a classically-simulable model; noise that resists such modeling is not directly addressed, so the gains reflect how much of the real noise fits the model.
The improvements vary widely. The reported 1.7 to 3.7 times mean initialization improvement, up to 13.3 times, spans a broad range across applications and devices; the benefit depends on how much noise structure there is to exploit for a given problem and machine.
It is complementary to, not a replacement for, error correction. Clapton is a near-term mitigation for noisy devices; it does not provide the fault tolerance of full quantum error correction, and its role is to stretch the useful reach of NISQ-era VQAs, not to substitute for the corrected machines of the future.

The evaluation

Approaches to running variational quantum algorithms on noisy devices

Property	General error mitigation	Classical Clifford initialization (CAFQA)
Exploits noise structure
What it changes	Post-processes results	Searches circuit parameters
Preserves the exact answer	Depends on method
Where the search runs		Classical (Clifford)
VQA initialization quality	Baseline

Approaches to running variational quantum algorithms (VQAs) on noisy near-term devices, as compared in the paper. VQAs find a problem's lowest-energy ground state by tuning a quantum circuit, but device noise limits accuracy; general error mitigation helps but treats noise as generic, and does not steer the algorithm's good solution toward the states the hardware runs reliably. The prior state-of-the-art initialization method, CAFQA, uses classically-simulable Clifford circuits to search for a good VQA starting point over circuit parameters, but does not transform the problem to match the device noise. Clapton exploits the fact that device noise is structured and biased (for instance, the all-zeros ground state runs with higher fidelity than excited states) by transforming the VQA problem's Hamiltonian, via conjugation with a Clifford operation, into an equivalent problem with exactly the same minimum energy but whose known-good states map onto noise-robust hardware states. Because Clifford operations and the device-noise model are both efficiently simulable classically, Clapton searches these transformations entirely on a classical computer, using the variational principle (any state's energy upper-bounds the true ground energy) to keep the search sound and the answer intact, then runs the transformed problem on the device as a better initialization and inverts the transformation to recover the solution. Evaluated on physics and chemistry applications across noise models and real quantum devices, Clapton improves VQA initialization by 1.7 to 3.7 times on average, up to a maximum of 13.3 times, over the state-of-the-art baseline.Underlined values explain themselves when clicked.

Where this stops working

What to keep in mind

Clapton is an elegant quantum error-mitigation result that reframes noise from an obstacle into a lever. The context is that variational quantum algorithms are the leading near-term use of noisy quantum computers, solving chemistry and physics problems by searching for a Hamiltonian’s lowest-energy ground state, but device noise keeps their accuracy below what those fields require, and generic error mitigation is not enough. The paper’s insight is that quantum device noise is not random but structured — some quantum states, like the all-zeros ground state, are executed far more reliably than highly-excited ones — and that a problem can be rewritten into an equivalent form whose good solution lands on those reliable states. Clapton does this by conjugating the problem’s Hamiltonian with a Clifford operation, which yields the same minimum energy (the same answer) but a noise-robust structure, and crucially it finds the best such transformation entirely on a classical computer, because both Clifford operations and the modeled device noise are efficiently classically simulable, spending no quantum runs on the search. The variational principle — that any state’s energy is an upper bound on the true ground energy — makes minimizing the good states’ noisy energy a sound objective that cannot fabricate a false answer. The reported gains are substantial: 1.7 to 3.7 times mean improvement in VQA initialization, up to 13.3 times, on real devices and noise models. Read the scope with care. It rests on having classically-estimated good states close to the ground state and a reasonably accurate noise model, both of which the authors argue generally hold but which can fail; it improves the starting point rather than replacing the whole optimization; it only addresses the noise that fits a classical model; the gains vary widely by problem and device; and it is a NISQ-era mitigation, complementary to, not a substitute for, full error correction. The durable idea is that when hardware errors are structured, the best response may not be to suppress them but to reshape the problem so its important computation happens where the hardware is strong — a move made safe here by transforming into a provably equivalent problem and doing the search on a classical model of the noise.

Background

Why near-term quantum computing leans on classical help

It helps to see Clapton within the defining strategy of near-term quantum computing: because the quantum hardware is scarce and noisy, the winning systems lean heavily on classical computation to model, mitigate, and route around the device’s imperfections, reserving the quantum machine for only what it uniquely provides. Variational algorithms are already hybrid by design, and a whole ecosystem of techniques has grown up to characterize device noise and error-correct or error-mitigate against it so that useful results emerge from imperfect machines. The quantum-error-correction decoding work covered elsewhere on this site reflects the longer-term arm of this effort, building the machinery to detect and correct errors fast enough for fault-tolerant operation, whereas Clapton is a near-term counterpart that squeezes more out of today’s uncorrected devices by exploiting the structure of their noise. The common thread is that quantum advantage in this era is a co-design between classical and quantum resources: the more of the error handling and problem shaping that can be pushed onto efficient classical computation — noise modeling, Clifford simulation, transformation search — the more the fragile quantum device can be aimed at exactly the states and computations it runs best. As devices scale but remain noisy for years to come, techniques like Clapton that let classical insight reshape quantum problems to fit real hardware are likely to remain central to extracting value before full fault tolerance arrives.

If you remember only three things

1. Variational quantum algorithms (VQAs) are a leading near-term use of noisy quantum computers: they find a problem's answer by tuning a parameterized quantum circuit on the hardware while a classical optimizer minimizes the energy of a target operator (the Hamiltonian), whose lowest-energy ground state encodes the solution, for tasks like molecular energy estimation. But near-term devices are too noisy — imperfect gates, decay, state-preparation-and-measurement errors, crosstalk — so VQA accuracy falls short of the precision chemistry and physics need, and generic error mitigation is insufficient. The key observation is that device noise is not random but structured and biased: some quantum states run far more reliably than others (for example, the all-zeros ground state has higher fidelity than highly-excited states because qubits decay toward it), yet nothing in the standard formulation steers the algorithm's good solution onto the states the hardware handles well, and a significant part of this noise can be modeled accurately and scalably on a classical computer.
2. Clapton (Clifford-Assisted Problem Transformation) rewrites the VQA problem to match the device's noise. It transforms the problem's Hamiltonian by conjugating it with a Clifford operation, producing an equivalent problem with exactly the same minimum energy (the same answer) but a different structure whose known-good solution lands on noise-robust hardware states. Because Clifford operations and the device-noise model are both efficiently simulable on a classical computer, Clapton searches over these transformations entirely classically — spending no scarce quantum runs — to find the one that most lowers the noisy energy of classically-estimated good states (states close to the ideal ground state). The variational principle, that any state's energy is an upper bound on the true ground energy, makes minimizing that noisy energy a sound objective that moves toward the real answer rather than fabricating a false one below it. Clapton then runs the transformed problem on the device as a much better, noise-robust initialization and applies the inverse transformation to recover the original solution.
3. Built as an end-to-end application-to-device framework, Clapton improves VQA initialization quality by 1.7 to 3.7 times on average, up to a maximum of 13.3 times, over the state-of-the-art baseline (CAFQA) across physics and chemistry applications, evaluated on both noise models and real quantum devices. Scope: it depends on having classically-estimated good states close to the ground state and a reasonably accurate noise model (generally true but not always); it improves the starting point rather than the whole optimization by itself; it addresses only the noise that fits a classical model; the improvements vary widely by problem and device; and it is a near-term mitigation complementary to, not a replacement for, full quantum error correction. The durable lesson is that when hardware errors are structured, the strongest response can be to reshape the problem so its important computation happens where the hardware is reliable — made safe by transforming into a provably equivalent problem and performing the search on a classical model of the noise.

Check yourself

Check your understanding

1. What are variational quantum algorithms, and why does device noise limit them?
2. What is the key observation about quantum device noise that Clapton exploits?
3. How does Clapton transform the problem, and why does the answer stay correct?
4. What did Clapton achieve, and what are its limitations?

Sources

The paper is “Clapton: Clifford Assisted Problem Transformation for Error Mitigation in Variational Quantum Algorithms” by Lennart Maximilian Seifert, Siddharth Dangwal, Frederic T. Chong, and Gokul Subramanian Ravi, published at ASPLOS 2024, DOI 10.1145/3622781.3674178. The authors are at the University of Chicago and the University of Michigan.

This explainer is based on the full text of the paper, obtained from the authors’ arXiv version (arXiv:2406.15721, a Creative Commons Attribution / CC-BY version). The problem framing (variational quantum algorithms as hybrid algorithms that tune a parameterized quantum circuit with a classical optimizer to minimize a Hamiltonian’s energy, whose ground state is the solution, for near-term noisy quantum devices; the limits of NISQ hardware and existing error mitigation for the precision that chemistry and physics require; and the key observation that device noise is structured and biased, with state-dependent effects such as the all-zeros ground state having higher fidelity than excited states, and that a significant part of it can be modeled scalably on a classical computer), the Clapton design (transforming the VQA problem’s Hamiltonian by conjugating it with a Clifford operation to obtain an equivalent problem with the same minimum energy but a noise-robust structure; leveraging classically-estimated good states, a classically-simulable noise model, and the variational principle; searching classically over Clifford transformations to lower the noisy energy of known-good states because Clifford operations and the noise model are efficiently simulable; the contrast with CAFQA’s search over circuit parameters; and the end-to-end application-to-device pipeline that produces an improved, noise-robust VQA initialization and inverts the transformation to recover the solution), and the results (mean VQA initialization improvements of 1.7 to 3.7 times, up to a maximum of 13.3 times, over the state-of-the-art baseline across physics and chemistry applications on noise models and real quantum devices) are all drawn directly from the paper. Background explanations of NISQ devices, VQAs, Hamiltonians and ground states, Pauli and Clifford operations, Hamming weight, and the variational principle are standard and provided to make the paper’s contribution understandable.