Measurement-Based Quantum Computing

Most descriptions of quantum computing imagine a sequence of gates — unitary operations that spin qubits around like tops until the answer emerges. That picture is powerful, but it is not the only one.

In measurement-based quantum computing (MBQC), proposed by Robert Raussendorf and Hans Briegel in 2001, the order is reversed. You start by preparing a large cluster state — a grid of qubits wired together by entanglement — and then compute purely by measuring individual qubits one at a time. No unitary gates are applied during the computation itself; measurement is the only operation, and every measured qubit is gone forever.

The trick is that which angle you measure at, and which qubit you measure next, can depend on outcomes so far. This adaptive feed-forward is what turns a destructive sequence of measurements into a controlled, reversible-in-principle computation that is provably universal: anything a standard quantum circuit can do, MBQC can do too.

It sounds paradoxical — how can destroying information compute something? The answer lies in the hidden correlations baked into the cluster state long before the first measurement was made.

Below is a four-qubit linear cluster state. Each qubit starts in the $|+\rangle$ state and adjacent pairs are entangled with a controlled-Z gate. Pick a measurement angle $\phi$ (in the XY-plane of the Bloch sphere) for each qubit from left to right. The outcome of each measurement randomly gives $\pm 1$, but the angle you choose steers the logical operation applied to the remaining qubits.

<!-- {{c_html_comment}} -->
<p class="hint">{{hint_para}}</p>
<div id="cluster" class="cluster-wrap"></div>
<div id="status" class="status"></div>
<div class="btns">
  <button id="btn-run" type="button">{{btn_run}}</button>
  <button id="btn-reset" type="button" class="ghost">{{btn_reset}}</button>
</div>

/* {{c_css_comment}} */
* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; padding: .5rem; }
.hint { font-size: .88rem; color: #444; margin: 0 0 .8rem; line-height: 1.5; }
.cluster-wrap { display: flex; align-items: center; gap: 0; margin-bottom: .6rem; overflow-x: auto; }
.qubit-col { display: flex; flex-direction: column; align-items: center; gap: .3rem; }
.wire { width: 32px; height: 2px; background: #adb1b8; margin-top: 28px; flex-shrink: 0; }
.qubit-box { width: 64px; padding: .45rem .3rem; border-radius: 10px; border: 1.5px solid #cdd9e3;
             background: #e8eef3; text-align: center; }
.qubit-box.measured { background: #f0f4f8; border-color: #b0bec5; opacity: .72; }
.qubit-box.active { border-color: #1d3557; background: #dce8f5; }
.qubit-label { font: 700 13px ui-monospace, monospace; color: #1d3557; margin-bottom: .2rem; }
.qubit-label.measured-lbl { color: #888; }
.angle-row { display: flex; align-items: center; gap: 4px; justify-content: center; }
.angle-row label { font-size: .75rem; color: #555; }
select { font: 13px system-ui; border: 1px solid #adb1b8; border-radius: 5px;
         padding: 2px 4px; background: #fff; cursor: pointer; }
select:disabled { opacity: .45; cursor: default; }
.outcome-row { font: 700 13px ui-monospace, monospace; min-height: 1.2em; color: #555; }
.outcome-row.plus { color: #0a7d33; }
.outcome-row.minus { color: #c92f3c; }
.corr-row { font-size: .7rem; color: #888; min-height: 1em; }
.status { font-size: .95rem; font-weight: 600; min-height: 1.5em; margin-bottom: .4rem; }
.status.ok { color: #0a7d33; }
.status.info { color: #1d3557; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }
button:disabled { opacity: .45; cursor: default; }

// Code not found

Notice that the measurement outcome is random — you cannot control it. What you control is the angle. The correction step shows how adaptive feed-forward absorbs randomness: a $-1$ outcome triggers a Pauli correction on the next qubit so that the logical computation stays on track regardless of luck.

This is the core asymmetry of MBQC: the resource (the cluster state) is prepared ahead of time and consumed irreversibly. Computation flows forward like ink on paper — there is no going back.

How powerful is MBQC, and how hard is it to simulate?

• Universal for quantum computing. Raussendorf and Briegel proved in 2001 that any quantum circuit of $n$ qubits and depth $d$ can be simulated by an MBQC on a cluster state of size $O(n \cdot d)$. The two models are computationally equivalent.
• The class BQP. Because standard quantum circuits define the class BQP (bounded-error quantum polynomial time), MBQC computes exactly the same class. Whatever a quantum algorithm can do in polynomial time, so can MBQC.
• Classical simulation is hard. Sampling from the output distribution of even a constant-depth cluster-state measurement is classically hard under standard complexity assumptions. More precisely, simulating MBQC exactly is #P-hard, placing it beyond the polynomial hierarchy unless it collapses.
• Adaptive vs. non-adaptive. Without the adaptive feed-forward (i.e., all measurement angles fixed in advance), MBQC collapses to a much weaker model. The adaptivity — letting angle $\phi_k$ depend on the outcomes $s_1, \dots, s_{k-1}$ — is what grants full universality.
• Depth advantage. Some computations that require $O(n)$ depth in the circuit model need only $O(\log n)$ depth in MBQC because many measurements can be performed in parallel once the cluster is prepared.

The open question: can we prepare large, high-fidelity cluster states on near-term hardware? That engineering challenge — not the theory — is what separates today's demos from tomorrow's advantage.

MBQC is not just a theoretical curiosity — it is the native language of several emerging quantum platforms:

• Photonic quantum computing: photons are naturally hard to entangle with gates but easy to measure. Companies like PsiQuantum and Xanadu build their architectures around MBQC precisely because photon loss becomes a feature rather than a bug — a lost photon is just an early measurement.
• Fault-tolerant codes: the surface code and other topological error-correcting codes have a natural MBQC interpretation. Logical gates on encoded qubits are implemented by measuring physical qubits in specific patterns — a direct descendant of the cluster-state idea.
• Blind quantum computing: in the protocol of Broadbent, Fitzsimons and Kashefi (2009), a client with no quantum computer can delegate a computation to a quantum server. The server manipulates qubits but never learns the angles — and therefore never learns what was computed. MBQC's angle-driven structure makes this possible.
• Measurement-based classical computation: the same ideas transfer. Boolean functions can be computed by measuring graph states, connecting MBQC to problems in graph theory and linear algebra over $\mathbb{F}_2$.

Whether your platform is photonic, superconducting, or trapped-ion, the cluster-state picture offers a unified lens through which circuits, error correction, and delegated computation all look like the same thing.

Measurement-based quantum computing turns intuition on its head. In every other model of computation, measurement is the last step — the moment you stop computing and read out the answer. In MBQC, measurement is the computation, and the preparing of the cluster state is the only moment where anything reversible happens.

The payoff is striking: universality, a depth advantage for certain algorithms, natural compatibility with photonic hardware, and a framework for blind delegation that keeps secrets even from the machine doing the work. All of it flows from two ideas — entanglement as a resource, and adaptive feed-forward as a way to steer randomness into determinism.

If you want to understand why quantum simulation and fault tolerance are considered the most plausible near-term applications of quantum computers, the cluster-state picture is one of the best places to start.