Blind Quantum Computing

Quantum computers will likely live in a few data centres, accessed remotely — much like classical cloud computing today. That raises a sharp question: can a client run a computation on a powerful remote server without revealing what the computation is, what the inputs are, or what the output is? Remarkably, the answer is yes. Blind quantum computing (BQC) lets an almost-classical client delegate a quantum computation to an untrusted server while keeping everything private.

The trust problem

In classical cloud computing, the provider sees your data and your program. Homomorphic encryption can hide data classically but is expensive and does not by itself hide the program. Blind quantum computing achieves something stronger and information-theoretic: the server performs the work yet learns essentially nothing about the client's algorithm or data — privacy guaranteed by the laws of physics, not by an assumed-hard problem.

The client only needs to prepare single qubits

The elegant feature of the Broadbent–Fitzsimons–Kashefi (BFK) protocol is how weak the client may be. The client does not need a quantum computer. It only needs to prepare individual qubits in states of the form

|+_\theta\rangle = \frac{|0\rangle + e^{i\theta}|1\rangle}{\sqrt{2}}, \qquad \theta \in \Big\{ 0, \tfrac{\pi}{4}, \tfrac{2\pi}{4}, \ldots, \tfrac{7\pi}{4} \Big\},

and send them to the server over a quantum channel. The angle $\theta$ is chosen secretly and at random by the client. The server, receiving a qubit on the equator of the Bloch sphere, cannot tell which $\theta$ was used — every such state looks maximally mixed to it.

Measurement-based computation as the engine

BQC is built on measurement-based quantum computation (MBQC). Instead of applying a circuit, the server:

entangles the client's qubits into a large cluster (graph) state;
measures them one at a time, in bases the client dictates step by step.

The computation is driven entirely by the choice of measurement angles and the order of measurements. Because the underlying qubits already carry the client's secret $\theta$ offsets, the client can issue each measurement instruction as a blinded angle

\delta = \phi + \theta + r\pi,

where $\phi$ is the true MBQC angle the algorithm needs, $\theta$ is the secret preparation phase, and $r \in \{0,1\}$ is a random bit that also hides the measurement outcome. The server faithfully measures at $\delta$ and reports the result, but $\delta$ is uniformly random from its viewpoint, so it reveals nothing about $\phi$ .

What the server learns

Under BFK, an honest-but-curious server learns at most an upper bound on the size of the computation (how many qubits and measurements) — never the algorithm, the data, or the result. This blindness is unconditional: it does not rest on any computational hardness assumption, which is strictly stronger than classical encryption-based privacy.

Verifiability

A natural follow-up worry: if the server is hidden from the computation, how does the client know it did the work correctly? Extensions to BQC add verification by secretly interleaving trap qubits — dummy positions whose correct measurement outcomes the client can predict. A cheating server has no way to distinguish traps from real computation qubits, so any tampering is caught with high probability. This turns blind computing into verifiable delegated quantum computing, a cornerstone for trustworthy quantum cloud services.

Why it matters for networks

Blind quantum computing is one of the headline applications that justify building a quantum internet (Stage 4 in the roadmap: it needs quantum memory at the server). It shows that networked quantum resources enable qualitatively new guarantees — perfect privacy of a delegated computation — that no classical network can match. As small quantum servers come online, BQC is a leading candidate for how clients will use them without surrendering their secrets.