Quantum Computing Paradigms: Measurement-Based Quantum Computing (MBQC)
Table of Contents
(For other quantum computing paradigms and architectures, see Taxonomy of Quantum Computing: Paradigms & Architectures)
What It Is
Measurement-Based Quantum Computing (MBQC), also known as the one-way quantum computer, is a paradigm where quantum computation is driven entirely by measurements on an entangled resource state. Instead of applying a sequence of unitary gates to a register of qubits, MBQC starts with a highly entangled state of many qubits (typically a cluster state) and then performs single-qubit measurements in a carefully chosen order and basis. The outcomes of these measurements determine the results of the computation, and crucially, they may dictate how later measurements are performed (a concept called feed-forward). Once a qubit is measured, it’s essentially removed (consumed) from the computer—hence “one-way” quantum computing, as the entangled resource is gradually used up.
The cluster state is the central resource in MBQC. A cluster state is a specific type of entangled state that can be described on a graph: each vertex is a qubit initialized to $|+\rangle = (|0\rangle+|1\rangle)/\sqrt{2}$, and each edge represents applying a controlled-phase gate (CZ) between the two connected qubits. For example, a simple cluster could be a 1D chain of qubits entangled by CZ gates between nearest neighbors, or a 2D lattice of qubits entangled in a grid. In notation, if $E$ is the set of edges, a cluster state on graph $G=(V,E)$ can be written as:
$∣Φcluster⟩=∏(i,j)∈ECZij ⨂k∈V∣+⟩k.|\Phi_{\text{cluster}}\rangle = \prod_{(i,j)\in E} CZ_{ij} \;\bigotimes_{k \in V} |+\rangle_k.∣Φcluster⟩=∏(i,j)∈ECZij⨂k∈V∣+⟩k$.
This state has the special property that it is highly entangled and serves as a universal substrate for quantum computation. It’s an eigenstate of certain commuting stabilizers (e.g., for a 2D cluster, each qubit’s $X \otimes Z$ neighbors is a stabilizer). One doesn’t need to fully grasp that formalism; the key point is that the cluster is a fixed entangled resource.
Computation in MBQC: Given a cluster state, quantum computation proceeds by single-qubit measurements:
- If you measure a qubit in the $Z$ basis (i.e., ${|0\rangle,|1\rangle}$), you essentially read out a result (which might be part of the output) and remove that qubit from the cluster without affecting the remaining ones (aside from collapsing that qubit).
- If you measure in the $X$-$Y$ plane (at some angle $\phi$), this has the effect of performing a certain logical gate on the remaining unmeasured qubits up to a known correction. Because of the entanglement, measuring one qubit can induce a gate (like a rotation) on the neighboring qubits. The exact effect depends on the measurement angle and the outcomes of previous measurements (this is where the feed-forward comes in).
Amazingly, any quantum circuit can be realized by an appropriate sequence of single-qubit measurements on a large enough cluster state. For example, to do a particular gate $U$ on the logical qubits, you would measure certain ancillary qubits in a pattern that implements $U$ on the remaining qubits’ state (this is akin to teleportation-based gates). By adjusting measurement bases based on earlier outcomes (which introduce random Pauli byproduct operations), one can ensure the correct overall transformation is realized. Raussendorf and Briegel showed in 2001 that a 2D square lattice cluster state is universal for quantum computing under such measurements. In their scheme, the measurements are the “program” – once the cluster is prepared, no further unitary gates are needed; we only perform a sequence of adaptive measurements.
Key Academic Papers
The foundational paper for MBQC is “One-Way Quantum Computing” by Raussendorf and Briegel (2001). They introduced the cluster state model and showed any quantum logic network can be simulated with one-qubit measurements on a cluster. Another important paper by Raussendorf, Browne, and Briegel (2003) further detailed how universal quantum computation is achieved with 2D cluster states. Michael Nielsen also wrote a lucid early description (2004) of MBQC and showed the equivalence with circuit models from a different angle. In Nielsen’s approach, measuring a cluster state was shown to effectively propagate quantum information in a way identical to gates.
In terms of implementation, Photonic experiments by Philip Walther and Anton Zeilinger’s group (2005) demonstrated a 4-qubit cluster state and performed simple algorithms (like a one-bit adder) via one-way computing. This was a proof-of-principle that MBQC works. Since then, photonic cluster states of increasing size have been demonstrated: 8-photon cluster states in 2011 (Pan’s group in China), and very recently, multiplexed continuous-variable cluster states with thousands of modes (Furusawa’s group in 2019) – the latter showed a deterministic generation of a very large entangled state of light.
The link between cluster states and error correction was made by Robert Raussendorf and Jim Harrington (2007), who showed a topological error-correcting code using a 3D cluster (the Raussendorf-Harrington code, a form of topological MBQC). This work connects MBQC with the notion of a fault-tolerant universal quantum computer realized as a giant cluster state with defects encoding logical qubits – an idea that underlies some of Google’s and others’ approaches to future fault-tolerance.
Comparison To Other Paradigms
MBQC is equivalent in power to the circuit model (it can simulate any circuit and vice versa), but it contrasts in how and when entanglement and operations occur:
- In circuit model, you entangle qubits as needed during the computation by applying two-qubit gates. In MBQC, you entangle all (or most) qubits upfront into a big cluster, and then computation is just measurement.
- MBQC shifts the “hard part” to state preparation. Creating a large, high-fidelity cluster state is resource-intensive. But once you have it, the actual computing is just local measurements, which (in some implementations like photonics) can be easier than performing deterministic gates.
- Feed-forward (adaptive measurement) is a feature not present in basic circuits (unless you explicitly allow mid-circuit classical control). MBQC naturally incorporates a classical side-computation: after measuring each qubit, based on the random outcome (0 or 1), you may need to change the basis of future measurements (e.g., flip an angle) to account for a Pauli $X$ or $Z$ error that occurs if the outcome was, say, 1 instead of 0. This is analogous to applying a correction gate in a circuit, but here we just adjust the next measurement. This classical control is an integral part of MBQC.
- MBQC can be more parallel in some respects. For instance, measurements on a large cluster can be done in layers, and some commuting measurements can be done simultaneously. Certain gates (Clifford gates) have particularly simple implementations that might allow massive parallelism – e.g. it’s known that a layer of certain Clifford operations in a circuit model can be done by measuring an entire layer of qubits at once in MBQC. Raussendorf et al. noted that circuits in the Clifford group can be done in a single measurement step on a cluster. Non-Clifford (especially the “T” or $\pi/8$ phase gates) require multiple steps and ancillas, but MBQC handles those with a bit more overhead (like magic state injection via measurements).
- From a theoretical standpoint, MBQC has ties to stabilizer formalism and error correction: cluster states can be seen as a resource state that is a stabilizer state, and one-way computing can be described in that language. This has made MBQC a convenient framework for certain error-correcting codes and fault-tolerance schemes (like topological cluster state computing in 3D).
Advantages
- Suitable for Photonic Implementation: One of the biggest motivations for MBQC is in linear optics (photonic) quantum computing. Photons don’t interact easily, making two-qubit gates probabilistic and challenging (as per the KLM scheme). However, creating entangled cluster states of photons (via probabilistic entangling gates or parametric down-conversion sources) and then measuring them is a viable route. Photons can be generated in entangled webs (for example, through time-bin entanglement or by entangling photon pairs and fusing clusters together), and once you have a large photonic cluster, you just measure each photon’s polarization or phase at the required angle to perform the computation. This avoids trying to do deterministic photon-photon gates during the computation; all the interference and entanglement is upfront. Companies like PsiQuantum and Xanadu, and research groups worldwide, are pursuing photonic quantum computers that heavily rely on MBQC with cluster states of light. In these systems, measurement is technically easier than maintaining long-lived quantum memories, which MBQC leverages by consuming qubits quickly.
- Temporal and Distributed Flexibility: Because measurement-based computing separates the entanglement resource from processing, one can imagine modular or distributed quantum computing scenarios. For instance, different cluster state portions could be prepared in parallel (or even in different locations) and then connected (via Bell measurements or fusion operations) into a larger cluster. Also, one can produce cluster states on-the-fly: e.g. a time-multiplexed cluster state where entangled photons are generated sequentially and coupled by delay lines. This was demonstrated in continuous-variable clusters where arbitrary size cluster states can be built in time domain. This extensibility means MBQC can be scalable in a pipelined fashion — you don’t need all qubits present from the start, you can keep adding and measuring.
- High Parallelism: In MBQC, many measurements can be done at once if they commute or act on different parts of the cluster. The depth of the measurement “circuit” can sometimes be less than the depth of the equivalent unitary circuit, because entanglement is already present globally. A noteworthy result from Raussendorf’s work was that some quantum circuits have a natural translation to a shallow sequence of measurements. This parallelism could potentially help speed up execution in wall-clock time (though feed-forward can force some sequentiality, since you might need a result before deciding the next basis).
- Resilience via Adaptive Correction: The need for feed-forward means MBQC inherently has a mechanism to correct certain errors (specifically, the random byproduct Pauli errors from measurements). This is not error correction in the full sense, but it shows that the model is comfortable with nondeterminism and adapts to it. In fault-tolerant schemes, one can incorporate error correction steps as part of the measurement sequence. Indeed, some of the leading quantum error correction implementations (like the surface code) can be formulated in the MBQC picture: a 3D cluster state with appropriate measurements can realize error-corrected logical gates topologically. Microsoft’s topological cluster approach (for a gate-based topological QC) is conceptually similar to doing MBQC on a 3D cluster state.
Disadvantages
- Resource State Preparation: The upfront cost of generating a large, high-quality cluster state is enormous. If your algorithm needs $n$ logical qubits and a circuit depth $d$, you might need of order $n \times d$ qubits entangled in a cluster (because roughly one qubit is consumed per time-step per logical qubit). For a realistic quantum computation, this could mean thousands or millions of qubits entangled together. Creating such a state with low error is challenging. In physical terms, if using matter qubits (trapped ions, atoms, superconductors, etc.), entangling a huge lattice of them is limited by control and connectivity. If using photons, you face probabilistic entanglement and photon loss. The larger the cluster, the more points of failure. Many experiments currently create small cluster states (e.g. 4 to 10 photons entangled). Scaling that to even 50 or 100 photons with high success probability is an active area of research.
- Feed-forward Latency: MBQC requires a classical processing loop in the middle of the quantum experiment – you measure a qubit, get a classical bit result, then adjust the basis of the next measurement based on that result. If the physical system is such that all qubits exist simultaneously (like an array of trapped atoms), you need classical electronics to keep up with the quantum device’s coherence time. For photons, since they travel at the speed of light, one often uses delay lines or fiber loops to slow them down enough that the measurement results can catch up to control the next ones. This adds complexity. In solid-state systems, the speed of classical feed-forward might limit how fast measurements can be done in sequence. Too slow feed-forward could lead to qubits decohering while waiting for the classical signal.
- Consumption of Qubits: Once a qubit is measured, it cannot be used again. This means MBQC tends to use more qubits overall than a gate-based computation for the same algorithm. It’s a one-time usage model, whereas in a circuit model one tries to reuse qubits throughout many gate operations. In MBQC, if you want to apply 100 one-qubit rotations on a logical qubit, you likely need 100 qubits in the cluster lined up, each measured sequentially to enact those rotations. This can be mitigated by clever constructions (you can teleport a state around the cluster rather than have a one-to-one mapping of operations to qubits), but generally the qubit overhead is high.
- Complexity of Design: Mapping an arbitrary algorithm to a sequence of measurements requires some effort. While we know MBQC is universal, designing the measurement pattern (angles and order) for a given circuit is typically done via a mapping: first design a circuit, then translate each gate or block of the circuit into a piece of cluster and measurement pattern. This is systematic but adds an extra compilation layer. Debugging or designing directly in MBQC terms (without referencing circuits) can be unintuitive for those used to thinking in circuits.
- Sensitivity to loss: Particularly in photonic implementations, if a photon is lost (absorbed or not detected) before being measured as part of the cluster, it’s like a qubit that vanished from your cluster. Loss in MBQC can be catastrophic unless the cluster is built with redundancy or some fault-tolerance. Some cluster state proposals incorporate fusion gates that can tolerate a certain loss rate (trading success probability). But generally, MBQC demands high efficiency in state distribution and detection. In other hardware (like ions), “loss” might correspond to qubit dropping out due to decoherence, which similarly needs handling via error correction if it happens.
Cybersecurity Implications
MBQC itself doesn’t change the quantum threat model – it’s another way to achieve a universal quantum computer. Any computation done via circuit model (breaking cryptography, running Shor’s algorithm, etc.) can equally be done on a measurement-based quantum computer given a large enough cluster state. So if photonic MBQC machines scale quickly, they could become the platform that breaks RSA and so forth. For the security community, the rise of MBQC-based efforts (like PsiQuantum’s ambitious goal of a million-qubit photonic cluster-state quantum computer by the late 2020s) is a signal that scalable quantum computing might come from a different technological direction than superconductors or ions. Photonic MBQC machines might have certain advantages in scaling (e.g. no need for extreme cryogenics for the qubits themselves, though detectors often need to be cooled; ability to leverage optical telecommunications technology). If successful, they could potentially accelerate the timeline to a cryptographically relevant quantum computer.
On the other hand, MBQC has interesting angles for quantum communication and cryptography: Since it is so measurement-centric, it dovetails with quantum networks and blind quantum computing protocols. For example, there are protocols for blind (secure) quantum computing where a client prepares single qubits, sends them to a server that creates a cluster state and measures it, and due to the nature of measurements the server cannot tell what computation it performed (this relies on the randomness of certain measurements). MBQC is naturally suited for such protocols where a user encodes their problem into certain measurement angles and the server does a generic cluster-state measurement routine. This could allow cloud quantum computing with privacy. Also, cluster states are useful in quantum network security – e.g. entangled states like cluster states can be used in quantum network protocols, and MBQC could be performed distributedly, which ties into quantum internet ideas.
In summary, MBQC’s main security implication is simply that it’s an alternate path to building a universal quantum computer — one which topologically and resource-wise might scale differently. A cluster-state photonic computer achieving, say, factoring of 2048-bit RSA would mark the same paradigm shift as a superconducting one doing it. Therefore, security professionals should track MBQC efforts as closely as circuit-based efforts. On the positive side, MBQC contributes to quantum cryptographic protocols and might enable more flexible quantum-secure cloud computing.
Who’s Pursuing
PsiQuantum (a Silicon Valley startup) is perhaps the most vocal industry player focusing on MBQC. They are building a photonic quantum computer and plan to utilize massive cluster states of photonic qubits with single-photon detectors to carry out one-way computation. PsiQuantum has partnered with GlobalFoundries to manufacture photonic chips and is targeting a million-qubit machine using MBQC and error correction. Xanadu (Canada) is another photonics company; while their early work has focused on continuous-variable quantum computing and Gaussian boson sampling, Xanadu’s roadmap also includes photonic universal QC, likely involving cluster states and measurement-based logic. In academia, University of Bristol’s Quantum Engineering group and University of Oxford have strong photonic MBQC research, as does University of Vienna (Pan’s former group, now Zeilinger’s successors) and USTC in China (Jian-Wei Pan’s team) – USTC’s team has demonstrated some of the largest entangled photon states.
Beyond photonics, measurement-based ideas are relevant in trapped ions and superconducting circuits too. For example, researchers have created small cluster states of ions in a trap and executed one-way logic on them; however, the circuit model is currently more natural for those platforms. Still, ion trap companies like IonQ or Quantinuum could in principle use MBQC for certain tasks or verification.
Distributed quantum computing initiatives (like the UK Quantum Communications Hub, or the EU’s quantum network projects) consider MBQC for linking remote processors, since entangled states across a network can be utilized via measurements to perform joint computations securely.
In summary, MBQC is a flourishing paradigm, especially where photonic or networked implementations are concerned. It stands as a strong contender for achieving large-scale quantum computing and is supported by a global cohort of researchers and companies aiming to harness cluster states for both computation and communication.
Quantum Computing Paradigms Within This Category
Photonic Cluster-State Computing
Photonic Cluster-State Computing is a specialized approach to quantum computing that leverages measurement-based quantum computing (MBQC) using photonic qubits. Instead of executing quantum logic gates sequentially as in traditional circuit-based quantum computing, this model begins by creating a highly entangled cluster state of photons, which serves as a computational resource. Computation is then performed by adaptive single-qubit measurements, where each measurement steers the remaining entangled photons in a way that implements quantum operations.
Ion Trap/Neutral Atom Implementations of MBQC
Trapped ions and neutral atoms have emerged as highly versatile platforms for measurement-based quantum computing (MBQC), a method where entangled resource states are prepared first and then consumed through a sequence of adaptive measurements to perform logical operations.
