Measurement-Based Quantum Computing

The circuit model of quantum computing, the one you have spent dozens of chapters internalising, goes like this. Line up your qubits in |00\dots0\rangle. Apply a carefully choreographed sequence of gates — Hadamards, CNOTs, T gates — in time order. At the end, measure everything. The circuit is a recipe that unfolds in time: gate after gate, each one a unitary rotation of the state vector, measurement only at the very end.

Here is a completely different recipe.

Line up a much larger array of qubits, in a 2D lattice. Before you compute anything, put every qubit in |+\rangle = (|0\rangle + |1\rangle)/\sqrt{2}. Now walk through every edge of the lattice and apply a controlled-Z (CZ) gate between the two qubits at that edge's endpoints. You have now set up a gigantic entangled state spanning the entire lattice — the cluster state. You have not computed anything yet. You have just prepared a resource.

Now compute. Pick a qubit. Measure it in a specific basis — the basis depends on what gate you want the measurement to implement, and on the outcomes of earlier measurements. Look at the outcome. Pick the next qubit, choose its measurement basis adaptively based on the outcomes so far, measure it. Continue until all but a chosen subset of qubits have been measured. The unmeasured qubits carry the quantum output of the computation.

That is measurement-based quantum computing. There are no gates during the computation. All the entanglement is laid down in advance; the computation is a cascade of single-qubit measurements, each one consuming one qubit of the lattice. Raussendorf and Briegel proved in 2001 that this model is computationally equivalent to the circuit model — anything the circuit model can do, MBQC can do, and vice versa. The direction of the computation is baked into the lattice, which is why the model is also called the one-way quantum computer: a measurement is not reversible, so the computation flows in one direction through the lattice and cannot be run backwards.

The photonic specialisation of MBQC — why photons are uniquely suited to it, and how PsiQuantum and Xanadu have built their billion-dollar strategies around it — is covered in chapter 169. This chapter is the general theory. It works for any qubit platform; it just happens to be natural for photons.

The framework — Raussendorf-Briegel 2001

Measurement-based quantum computation decomposes into three steps, cleanly separated in time.

Step 1: Prepare the cluster state. Choose a graph G = (V, E). Put one qubit at each vertex of V. Initialise every qubit in |+\rangle. For every edge (i, j) \in E, apply CZ_{ij} between the two endpoint qubits. The resulting state is the graph state for G:

When G is a 2D square lattice, the graph state is specifically a 2D cluster state. This is the workhorse of MBQC.

Why the graph structure matters: two cluster states built on different graphs are not the same state. The lattice connectivity encodes which qubits can be directly related to which by the CZ gates, which in turn dictates which gates you can implement during the measurement phase. A 1D chain implements single-qubit rotations on one logical qubit; a 2D lattice implements universal multi-qubit computation; a 3D lattice implements a fault-tolerant computation over time.

Step 2: Measure with a pattern. Designate a subset I \subseteq V of input qubits, a subset O \subseteq V of output qubits (which will not be measured), and for every qubit in V \setminus O an intended measurement basis in the XY plane of the Bloch sphere: the basis

where \alpha is the measurement angle. Setting \alpha = 0 gives the X basis; \alpha = \pi/2 gives the Y basis; any angle in between gives a basis on the equator of the Bloch sphere.

The choice of \alpha for each qubit implements a particular rotation gate on the information as it is teleported through the cluster. Varying \alpha varies the gate.

Step 3: Adapt and correct. The measurement outcomes are random — each measurement gives \pm with probability 1/2 each. The randomness is not destructive, because each outcome contributes a known Pauli byproduct (an X or Z on subsequent qubits) that can be tracked classically. Two things happen in response to an outcome:

• Adaptive measurement basis. The angle \alpha of a later measurement is adjusted based on earlier outcomes, so that the logical computation proceeds deterministically.
• Classical Pauli tracking. By the time you reach the output qubits, the accumulated Pauli corrections can be applied in software as reinterpretations of the final measurement basis.

The flow of a measurement pattern (formalised by Danos-Kashefi 2007) is a mathematical function that specifies, for each measurement, which later qubit inherits the correction. A pattern is valid — i.e. deterministically simulates a target unitary — if and only if it admits such a flow.

Constructing a cluster state — pictures first

The two-qubit CZ gate multiplies the amplitude of |11\rangle by -1 and leaves all other basis states alone:

Two CZ gates on disjoint edges commute (they act on different qubit pairs), so you can apply all of them in parallel during state preparation. The cluster state depends only on the graph, not on the order in which the edges were processed.

The smallest non-trivial cluster state is two qubits joined by one edge:

Why the minus sign gives entanglement: without the sign flip on |11\rangle, the state would factor as |+\rangle|+\rangle — a pure product. The sign flip breaks the product structure. The resulting state is entangled, which is the definition of a non-product two-qubit state.

You can verify this state is entangled by trying (and failing) to write it as |\psi\rangle \otimes |\phi\rangle. The minus sign on a single basis vector is algebraically small but physically decisive — it is the entire reason the cluster state is a useful resource rather than a glorified product state.

Universality — why the 2D lattice is enough

The universality theorem of MBQC (Raussendorf-Briegel 2001; strengthened in Raussendorf-Browne-Briegel 2003) says: a 2D square-lattice cluster state of width K and length D, together with adaptively chosen single-qubit measurements in the XY plane, can simulate any quantum circuit on K logical qubits and circuit depth O(D).

The argument has a lovely structure. A horizontal row of the lattice corresponds to a logical qubit's "wire" in the circuit model. Measurements along that row, in X-basis or in an \alpha-angle basis, apply single-qubit rotations to the logical information as it propagates from left to right. The vertical edges between rows allow two adjacent logical wires to interact — specifically, a carefully-designed pattern of vertical-edge measurements implements a logical CNOT between neighbouring logical qubits.

Three classes of primitives are enough to cover the whole circuit model:

• Identity / wire: measure each qubit in the X basis. Teleports information from left to right along the row with no rotation (up to tracked Pauli corrections).
• Single-qubit rotation R_z(\alpha): measure a qubit in the \alpha-angle basis. Teleports information with a R_z rotation applied (up to tracked Pauli corrections).
• CNOT between two rows: exploit the vertical edges between the two rows; a specific measurement pattern produces a logical CNOT.

A Hadamard emerges as a special case of the rotation (combined with a particular pre/post X-basis move). A T gate emerges as R_z(\pi/4). And any single-qubit unitary decomposes into R_z-conjugated rotations via Euler angles. Combined with CNOT, that is a universal gate set.

Why a 1D chain is not universal

You can implement any single-qubit unitary on a 1D cluster chain, by composing measurements in appropriately chosen bases along the chain. What you cannot do on a 1D chain is couple two distant logical qubits. A 1D cluster has a single line of qubits; there are no two-logical-qubit wires to couple. You would need a way to make a CNOT between two separate lines, and that requires vertical edges — which only exist in 2D.

The 2D lattice provides exactly the missing ingredient. A vertical edge between two horizontal rows becomes the raw material from which a logical CNOT is built. With Cliffords (Hadamards, phases, CNOTs) and a non-Clifford (e.g. R_z(\pi/4)), you have universality. All three types of gates are implementable by single-qubit measurements on a 2D cluster.

How a measurement pattern implements a gate — the minimal picture

The operational essence of MBQC is that measuring one qubit in a specific basis implements a gate on its unmeasured neighbour. This is worth seeing in detail on the simplest possible cluster — two qubits joined by one CZ edge — because it is the atomic unit out of which every MBQC computation is built.

Consider the two-qubit cluster state

and measure qubit 1 in the X basis \{|+\rangle, |-\rangle\}.

Rewrite in terms of the X basis of qubit 1, using |0\rangle = (|+\rangle + |-\rangle)/\sqrt{2} and |1\rangle = (|+\rangle - |-\rangle)/\sqrt{2}:

Measure qubit 1. Outcome + (probability 1/2) leaves qubit 2 in |+\rangle. Outcome - (probability 1/2) leaves qubit 2 in |-\rangle = Z|+\rangle. So the X-basis measurement on qubit 1 has implemented the identity gate on qubit 2's logical information, with a Pauli-Z byproduct determined by the outcome. You track the byproduct classically and continue.

Why this is the entire MBQC principle in miniature: the X-basis measurement chose the zero rotation angle (\alpha = 0), which implemented the identity gate. If instead you had measured in the \alpha = \pi/4 basis, qubit 2 would have ended up in R_z(\pi/4) |+\rangle up to a Pauli byproduct — implementing a T gate. The measurement basis is the gate. This is how arbitrary single-qubit rotations are implemented on MBQC clusters.

Repeat this measurement-teleports-with-rotation pattern along a chain: qubit 2 is measured next (after qubit 1), teleporting the result to qubit 3 with a second rotation, and so on. A chain of n measurements implements a product of n rotations on the final unmeasured qubit — exactly the action of an n-gate single-qubit circuit.

Worked examples

3D cluster states and fault-tolerant MBQC — Raussendorf-Harrington-Goyal

In 2005-2007, Raussendorf, Harrington, and Goyal showed that a 3D cluster state — a graph state on a 3D lattice — naturally encodes a fault-tolerant surface code, with the third dimension serving as time. This is the gateway to MBQC fault tolerance, and it is the theoretical basis for PsiQuantum's entire architecture.

The construction has a lovely geometric picture. Slice the 3D cluster into 2D layers perpendicular to the time axis. Each layer corresponds to a moment in the computation; the vertical edges between adjacent layers correspond to time evolution. A defect (an error) in the cluster state manifests as a 1-dimensional string in the 3D lattice — its endpoints are detected by the stabiliser measurements, and minimum-weight perfect matching identifies the string and corrects it.

The fault-tolerance threshold of 3D-cluster MBQC is approximately 0.75%, which is comparable to the 2D surface-code threshold for conventional fault-tolerant quantum computing. Below this threshold, increasing the cluster size suppresses logical errors exponentially, just as in the standard surface code.

PsiQuantum's fusion-based quantum computing is a clever variant of 3D-cluster MBQC: instead of preparing the monolithic 3D cluster all at once, small 4-photon "GHZ-3" resource states are generated on-chip and fused into a Raussendorf-lattice 3D cluster through probabilistic Bell-state measurements. A fusion failure is tolerated as an erasure error — a missing cluster edge — which the surface code absorbs up to erasure rates of about 50%. This is why PsiQuantum's photonic architecture can work despite the fundamental probabilistic nature of linear-optical photon-photon interactions.

Continuous-variable MBQC — the Xanadu path

Continuous-variable (CV) MBQC (Menicucci, Flammia, and van Loock 2006) generalises MBQC to modes of continuous-variable light — squeezed optical modes with a continuum of eigenstates, rather than two-level qubits. The "cluster state" becomes a CV cluster state: a collection of squeezed modes entangled via beamsplitter interactions, with the Gaussian analogue of a CZ gate at each edge.

CV-MBQC has a problem and a solution. The problem: a CV cluster state measured with homodyne detection (measuring a continuous quadrature of the electromagnetic field) alone implements only Gaussian operations. And Gaussian operations on Gaussian states are efficiently classically simulable (Bartlett-Sanders 2002), so you get no quantum speedup from this alone.

The solution: introduce a non-Gaussian ingredient. Two standard options:

• Photon-number-resolving detection: a non-Gaussian measurement that, on a Gaussian cluster state, produces non-Gaussian output states. Sufficient for universality.
• GKP (Gottesman-Kitaev-Preskill) states: a specific class of non-Gaussian resource states shaped like a comb of delta functions in both position and momentum. A GKP-encoded qubit lives in a single mode of light and has its own error-correcting structure against small displacement errors. A cluster of GKP-encoded qubits combined with homodyne measurements is universal for quantum computation.

Xanadu's approach uses GKP-encoded CV cluster states. The idea: each mode of the cluster carries one GKP-encoded logical qubit; the cluster state provides the entanglement for multi-qubit MBQC; the homodyne measurements carry the computation forward; and the GKP encoding provides built-in protection against small displacement errors. The fault-tolerance threshold for GKP-CV-MBQC is around 10 dB of squeezing plus a modest GKP ancilla error rate — numbers that are individually demonstrated in state-of-the-art experiments and that Xanadu's roadmap targets combining in one machine.

Advantages and disadvantages of MBQC

Advantages:

• Ideal for photonics. All the hard two-photon work is offloaded into state preparation, where probabilistic gates are acceptable. The computation itself is just photodetector clicks — which is the single most mature operation in quantum optics.
• Parallelism. Many cluster qubits can be measured simultaneously (if the measurement order permits), which allows the effective circuit depth to be shallower than a corresponding circuit-model computation.
• Conceptual simplicity at the resource level. "Prepare a grid of entangled qubits, measure them adaptively" is a surprisingly clean story. The complexity moves into the measurement pattern and the classical control loop.
• Natural fault tolerance in 3D. The Raussendorf-Harrington-Goyal result gives you fault tolerance essentially for free on 3D clusters, without the circuit-level compilation of syndrome measurements that conventional surface-code fault tolerance requires.

Disadvantages:

• Huge cluster states. A useful computation might need 10^6-10^{10} entangled cluster qubits. Preparing and maintaining such states is a massive engineering challenge.
• Classical feedback latency. Adaptive measurements require the classical control loop to read each outcome and decide the next measurement basis faster than the next qubit's coherence deadline. This is not a fundamental problem — fast FPGAs handle it — but it is a real engineering constraint.
• No speed advantage per se. MBQC is not faster than the circuit model in any fundamental sense; it is only as fast as the circuit model. The reason to use it is hardware-dependent: on photonic hardware, MBQC is the only feasible architecture. On matter-qubit hardware (superconducting, trapped ion, neutral atom), the circuit model is usually preferable because you can do gates during the computation without needing to prepare a pre-entangled cluster.

Common confusions

• "MBQC is photonic only." No — MBQC is a general model of quantum computation defined for any qubit system. It is the native model for photonic hardware because probabilistic gates are acceptable in preparation but not in computation; it is not the native model for matter-qubit hardware. The theory works everywhere, but the practical choice depends on the platform.
• "A cluster state is a general graph state." All cluster states are graph states, but not all graph states are cluster states. "Cluster state" specifically refers to graph states on square lattices (2D or 3D). Graph states on other graphs are more general and have their own uses (GHZ states as star-graph graph states, for instance).
• "Adaptive means real-time." Yes — but "real-time" in MBQC means "the classical control system makes each decision before the next measurement happens," not "instantaneously." The measurement timing is set by the physical system (photon detectors, ion measurements, etc.) and the control loop runs fast enough to keep up, typically on an FPGA.
• "MBQC is slower than circuit-model QC." Not inherently. For a given algorithm, MBQC uses more qubits (the whole cluster) but allows more parallelism in the measurements; the net wall-clock time can be shorter. The circuit-model version is sometimes faster because it uses fewer qubits; but this is hardware-dependent, not fundamental.
• "You need a 2D cluster for universal MBQC." A 2D cluster with single-qubit adaptive measurements is the simplest universal resource. Other resources are also universal: 3D clusters (which also give fault tolerance), certain kinds of graph states on non-square lattices, and CV cluster states with non-Gaussian ingredients. The 2D square-lattice cluster is canonical because it is the simplest.
• "Measurement destroys information." In MBQC, measurement transfers quantum information — from the measured qubit to its unmeasured neighbours, plus a classical record. The "destruction" is really a change of encoding: the same logical information that was distributed across the cluster is now concentrated on the unmeasured output qubits, plus classical side-information.

Going deeper

Formal measurement patterns — the Danos-Kashefi calculus

A measurement pattern is a 5-tuple (V, I, O, E, A) where V is a set of qubits, I \subseteq V is the input subset, O \subseteq V is the output subset, E \subseteq V \times V is the edge set of the underlying graph, and A : V \setminus O \to [0, 2\pi) is an assignment of measurement angles. The measurement calculus (Danos, Kashefi, Panangaden 2007) provides rewrite rules that allow one pattern to be simplified into another — exactly analogous to circuit identities in the circuit model. Two measurement patterns that implement the same unitary are provably equivalent in this calculus. The flow of a pattern is a function f : V \setminus O \to V that identifies, for each measurement, which later qubit inherits the Pauli byproduct correction. A pattern with a valid flow deterministically simulates its target unitary. Not every pattern has a flow; finding one is a computational problem in its own right, and patterns without flows correspond to non-deterministic computations.

3D cluster fault tolerance — the detailed construction

The 3D-cluster fault tolerance construction (Raussendorf-Harrington-Goyal 2005-2007) works as follows. Take a 3D cubic lattice of qubits and apply CZ gates along every edge. The resulting cluster state has a stabiliser group generated by "local generators" at each vertex (the product of X on that vertex and Z on all neighbours). Slice the cluster horizontally; each slice is a 2D cluster state that encodes a surface-code state with a particular distance. The vertical edges between slices implement the time evolution of the surface code — essentially, they are the "transversal gates" between adjacent code cycles. Errors in any cluster qubit, or failures of fusion (in the PsiQuantum variant), manifest as 1D strings in the 3D lattice; the string endpoints trigger stabiliser violations that are measured during the MBQC sweep; the decoder runs minimum-weight perfect matching to identify and correct the errors. The threshold is \sim 0.75% in the local-noise model, rising for erasure-dominated noise. PsiQuantum's variant trades lower fusion success probability for higher tolerance to erasure — a specific bet on what noise model photonic hardware will present.

Continuous-variable MBQC — the formal picture

In CV-MBQC, each "qubit" is replaced by a mode of light with position and momentum quadratures \hat{q}, \hat{p} satisfying [\hat{q}, \hat{p}] = i. The CV analogue of |+\rangle is an infinitely-squeezed state in \hat{p} — a delta function in momentum, infinitely spread in position. Real hardware achieves finite squeezing, typically 6-15 dB, which introduces a noise term. The CV analogue of CZ is a Gaussian two-mode gate e^{i\hat{q}_1 \hat{q}_2}. A CV cluster state is prepared by applying this gate across every edge of the lattice. Gaussian measurements (homodyne detection of \hat{q} or \hat{p}) on this cluster implement Gaussian unitary operations on the encoded state. The Bartlett-Sanders theorem (2002) shows that Gaussian operations on Gaussian states are efficiently classically simulable, so Gaussian-only CV-MBQC has no quantum speedup. Injecting a non-Gaussian resource — photon-number-resolving detection, or GKP states — breaks the Gaussian structure and restores universality. The GKP state is the one used in Xanadu's roadmap: a specific superposition of position eigenstates at comb-like regular intervals, which encodes a single qubit with natural protection against small displacement errors.

PsiQuantum detailed architecture

PsiQuantum's architecture is detailed in Bartolucci et al. (2021), Fusion-based quantum computation. The approach: on-chip silicon-photonic circuits generate heralded 3-photon or 4-photon entangled resource states (GHZ-like clusters) using spontaneous parametric down-conversion combined with multiplexed switching; these resource states are then fused together by linear-optical Bell-state measurements to build up a 3D Raussendorf lattice; the fusion measurements are probabilistic (success probability \sim 75% using standard linear optics, boostable toward 95% with ancilla photons); failed fusions leave "erasure errors" in the cluster, which the surface-code stabiliser measurements detect and correct. The PsiQuantum Omega chip (tape-out 2024 at GlobalFoundries Fab 10) integrates the heralded-photon sources, the waveguides, the beamsplitter networks, the phase shifters, and the superconducting-nanowire single-photon detectors on a single silicon-photonic wafer. A useful fault-tolerant computation requires thousands of Omega-class chips interconnected with phase-stable fibre links; the public target is early 2030s for a million-qubit fault-tolerant machine.

The India angle

MBQC research in India is primarily theoretical and small-experimental as of 2026. The quantum-optics group at IIT Madras runs a measurement-based photonic computing theory programme aligned with the NQM's photonic hub, with contributions to cluster-state decoder theory and fault-tolerant MBQC architectures. The Raman Research Institute, Bangalore has a long history of quantum-optics experiments including single-photon sources and photon-photon entanglement, making it a natural site for early cluster-state experiments in India. IISc Bangalore's continuous-variable quantum-optics group has worked on Gaussian CV cluster-state theory and on squeezed-light experiments. A small NQM-funded proof-of-concept cluster-state programme — scoping 10-20-qubit photonic cluster states using integrated silicon-photonic chips from the domestic SCL (Semiconductor Complex Laboratories, Chandigarh) — is under discussion for 2026-2028. The programme is complementary to PsiQuantum and Xanadu's commercial efforts rather than competitive: the scale and resources of those companies are not matched domestically, but the theory and small-scale experimental capability is being built within the NQM hub-and-spoke architecture.

Where this leads next

• Measurement-Based Photonics — chapter 169, the specialisation of this chapter to photonic hardware, with PsiQuantum and Xanadu covered in detail.
• Cluster States — the mathematical structure of cluster and graph states in more detail.
• Preparing Cluster States — the next chapter, covering the practical recipe for cluster-state preparation from |+\rangle states and CZ gates.
• Topological Qubits — an alternative architecture in which physical error suppression replaces the software layer of cluster-state fault tolerance.
• Toric and Surface Codes — the error-correcting code that 3D-cluster MBQC implements naturally.

References

1. Robert Raussendorf and Hans J. Briegel, A One-Way Quantum Computer (2001), Physical Review Letters — arXiv:quant-ph/0010033.
2. Robert Raussendorf, Jim Harrington, Kovid Goyal, Topological fault-tolerance in cluster state quantum computation (2007) — arXiv:quant-ph/0703143.
3. Nicolas C. Menicucci, Steven T. Flammia, Peter van Loock, Universal Quantum Computation with Continuous-Variable Cluster States (2006) — arXiv:quant-ph/0605198.
4. Wikipedia, One-way quantum computer.
5. John Preskill, Lecture Notes on Quantum Computation, Chapter 7 — theory.caltech.edu/~preskill/ph229.
6. Sara Bartolucci et al. (PsiQuantum), Fusion-based quantum computation (2021) — arXiv:2101.09310.