Can a classical computer reliably check computations performed on a quantum processor without fully trusting that processor. Researchers at ETH Zurich and MIT have now created the first argument system enabling such verification within the BQP complexity class; it allows a standard computer to confirm calculations carried out by a single quantum prover. This new system establishes verifiable delegation of quantum circuits, requiring computational resources which scale linearly with circuit size, a significant improvement over previous methods.

Researchers have developed a new technique allowing standard computers to verify calculations performed by quantum processors without fully trusting them. This verification system operates within the BQP complexity class; it enables confirmation of computations carried out by one quantum processor using conventional computing resources. The method requires computational effort that increases proportionally to the size of the calculation being verified, unlike earlier approaches which became impractical as problems grew larger.

Researchers at ETH Zurich and MIT have created a new system allowing standard computers to verify calculations performed by quantum processors without complete trust in those processors; it operates within what is known as BQP, essentially defining all tasks a specific type of super-powerful calculator can handle. This verification method requires computational effort that scales linearly with calculation size, representing significant progress over previous approaches which became impractical when dealing with larger problems.

The team’s technique relies on ‘computational self-testing’, enabling command over the quantum register of a single prover, and builds upon the ‘Learning With Errors‘ assumption, a mathematical problem considered difficult for conventional computers, similar to how encryption depends on prime factorisation being computationally intensive. Fundamental to this process are Clifford observables, basic building blocks used to operate on qubits; imagine these as simple programming instructions for quantum bits.

Scalable quantum computation delegation via computationally self-tested provers offers constant durability

Total resource requirements for quantum computation delegation scale at O(poly(λ, log g)⋅g), an improvement over prior methods lacking this scalability. Previously, verifying computations became impractical as circuit size increased due to exponential growth in required resources. The new protocol enables efficient verification of calculations performed on quantum processors with up to *g* gates by classical computers; λ defines the level of security based on the learning with errors (LWE) assumption, a mathematical problem considered difficult for standard machines.

Notably, verification error remains constant regardless of qubit count during calculation, a feature termed ‘constant durability’ and enabled through computational self-testing which grants control over the prover’s quantum register. Computational self-testing allows classical computers to issue commands throughout computation, providing control over the calculating device known as the prover. Constant durability ensures stable verification error irrespective of qubits used in calculations. This is because it maintains consistent accuracy even when more qubits are employed.

Verifiable random remote state preparation was achieved using single-qubit Clifford observables such as σX, σY, and σZ. Replicating earlier multi-prover results within a single-prover framework via Kalai et al.’s compiler represents significant progress, although current figures describe performance under ideal conditions without accounting for limitations imposed by noisy intermediate scale quantum hardware.

This unlocks potential for secure quantum cloud computing; a standard computer can now check distant processor calculations without complete trust in that hardware. However, this advance replicates an existing result from the realm of multi-provers but does so within a streamlined, single-prover framework utilising what is known as a game compiler; questions arise regarding whether it constitutes genuinely new progress or merely efficient refinement of established techniques. The team achieved the first argument system for BQP, problems efficiently solvable by quantum computers, with resource demands scaling linearly with problem size, unlike previous verification costs which grew much faster.

A novel method has been demonstrated to verify quantum computations using only standard computers. Researchers at ETH Zurich and MIT have created the first such argument system allowing verification of any computation in complexity class BQP, establishing a means to check calculations performed by a lone quantum processor employing conventional computing resources. This advancement builds upon ‘computational self-testing’, granting classical control over the prover’s quantum register, and relies on Learning With Errors, a concept underpinning many modern security protocols.

The researchers developed an argument system for verifying quantum computations within the BQP complexity class. The new method requires computational resources that scale linearly with the size of the verified circuit, an improvement over previous approaches where verification costs increased at a faster rate. It achieves this by combining computational self-testing with the learning with errors assumption, allowing verifiable random remote state preparation using specific single-qubit observables.

👉 More information
🗞 Classical Verification of Quantum Computation with Quasilinear Resources, from Compiled Nonlocal Games
✍️ Finn Holler (Affiliation: ETH Zurich); Anand Natarajan (Affiliation: MIT)
🧠 ArXiv: https://arxiv.org/abs/2609.38060

More like this