One-Way Quantum Computer

The measurement-based model is the native architecture of the platforms now scaling fastest. In photonics, deterministic two-qubit gates are notoriously hard, but generating entanglement and measuring photons quickly are natural — so leading efforts build large resource states and compute by measurement. PsiQuantum's fusion-based quantum computing is a direct descendant, fusing small "resource states" with Bell measurements into a fault-tolerant cluster, the whole error-corrected computation expressed as a measurement pattern. In the continuous-variable world, Gaussian cluster states from squeezed light have been demonstrated at extraordinary scale — clusters spanning thousands to over a million entangled modes, reported by groups in Tokyo and Copenhagen — where homodyne detection implements the Gaussian gates and a single non-Gaussian measurement supplies the magic. On the theory side, Raussendorf–Harrington–Goyal's 3D topological cluster state is the backbone of surface-code fault tolerance, and lattice surgery is often analyzed as a measurement pattern. The model also underwrites blind and verifiable computing: because the client only chooses angles, a server can run a computation it cannot read. The open frontier is compilation — turning an arbitrary circuit into the smallest, lowest-depth pattern with a valid gflow.

Picture a horizontal chain of qubits, each prepared in $|+\rangle$ and bonded to its neighbours by a controlled-$Z$. Measure the leftmost qubit in a basis tilted by $\alpha$ in the $X$–$Y$ plane. The qubit collapses, but the $CZ$ bond it shares with its right neighbour pushes its logical content one site to the right, rotated by $\alpha$. Repeat and the logical state walks rightward, picking up a programmable sequence of rotations. The chain is a quantum wire that also computes single-qubit gates — the first figure shows this elementary step.

Now stack two such chains and join them with a vertical $CZ$ bond. That bond is a pre-installed controlled-$Z$ between the two logical qubits — a two-qubit gate you never perform, because it was baked into the cluster at preparation. So a 2D lattice is a slab of pre-installed gates, and running an algorithm means carving the circuit out of it: $Z$-measure the qubits you do not want (deleting them from the graph) and $X$–$Y$-measure the ones you keep at the angles that spell out your rotations. It is sculpture, not construction — the figure is already inside the marble. Every measurement returns a random bit, but that randomness is a known entry in a Pauli frame, an $X^{s_x}Z^{s_z}$ stuck onto the true state; because Paulis commute through the Clifford parts in a trackable way, you carry the frame forward and cancel it downstream. The second figure is the map a compiler reasons about: which angles are free Clifford operations, and which one supplies the magic.

The cluster state is the raw material, defined by a graph. Put a qubit on every vertex in $|+\rangle$ and apply a controlled-$Z$ across every edge. Because all $CZ$ gates are diagonal they commute, so the order is irrelevant and the result is a unique stabilizer state.

where: $G=(V,E)$ — the graph, vertices $V$ are qubits and edges $E$ are bonds; $CZ_{ab}=\mathrm{diag}(1,1,1,-1)$ — controlled-$Z$ between qubits $a$ and $b$; $|+\rangle=\tfrac{1}{\sqrt2}(|0\rangle+|1\rangle)$ — the $+1$ eigenstate of $X$. A lattice-shaped $G$ gives the universal 2D cluster; the state holds the entanglement the whole computation will spend. That state is pinned down completely by its stabilizers — a commuting set of Pauli operators, one per vertex, each fixing the state with eigenvalue $+1$. Knowing the stabilizers is knowing the state, and is the compact language in which every measurement is bookkept.

where: $K_v$ — the stabilizer generator centred on vertex $v$; $w\sim v$ — every neighbour $w$ of $v$ in $G$; the $|V|$ generators $\{K_v\}$ mutually commute and uniquely fix $|\phi\rangle_C$. Each qubit carries an $X$ dressed by a $Z$ on every neighbour — the algebraic fingerprint of a $CZ$-bonded lattice. Computation happens by measuring in a basis in the $X$–$Y$ plane of the Bloch sphere, tilted by an angle $\alpha$. The two outcomes are equiprobable on a cluster qubit; which occurs is the source of the byproduct randomness.

where: $\alpha$ — the measurement angle; $\alpha=0$ measures $X$, $\alpha=\pi/2$ measures $Y$; $|+_\alpha\rangle$ ($s=0$) and $|-_\alpha\rangle$ ($s=1$) each occur with probability $\tfrac12$. The sign convention $e^{-i\alpha}$ is chosen so a positive angle realizes a positive $R_z(\alpha)$ below — bookkeeping, not physics. The gate one such measurement enacts on the wire is a $Z$-axis rotation, dressed by a fixed Hadamard from the wire geometry. Universality is built from this single primitive.

where: $\alpha$ — the measurement angle, up to the feed-forward sign; $H$ — the Hadamard, fixed by the wire. Chaining steps gives $\cdots HR_z(\alpha_2)HR_z(\alpha_1)$, and since $HR_z(\theta)H=R_x(\theta)$, a chain composes into a general Euler rotation. Every random outcome deposits a Pauli on the output wire. The full byproduct after a pattern is a product of $X$'s and $Z$'s whose exponents are mod-2 sums of outcomes, tracked on the fly by classical hardware.

where: $s_x,s_z$ — parities (mod 2) of the outcomes in the $X$- and $Z$-dependency sets of the output qubit; $U_\Sigma$ — the known Pauli byproduct multiplying the intended state. The logical answer is the intended one dressed by $U_\Sigma$; because $U_\Sigma$ is known, it is undone by relabelling the readout. The scheme is deterministic only because of one rule: before measuring a qubit, shift its angle to absorb the byproducts already on it. This is feed-forward, and it must run in real time.

where: $\alpha$ — the intended (default) angle; $\alpha'$ — the angle actually measured; $s_x$ — parity of prior outcomes leaving an $X$ byproduct (flips the sign); $s_z$ — parity leaving a $Z$ byproduct (shifts by $\pi$, swapping the outcome labels). An $X$ anticommutes past the rotation direction ($\alpha\to-\alpha$); a $Z$ commutes but relabels the outcomes ($\alpha\to\alpha+\pi$). Finally, measuring a cluster qubit in the computational ($Z$) basis is not a gate but graph surgery: it removes the vertex and its edges, up to $Z$ byproducts on the neighbours — how a computational region is cut from a generic lattice.

where: $G\setminus v$ — the graph with vertex $v$ and its incident edges deleted; $s$ — the $Z$-measurement outcome; the induced $Z^{s}$ acts on each former neighbour of $v$. This carves wires and gate locations out of the universal 2D cluster.

What a single $X$–$Y$-plane measurement does at special angles, together with the $Z$-basis limit that deletes a vertex, exposes the model's structure:

1 · Implementing a T gate on one wire qubit (fully worked)

Take a single wire step with input $|\psi\rangle=|+\rangle$ (so $a=b=\tfrac{1}{\sqrt2}$) and angle $\alpha=\pi/4$. Find the output for each outcome and show the logical gate is the same either way.

Step 1. Apply the bond. With $a=b=\tfrac{1}{\sqrt2}$, $CZ_{12}(|+\rangle_1|+\rangle_2)=\tfrac{1}{\sqrt2}(|0\rangle_1|+\rangle_2+|1\rangle_1|-\rangle_2)$ — a two-qubit cluster state on the edge $1\!-\!2$.

Step 2. Outcome $s=0$. Projecting with $\langle+_{\pi/4}|=\tfrac{1}{\sqrt2}(\langle0|+e^{i\pi/4}\langle1|)$ gives output $\tfrac12 HR_z(\pi/4)|+\rangle$ on qubit 2. Since $R_z(\pi/4)|+\rangle\propto T|+\rangle=\tfrac{1}{\sqrt2}(|0\rangle+e^{i\pi/4}|1\rangle)$, the normalized output is $\mathbf{HT|+\rangle}$.

Step 3. Outcome $s=1$. The same projection with $\langle-_{\pi/4}|$ gives $\mathbf{X\,HT|+\rangle}$ — identical logical gate $HT$, dressed by a known Pauli $X$.

Step 4. Correct. The tracker records the byproduct: $s_x$ increments when $s=1$. A later angle $\beta$ on this qubit is measured as $\beta'=(-1)^{s_x}\beta$, and at readout any residual $X$ is undone by flipping the final $Z$-measurement bit. Either outcome realizes the same non-Clifford gate $HT$; the $\pi/4$ angle is exactly what injects a $T$, and the coin-flip only sets a correctable $X$.

2 · Counting the cluster: a general rotation and a CNOT

How many measured qubits run (a) an arbitrary single-qubit unitary and (b) a CNOT, and where does the non-Clifford cost sit?

Step 1. Single-qubit unitary. Any $U\in SU(2)$ has an Euler decomposition $U=R_x(\gamma)R_z(\beta)R_x(\alpha)$ up to phase. Chaining wire steps gives $\cdots HR_z(\alpha_2)HR_z(\alpha_1)$, and since $HR_z(\theta)H=R_x(\theta)$, three consecutive $X$–$Y$ measurements compose into a general Euler rotation. So five qubits in a row — four measured, one output — implement any single-qubit gate (the classic RBB count: three rotation sites plus input and output).

Step 2. Two-qubit gate. A vertical $CZ$ bond is a controlled-$Z$; conjugating one wire by Hadamards turns it into a CNOT. On the original 2D square lattice the standard CNOT block uses a 15-qubit cluster — the number quoted by Raussendorf and Briegel — though in abstract graph-state language a CNOT needs only a few vertices.

Step 3. Locate the magic. Every angle above can be a multiple of $\pi/2$: the Clifford Euler rotations, Hadamards, and $CZ$ make a circuit of them Gottesman–Knill simulable however many qubits it spans. What matters is not the qubit count but the number of generic angles — each $T$ demands one measurement at $\alpha=\pi/4$. The lattice scales with circuit size; the hardness scales with the count of non-Clifford angles.

The one-way quantum computer is barely two decades old, yet it already sits among the deepest reorganizations of what "computing quantumly" means — trading the reversible clockwork of gates for the arrow of measurement.

Texts and papers. Raussendorf and Briegel, "A One-Way Quantum Computer", Physical Review Letters 86, 5188 (2001) · Raussendorf, Browne and Briegel, "Measurement-based quantum computation on cluster states", Physical Review A 68, 022312 (2003) · Briegel and Raussendorf, "Persistent entanglement in arrays of interacting particles", Physical Review Letters 86, 910 (2001) · Danos, Kashefi and Panangaden, "The Measurement Calculus", Journal of the ACM 54(2) (2007) · Nielsen and Chuang, Quantum Computation and Quantum Information, §10 · Preskill, Lecture Notes on Quantum Computation, on measurement-based models. The key numerical anchors are: the cluster stabilizers $K_v=X_v\prod_{w\sim v}Z_w$ with $CZ=\mathrm{diag}(1,1,1,-1)$; the core projection identity $\langle\pm_\alpha|CZ_{12}(|\psi\rangle|+\rangle)=\tfrac12 X^{s}HR_z(\alpha)|\psi\rangle$ using the basis convention $|\pm_\alpha\rangle=\tfrac{1}{\sqrt2}(|0\rangle\pm e^{-i\alpha}|1\rangle)$; the feed-forward rule $\alpha'=(-1)^{s_x}\alpha+s_z\pi$, derived by commuting Pauli byproducts through $HR_z$ and using $HX=ZH$; and the gate identities $R_z(\pi/2)=S$, $R_z(\pi)=Z$, $R_z(\pi/4)=T$. The $\sim1\%$ threshold for 3D topological cluster-state computing is the standard order-of-magnitude result of Raussendorf–Harrington–Goyal.

Prerequisites. Cluster States and Graph States · Measurement-Based Quantum Computation · Magic State Distillation. Leads to. The Measurement Calculus · Flow and Gflow Conditions · Topological Quantum Computation.

Ask the tutor: ask me to compile a specific gate — say a Hadamard or a $T$ — into an explicit cluster and measurement pattern, tracking every byproduct and feed-forward step.