How can we trust the output of quantum cloud computers?

At the forefront of problem-solving machines, quantum computers are unlocking new and exciting forms of computation. But what are quantum computers, and what might they mean for machine learning, drug discovery, scientific simulation, and more?

Contents:

1. What are quantum computers?
2. The challenge: trusting quantum cloud computing
3. Why public verification matters
4. Why simple fixes do not work
5. Our idea: hide the verification key inside a time-lock puzzle
6. Preventing cheating after the key is revealed
7. Why this matters for cryptography
8. Testing the approach
9. Looking ahead

What are quantum computers?

Quantum computers are advanced, experimental computing systems that use principles of quantum mechanics to process information in ways that differ fundamentally from classical computers.

Unlike traditional computers, which process information using bits measured as either 0 or 1, quantum computers use quantum bits, or qubits. Qubits can be prepared in superpositions of states, and multiple qubits can be linked through entanglement. Quantum algorithms exploit these effects, together with interference, to solve certain classes of problems more efficiently than the best known classical methods.

For some carefully defined tasks, quantum algorithms are expected to offer dramatic speedups over classical methods, although the practical advantage depends on the problem, hardware, and algorithm.

Most users are likely to access quantum computers through cloud services, not by owning quantum hardware themselves. This raises a simple but important question: how can a traditional computer user trust the result returned by a powerful quantum server?

This question is at the heart of our recent work developed in collaboration with Dr Ameer Mohammed from Kuwait University and Jaffer Mahdi from Kuwait Oil Company. The resulting paper, Time-Delayed Publicly Verifiable Quantum Computation for Classical Verifiers, has been accepted at the Association for Computing Machinery Conference on Computer and Communications Security 2026.

The challenge: trusting quantum cloud computing

Quantum computing is now in the exciting phase of moving from theory towards deployment. In the future, many organisations and individual users may access quantum processors through cloud-based, pay-per-use services.

This model could support powerful new applications, but it also introduces a trust problem.

A client may send a task to a remote quantum server and receive a result. But how can the client know that the result is correct? This is difficult because the client may only have a classical computer, and is therefore unable to repeat the quantum computation independently. If redoing the computation were easy, there would be little reason to outsource it.

This problem is known as classical verification of quantum computation. It asks whether a classical verifier can check the result of a computation carried out by an untrusted quantum prover.

In our paper accepted for the conference, we study a stronger version of this problem: can the result be verified not only by the original client, but by anyone?

Why public verification matters

In many settings, private verification is not enough.

Suppose a company outsources a high-value quantum computation to a cloud provider. If a dispute later arises, an auditor, regulator, court, customer, or another third party may need to check the result.

This requires public verifiability. Anyone should be able to inspect the proof and verify that the computation was performed correctly.

Public verification is especially relevant in applications where quantum computing may support high-impact decisions. Examples include quantum machine learning, drug discovery, genomics, personalised medicine, portfolio optimisation, risk modelling, fraud detection, and quantum-enhanced classification.

In these settings, the result of a computation may influence scientific, financial, or medical decisions. Auditability, therefore, becomes an important part of trust.

Why simple fixes do not work

A natural first idea is to use an existing privately verifiable quantum computation protocol, then publish the secret verification key so everyone can check the proof.

Unfortunately, this breaks security.

If the quantum server learns the secret verification key too early, it may be able to create a convincing proof for an incorrect result.

A second idea is to keep the secret key private until after the server has returned the proof, then publish it. This works only if the client remains online and available at the right time. It may also require a trusted third party to hold and release the key. Our goal is to avoid both assumptions.

We need a solution where the client can send one initial message, go offline, and still allow everyone to verify the result later.

Our idea: hide the verification key inside a time-lock puzzle

Our solution uses time-lock puzzles. A time-lock puzzle is a cryptographic mechanism that hides information until a certain amount of time has passed.

It is like a digital time capsule: easy to create, but deliberately slow to open.

In our protocol, the client places the private verification key inside a time-lock puzzle. The quantum server receives the public information needed to perform the computation and generate a proof, but it can't learn the verification key immediately.

The specific delay is chosen so that the server cannot solve the puzzle before it has already generated and published the computation result and proof. After the delay has passed, the puzzle can be solved, the verification key becomes public, and anyone can check the proof.

This gives us time-delayed public verifiability.

Verification is not public from the beginning. It becomes public only after the computation and proof have already been completed. This small change allows us to avoid much stronger cryptographic assumptions used in earlier approaches.

Workflow of the proposed time-delayed public verification scheme for quantum cloud computation.

Preventing cheating after the key is revealed

There is one more challenge. What stops the server from waiting until the puzzle is solved, learning the verification key, and then creating a forged proof?

To prevent this, the proof is timestamped. The verifier checks that the proof was generated before the deadline. A proof created after the verification key becomes available will be rejected.

We also need to ensure that the key recovered from the puzzle is the same key originally fixed by the client. For this, the client publishes a commitment to the verification key. Later, once the puzzle is solved, anyone can check that the recovered key matches the commitment.

Together, the time-lock puzzle, timestamp, and commitment provide a clear security structure:

1. the key is hidden at the beginning,
2. the proof must be produced before the key is revealed,
3. the key becomes public after the delay,
4. and any third party can then verify the proof.

Why this matters for cryptography

Previous approaches to publicly verifiable quantum computation have often relied on highly theoretical cryptographic tools.

One example is 'indistinguishability obfuscation'.

This can be thought of as a way of “scrambling” a computer program so that it still works, but its internal structure is extremely difficult to learn from the outside. It is a powerful idea in modern cryptography, but current constructions are far from practical.

Other approaches rely on idealized models, including classical oracle models that can be viewed as abstracting obfuscation-like functionality. These models are useful for exploring what may be possible in theory, but they abstract away details that a real-world system would need to implement. Our work takes a different route: although our security proof is still in the quantum random oracle model and uses a common reference string, the construction avoids indistinguishability obfuscation and is based on more standard post-quantum assumptions.

We show that, by delaying public verification until after the computation should be complete, we can build a practical non-interactive scheme from more standard post-quantum assumptions.

The construction relies on post-quantum time-lock puzzles, commitment schemes, and privately verifiable quantum computation protocols. To the best of our knowledge, this is the first use of time-lock puzzles to transform a privately verifiable quantum computation scheme into a publicly verifiable one.

Image of a quantum computer machine in a server room.

Testing the approach

We also implemented an instantiation of the scheme using AWS Braket, a cloud-based platform that we used to simulate quantum circuits.

Our experiments considered two types of quantum workloads. The first was random quantum circuits, which are useful as general test cases. The second was based on the Harrow-Hassidim-Lloyd algorithm, usually called HHL.

HHL is a quantum algorithm for solving linear systems: problems where one wants to find unknown values that satisfy a collection of equations. Linear systems are fundamental across science, engineering, finance, and machine learning.

A “16×16 HHL instance" means that the test problem involved a linear system represented by a 16-by-16 matrix. In simple terms, this is comparable to a system with 16 linked variables. This is not intended to be a large real-world problem; rather, it is a useful benchmark for testing the end-to-end behaviour of the verification scheme.

In our experiment, the quantum circuit computation for this 16×16 instance took around 90 seconds. The corresponding time-lock puzzle was calibrated so that solving it would take at least as long as the computation. On the classical client side, generating the puzzle itself required only around 0.05 milliseconds, excluding setup costs.

These results suggest that the additional work required from the client can be very small. This is important for users who may have limited computational resources or who may not remain online after submitting their task.

Looking ahead

Our work is a step towards a more accountable model of quantum cloud computing.

As quantum computing becomes more accessible through remote services, users will need mechanisms to verify that they received correct results. In high-stakes contexts, it may not be enough for only the original client to be convinced. Others may need to check the result too.

Time-delayed public verification offers one way forward. It does not solve every open problem in publicly verifiable quantum computation, but it shows that timing can be used as a cryptographic resource.

By combining time-lock puzzles with classical verification of quantum computation, we provide a practical route towards verifiable quantum cloud services for classical users.

You might also like:

• read the paper: Time-Delayed Publicly Verifiable Quantum Computation for Classical Verifiers
• learn more about Dr Aydin Abadi, Lecturer in Cybersecurity at Newcastle University
• discover more research from Newcastle University’s School of Computing