In short
A cluster state is a giant entangled resource — a 2D (or 3D) lattice of qubits in which every edge carries a controlled-Z bond. Measurement-based quantum computing consumes it one qubit at a time. Before any measurement can happen, you have to actually build the cluster. There are two routes. The direct route — available on superconducting, trapped-ion, and neutral-atom platforms — starts every qubit in |+\rangle and applies a deterministic CZ along every lattice edge; a few gate layers and the cluster is done. The photonic route has a problem: two photons passing through empty space do not interact, so a deterministic CZ between photonic qubits does not exist. The workaround is fusion (Browne and Rudolph, 2005): generate small entangled fragments — Bell pairs, three-photon GHZ states — and then probabilistically merge them into a bigger cluster using linear-optics measurements, retrying failures until the cluster has been stitched together. Type-I fusion succeeds around 50% of the time; Type-II fusion succeeds around 75% of the time with extra ancillas. PsiQuantum's billion-dollar architecture is built on a fusion network that generates small photonic resource states on-chip and fuses them into a fault-tolerant 3D cluster at gigahertz rates. As of 2024, direct preparation has produced ~30–50-qubit cluster-like entangled states on superconducting chips and 20+-qubit clusters in ion traps; photonic fusion experiments have produced small clusters of tens of photons and are scaling toward the millions required for fault tolerance. The three killers are photon loss (every lost photon breaks a cluster edge), imperfect gates (errors multiply with lattice size), and detector efficiency (below ~90% the whole architecture fails).
A cluster state is a beautiful thing to look at on paper — a grid of dots, a line on every edge, a state that, measured correctly, can simulate any quantum algorithm you like. On paper, it costs nothing. The previous chapter showed you what the measurements do once the cluster exists: they teleport quantum information through the lattice and leave the answer sitting on the boundary.
But on paper is not in hardware. A cluster state on a thousand physical qubits is an entangled pure state in a 2^{1000}-dimensional Hilbert space. No matter how easy it is to describe, producing it requires a real physical operation on each edge of the lattice. Every CZ has to actually happen. Every qubit has to actually begin life in |+\rangle. And the system has to hold that enormous superposition together long enough for you to measure through it.
This chapter is the hardware story. How do you build a cluster state? The answer depends sharply on what kind of qubit you are working with — and the difference between "matter qubits" and "photons" is where the whole architecture of modern photonic quantum computing comes from.
The direct recipe — start in |+⟩, apply CZ on every edge
If your qubits are sitting still (ions in a Paul trap, superconducting islands on a chip, neutral atoms in an optical tweezer array) and you already have a working CZ gate between any nearest-neighbour pair, building a cluster state is almost embarrassingly easy. The recipe has two steps.
Step 1. Initialise every qubit in |+\rangle. The state |+\rangle = (|0\rangle + |1\rangle)/\sqrt{2} is the equal superposition — a single Hadamard on |0\rangle produces it. On every hardware platform, this is a routine operation that takes a few microseconds (for ions) down to a few tens of nanoseconds (for superconducting qubits).
Step 2. Apply a CZ gate between every pair of qubits that share an edge in your target lattice. On a 2D square lattice of size N \times N, there are roughly 2N(N-1) edges — about 2N^2 gates. Because disjoint CZs commute, many of them can be done in parallel: group the edges by direction and by even/odd offset, and you end up needing only four parallel layers of CZ to cover the whole 2D lattice (horizontal-even, horizontal-odd, vertical-even, vertical-odd).
Why only four layers: on a 2D grid, any edge is either horizontal or vertical. Within the horizontal edges, alternating columns of edges share no qubits with each other, so the even-indexed horizontal edges can all fire at once in one layer, and the odd-indexed ones fire in a second layer. Same argument for vertical edges. Four layers total — the depth is constant in the lattice size. This is why the direct route works beautifully on platforms that support parallel gates.
That is it. Two steps, and you are holding a cluster state. In pseudo-code:
for each qubit q in lattice:
initialise q in |+⟩
for each edge (i, j) in lattice:
apply CZ(i, j)
The state produced is exactly
where E is the edge set of your lattice.
Where this works — and where it does not
The direct route is the standard technique on every matter-based quantum platform. IBM's superconducting chips and Google's Sycamore family both support fast parallel CZ layers, and cluster-like multi-qubit entangled states of 30–50 qubits have been prepared this way (often as GHZ states, which are cluster states on a tree graph). Trapped-ion platforms (Quantinuum's H2, AQT, IonQ) can apply CZ between any pair of ions in the trap through shared motional modes; ion cluster states of 20+ qubits have been demonstrated (Lanyon, Monroe, Friis et al., 2017–2024). Neutral-atom arrays (QuEra's Aquila, Pasqal) apply CZ via Rydberg-blockade interaction, and the 2D geometry of the atom array naturally matches the lattice structure of the target cluster.
The limits are set by gate error accumulation. If every CZ has a fidelity of 99.5\%, then a cluster with 200 edges has a total fidelity of 0.995^{200} \approx 0.37 — barely above a third. Scaling up quickly runs into the same wall every NISQ platform hits: you cannot build a useful fault-tolerant cluster without a lower error rate than anyone currently achieves.
Where the direct route simply does not work is with photons.
Why photons cannot do the direct recipe
A photonic qubit is a qubit whose logical states are encoded in the presence, absence, polarisation, time-bin, or path of a single photon of light. You can read the full story in photonic qubits. Photons have one extraordinary virtue: they do not interact with anything. No magnetic field, no electric field, no other photon. A photon travelling through empty space — or through a low-loss optical fibre — preserves its quantum state almost indefinitely.
This is, at first glance, the perfect qubit. Perfect coherence, perfect portability. But it comes with an equally extraordinary problem: since photons do not interact, you cannot directly apply a two-photon gate. A CZ between two photons requires their amplitudes to pick up a relative phase depending on whether both are "present" — which requires them to notice each other, which requires a nonlinear optical medium strong enough to respond to single photons. Such media exist only as exotic laboratory demonstrations; no one has built a scalable, low-error, deterministic photon-photon CZ.
So the direct recipe — "apply a CZ on every edge" — is dead on arrival for photonics. You cannot fire a CZ along every lattice edge because you do not have a CZ to fire.
If photonic quantum computing is to work, the cluster state must be built a different way.
Browne-Rudolph fusion — the photonic trick
In 2005, Daniel Browne and Terry Rudolph published a paper in Physical Review Letters that changed the entire photonic quantum-computing landscape. Their central idea: you do not need a deterministic CZ to build a cluster state. You need a probabilistic operation that, when it succeeds, fuses two small entangled fragments into a larger one. A failure just removes an edge; you can detect failures, retry, and stitch together a cluster gradually.
Here is the core picture. Suppose you already have a small supply of Bell pairs — photon pairs in the state |\Phi^+\rangle = (|00\rangle + |11\rangle)/\sqrt{2}. Bell pairs are cheap in photonics: spontaneous parametric down-conversion (SPDC) in a nonlinear crystal produces them at megahertz rates. You can also, with a little more work, generate small three-photon GHZ states |GHZ_3\rangle = (|000\rangle + |111\rangle)/\sqrt{2} at lower but usable rates.
These small fragments are your raw material. Fusion is the tool that turns them into a cluster.
Type-I fusion — the simplest version
A Type-I fusion is a specific linear-optics gadget. Take one photon from each of two separate entangled states, send them both onto a polarising beamsplitter (which transmits horizontal polarisation and reflects vertical), and place a single-photon detector on each output port of the beamsplitter.
- Success (probability 1/2): exactly one detector clicks. The two photons had the same polarisation and bunched into the same output. The measurement projects the two original fragments into a merged entangled state — they have been "fused" at the qubit where the measured photon came from.
- Failure (probability 1/2): both detectors click, or neither does. The two photons had opposite polarisations, the measurement projected onto a state that destroys the entanglement structure, and the fragments come apart.
Why exactly one-half: a polarising beamsplitter in the "bunching" basis produces a two-photon interference pattern identical to Hong-Ou-Mandel. For two photons from two Bell pairs with unknown correlated polarisations, the two relevant outcomes (both transmitted vs both reflected) cancel, and the probability splits fifty-fifty between success and failure. This is linear optics; no nonlinear material is doing anything clever.
When a Type-I fusion succeeds, it effectively applies a fused CZ between the remaining photons of the two fragments, minus one photon (which was consumed in the measurement). If you had two Bell pairs (A_1, A_2) and (B_1, B_2) and you fused A_2 with B_1, you are left with a three-photon linear cluster (A_1, \text{fused}, B_2).
Type-II fusion — better odds
A Type-II fusion is a more sophisticated version that uses a different linear-optics gadget — including a half-waveplate before the polarising beamsplitter — and succeeds with probability 1/2 on a single attempt, but can be boosted toward probability 3/4 by adding ancilla photons (Grice, 2011). Current PsiQuantum-style architectures assume a boosted Type-II fusion with success probability around 75\% in the absence of photon loss.
The crucial property is the same in both cases: failure is heralded. The pattern of detector clicks tells you, for every attempted fusion, whether it succeeded or failed. Failures are not silent corruption; they are known absences. That means you can plan around them — either by retrying locally, or (more cleverly) by designing a cluster whose error-correcting code tolerates missing edges up to a threshold.
Building up incrementally
Given this fusion primitive, the recipe for a big cluster state is:
- Generate fragments. Run many Bell-pair sources or three-photon-GHZ sources in parallel. Each produces a small entangled fragment.
- Plan a fusion schedule. Decide which pairs of fragments to fuse and in what order to get the target cluster graph.
- Attempt fusions. For each scheduled fusion, send the relevant photons into a fusion gadget. Record success or failure.
- Repair failures. If a fusion fails, either (a) retry with fresh fragments, or (b) route around it — the error-correction code on top of the cluster is designed to tolerate missing edges.
- Stop when the cluster is complete enough for your computation to begin.
On a silicon-photonics chip running thousands of fusion gadgets in parallel at gigahertz rates, this whole pipeline becomes a streaming assembly line: fresh fragments pour in one side, finished cluster-state output goes out the other, in real time. This is the architecture PsiQuantum has built its company around.
Example 1: direct preparation of a 3-qubit linear cluster
Build the smallest non-trivial cluster state — a three-qubit linear chain — using the direct recipe on any hardware that has a deterministic CZ.
Step 1. Initialise. Three qubits, each in |+\rangle:
Why: each |+\rangle is an equal superposition over |0\rangle and |1\rangle; the tensor product is an equal superposition over all 2^3 = 8 basis states. The coefficient is (\tfrac{1}{\sqrt{2}})^3 = \tfrac{1}{2\sqrt{2}}. The state is still a product state — no entanglement.
Step 2. Apply CZ_{12}. The CZ gate multiplies the coefficient of |11\rangle by -1 and leaves all other basis states alone. Acting on qubits 1 and 2 across the full state:
Why the minus sign is only on |11\rangle: CZ acts as the identity on the three basis states |00\rangle, |01\rangle, |10\rangle and multiplies |11\rangle by -1. The state is now entangled between qubits 1 and 2 (it cannot be factored as a product), and qubit 3 is still a free |+\rangle tensored on.
Step 3. Apply CZ_{23}. Same action, now across qubits 2 and 3:
Why the sign is (-1)^{xy + yz}: each CZ contributes a factor of (-1) whenever the two bits it acts on are both 1. After both CZs, the total sign picks up a factor from the (1,2) pair whenever xy = 1, and a factor from the (2,3) pair whenever yz = 1. The exponents add in the exponent of -1, which is the same as a single (-1)^{xy + yz} factor. This is the graph-state sign rule: the sign of each basis state is (-1) to the power of the number of edges in the graph whose endpoints are both labelled 1.
Step 4. Write out all eight amplitudes and verify.
| basis state | xy + yz | sign |
|---|---|---|
| $ | 000\rangle$ | 0+0=0 |
| $ | 001\rangle$ | 0+0=0 |
| $ | 010\rangle$ | 0+0=0 |
| $ | 011\rangle$ | 0+1=1 |
| $ | 100\rangle$ | 0+0=0 |
| $ | 101\rangle$ | 0+0=0 |
| $ | 110\rangle$ | 1+0=1 |
| $ | 111\rangle$ | 1+1=0 |
Why |111\rangle ends up with a + sign even though both edges contribute: xy + yz = 1 + 1 = 2, and (-1)^2 = +1. The two minus signs from the two edges cancel. This is a feature of CZ, not a bug — it is the mathematical expression of the graph structure.
Result. The three-qubit linear cluster state is
Why this is useful: this is the minimal resource for performing a single-qubit rotation via MBQC. Measuring qubit 1 in an angle-\alpha basis and qubit 2 in an angle-\beta basis implements a two-parameter unitary on qubit 3, up to Pauli corrections. Every photonic MBQC experiment in the 2000s built and used exactly this three-photon cluster as a proof of principle.
What this shows. The direct recipe is simple and deterministic on any platform with a real CZ. You initialise in |+\rangle^{\otimes n}, fire CZs along edges, and the graph-state sign structure falls out automatically. For three qubits you needed two gates; for a 10 \times 10 lattice you would need about 180 gates in four parallel layers. The gate count grows linearly with the number of edges; the depth does not grow at all.
Example 2: Type-I fusion of two Bell pairs
Take two Bell pairs and fuse them into a three-photon linear cluster using a probabilistic Type-I fusion. Calculate the success probability and the output state on success.
Step 1. Write down the two Bell pairs.
The joint state is
Why this particular form: each Bell pair independently gives a sum over its two correlated outcomes. The tensor product is a sum over all four combinations, each with amplitude \tfrac{1}{\sqrt{2}} \cdot \tfrac{1}{\sqrt{2}} = \tfrac{1}{2}.
Step 2. Model the fusion. A Type-I fusion on photons A_2 and B_1 performs a measurement in the Bell basis that projects the two measured photons onto the symmetric outcome |00\rangle_{A_2 B_1} + |11\rangle_{A_2 B_1} if it succeeds, and onto the anti-symmetric outcome if it fails.
The probability of the symmetric outcome is
which requires reading off the amplitudes where A_2 = B_1. Why: the Type-I fusion herald is "both photons came out of the beamsplitter in the same mode and one detector clicked." Quantum-mechanically, this projects the measured two-qubit subsystem onto the subspace spanned by |00\rangle + |11\rangle. The probability is the total weight of the state in that subspace.
Step 3. Compute. In |\Psi\rangle the four basis terms have A_2 B_1 equal to 00, 01, 10, 11, each with amplitude \tfrac{1}{2}. Only the first and last have A_2 = B_1. So the projection onto the symmetric subspace has amplitude
with a total probability before normalisation of |\tfrac{1}{2}|^2 + |\tfrac{1}{2}|^2 = \tfrac{1}{2}. So P(\text{succ}) = 1/2 — the famous 50% success rate.
Step 4. Read off the output state on success. After projection onto the symmetric subspace and normalisation, the three-photon state on A_1, \text{fused}, B_2 (where "fused" is the surviving degree of freedom of the A_2 B_1 measurement) is
This is a three-photon GHZ state — which is locally equivalent to a three-qubit linear cluster by a single Hadamard on the middle qubit. Why GHZ not immediately linear-cluster: Type-I fusion in its most basic form produces a GHZ-type merger. Applying a Hadamard on the fused qubit converts it into the linear-cluster form |C_3\rangle. In practice, this single Hadamard is folded into the next measurement basis choice, so the output does not need a separate gate.
Result. With probability 1/2 per attempt, Type-I fusion merges two Bell pairs into a three-photon GHZ (locally equivalent to a three-photon linear cluster). With probability 1/2, it fails and the entanglement is destroyed. To get a 99% success rate, you need on average \log_2(1/0.01) \approx 7 independent Bell-pair sources feeding a retry loop per fusion — a significant overhead, but manageable at fab scale.
What this shows. Fusion turns the absence of a deterministic CZ into a tractable engineering problem. You accept probabilistic failure, you herald it, and you plan around it. The overhead is real (an extra factor of 2–4 in resource consumption), but the architecture remains buildable at scale — which is exactly what PsiQuantum is betting its company on.
PsiQuantum — a fab-scale fusion network
PsiQuantum, founded in 2016 by O'Brien, Rudolph, and others, has taken the Browne-Rudolph fusion idea and scaled it into a silicon-photonics fabrication architecture. Their 2023 Nature paper and 2024 roadmap describe a machine whose steady-state operation is a fusion network — thousands of photon sources producing small resource states (three-photon GHZs, four-photon "star" clusters) at gigahertz rates, with fusion gadgets interleaved between them, weaving the cluster state in real time.
The key numbers their architecture depends on are tight:
- Single-photon detector efficiency > 90\%. A missed detection is a photon loss, which breaks a cluster edge.
- On-chip single-photon source efficiency > 30\%. Higher is better; lower means too many failed fusions.
- Waveguide loss < 0.1 dB/cm. Even small losses compound across a large chip.
- Boosted Type-II fusion success rate \approx 75\%. The 75% is with ancilla boosting; 50% bare fusion is not enough for efficient scaling.
- Target total cluster size: 10^6 to 10^7 physical photonic qubits for a fault-tolerant logical machine.
PsiQuantum's fusion network is meant to run continuously. The cluster is not a fixed object sitting in memory (photons do not sit — they travel at c), but a flowing river of entanglement through the chip. Fresh photons enter, measurements happen, classical outcomes go to a real-time control system, and logical-qubit information propagates through the evolving cluster. The fault-tolerant architecture uses the 3D Raussendorf lattice, which — as shown by Raussendorf, Harrington, and Goyal in 2007 — is equivalent to a surface code with a topological threshold around 0.75\% for errors and up to 12\% for photon loss when the code is designed for loss tolerance from the start.
Experimental sizes as of 2024
It is worth being honest about where the experimental state actually is.
| platform | cluster-like size (qubits) | year | notes |
|---|---|---|---|
| Superconducting (IBM, Google) | 30–60 (GHZ/tree) | 2023–2024 | Direct CZ on chip; fidelity drops past ~30 qubits |
| Trapped ions (Quantinuum, IonQ) | 20–30 | 2023 | Direct CZ via motional modes; very high fidelity per gate |
| Neutral atoms (QuEra, Pasqal) | 40–60 | 2024 | Rydberg-blockade CZ; rapidly growing |
| Photonic, on-chip (Xanadu, PsiQuantum-affiliated) | ~10–20 | 2023 | Fusion-based; loss-limited |
| Photonic, bulk optics (academic) | 4–12 | 2000–2020 | Historical; first MBQC demonstrations |
The gap between these and the millions required for useful fault tolerance is the entire research program of photonic quantum computing. Progress has been steady — the numbers double roughly every three years — but the absolute distance remaining is still three-to-four orders of magnitude.
The three killers
Every cluster-state preparation architecture has the same three enemies.
Photon loss. Every photon that disappears — due to absorption in a waveguide, coupling inefficiency at a detector, or just imperfect transmission through a component — breaks a cluster edge. A 2D cluster with lots of missing edges is useless. The loss budget for a fault-tolerant photonic machine is around 1–3% per photon across the entire round-trip, which is tight for any realistic chip.
Gate imperfection. On matter platforms, every CZ has a small infidelity; the errors compound multiplicatively across edges. A 1% infidelity per gate on a cluster with 200 edges gives a total fidelity of 0.99^{200} \approx 0.13 — below the threshold for error correction to be useful. On photonic platforms, the equivalent is the fusion gadget's imperfection — phase errors at the beamsplitter, imperfect mode-matching — which is smaller but still nonzero.
Scale-up. Even if every component works to spec, building a machine that runs a million photons' worth of cluster in real time requires integrating tens of thousands of detectors, sources, and control lines on a single coherent system. The engineering is as much about the classical control as the quantum optics — which is why PsiQuantum partners with semiconductor fabs (GlobalFoundries) rather than optics shops.
Indian context
Photonic quantum computing research in India is concentrated at the Raman Research Institute, Bangalore (quantum optics, single-photon sources, satellite-QKD collaborations via ISRO), IIT Madras (integrated photonic chip design and fabrication through their Centre for Quantum Information, Communication and Computing), IISc Bangalore (silicon photonics for classical and quantum applications), and TIFR Mumbai (experimental photonic entanglement). Under the National Quantum Mission, India has budgeted ~₹6,000 crore over 8 years, with photonics as one of four pillars. A domestic fusion-based architecture effort is being scoped for 2026–2028 in partnership with Semi-Conductor Laboratory (SCL, Chandigarh) and private silicon-photonics foundries. The ambition is not yet PsiQuantum scale, but the research ecosystem is real and growing.
Common confusions
- "A cluster state is the same as a Bell state, just bigger." It is not. A Bell state is a two-qubit maximally entangled state with one of four possible structures. A cluster state is an N-qubit entangled state whose structure is determined by the graph of edges — the two-qubit Bell pair is the simplest cluster state, but an N-qubit cluster has far more structure (most importantly, the entanglement graph is what determines which MBQC operations are possible).
- "Fusion is a gate." It is a measurement. The fusion gadget measures two photons — consuming them — and conditional on the outcome, the remaining photons are left in an entangled state. No unitary gate is applied during fusion. This is why it is called "measurement-based" quantum computing: everything that looks like a gate is actually a measurement with classical outcome tracking.
- "Photon loss is just like gate error." They look similar but behave differently in the error-correction analysis. A lost photon is an erasure — you know which qubit is missing. A faulty gate is an unknown error — you do not know which qubit was affected. Surface codes tolerate erasure at a much higher rate (\sim 50\%) than unknown errors (\sim 1\%), which is why the photonic architecture is deliberately designed to convert as many errors as possible into heralded losses.
- "Fusion only works on Bell pairs." The Browne-Rudolph construction generalises: you can fuse any two graph states along a shared qubit measurement, and the output is a graph state whose edges are the union of the inputs' edges (minus the consumed qubit and an adjustment for the measurement basis). PsiQuantum uses three-photon GHZ resource states precisely because they give a higher cluster density per fusion than raw Bell pairs.
- "You need a complete cluster before computation can start." No. Modern architectures compute "on the fly": as soon as the leftmost column of the cluster is ready, measurements can begin there, and the classical outcomes steer the preparation of the rightmost columns that have not yet been fused. This just-in-time cluster assembly is the whole point of a streaming fusion network.
Going deeper
If you understand that a cluster state is built by initialising every qubit in |+\rangle and firing CZ gates along edges, that this direct recipe works on matter platforms but not on photonics, that photonic cluster states must instead be built by probabilistic fusion of small entangled fragments (Browne-Rudolph 2005), that PsiQuantum's architecture is a streaming fusion network of resource-state generators feeding fusion gadgets, and that the whole game is limited by photon loss, gate fidelity, and detector efficiency — you have chapter 177. What follows is the formal statement of Browne-Rudolph fusion, the PsiQuantum resource-state choices, percolation thresholds, loss-tolerant cluster states, and the Xanadu continuous-variable analogue.
Formal Browne-Rudolph fusion
Let |G_A\rangle and |G_B\rangle be two graph states on vertex sets V_A and V_B. Pick a qubit a \in V_A and a qubit b \in V_B. A Type-I fusion measures the two qubits in a Bell-like basis; on success (heralded by a specific click pattern), the output is a graph state on (V_A \cup V_B) \setminus \{a\} (or equivalently \setminus \{b\}, up to a symmetry), with edge set equal to the union of the two input edge sets but with b inheriting all the edges of a (or vice versa). Algebraically, success projects the joint state onto a Bell-pair stabiliser generator X_a X_b and Z_a Z_b. Failure projects onto the orthogonal complement, and the fused qubit is lost.
Type-II fusion uses a half-waveplate followed by a polarising beamsplitter and measures both photons in a basis that projects onto X_a X_b (without projecting onto Z_a Z_b), with a single click-pattern heralding one of two possible successes and the two-click pattern heralding failure. The success probability is 1/2 without boosting and 3/4 with one ancilla photon boost (Grice 2011). The output on success is a graph state with the same rewiring rule but one fewer photon consumed (both photons are destroyed in Type-II, vs one destroyed in Type-I).
PsiQuantum resource states
PsiQuantum's architecture uses four-photon GHZ-like resource states as the building block, rather than Bell pairs. A four-photon GHZ-3 (one central "core" photon entangled with three "leaf" photons) is generated on-chip at ~gigahertz rates per module. Fusions between leaf photons of adjacent modules weave the 3D Raussendorf lattice. The choice of four-photon rather than two-photon raw material is an efficiency optimisation: each fusion attempt couples more cluster edges per unit resource than a Bell-pair-based approach, improving the effective gate count and the loss tolerance.
Percolation thresholds
When fusions fail independently with probability p_f, the resulting random graph is in a percolation regime: whether the cluster has a single connected component spanning the lattice depends on whether p_f is above or below a critical threshold. For the 2D square lattice, the bond-percolation threshold is exactly 1/2, meaning fusions with success \ge 50\% produce (with probability 1 in the thermodynamic limit) a spanning cluster. For the 3D Raussendorf lattice the threshold is around 25\%, giving much more headroom. This is why PsiQuantum aims for a 3D architecture: the loss-and-failure tolerance is structurally higher.
Loss-tolerant cluster states
A standard cluster state with a missing edge is fine. A standard cluster state with a missing node (one photon lost) is worse: the node is part of the stabiliser structure, so losing it creates a boundary of broken stabilisers that must be repaired. Varnava, Browne, and Rudolph (2006) and subsequent work showed that concatenation — each logical qubit of the cluster encoded in a small inner code of several physical photons — can make the cluster tolerant to per-photon loss up to 50% without the overall machine failing. The cost is a factor of 5–10 more physical photons per logical qubit. The PsiQuantum architecture uses a variant of this approach at the resource-state level.
Xanadu's continuous-variable route
Xanadu pursues a completely different preparation recipe. Instead of single-photon fragments and fusion, they generate continuous-variable cluster states on squeezed light: each "qubit" is an infinite-dimensional mode of an optical resonator, and edges are realised by two-mode squeezing interactions on the optical table. No fusion is needed — the CV cluster can be generated as a single large Gaussian state. The trade-off is that universal CV-MBQC additionally requires non-Gaussian operations (injecting GKP states or performing photon-number-resolving detection), and the overall threshold is a combination of squeezing level and GKP error rate rather than photon loss. Xanadu's Borealis machine (2022) demonstrated Gaussian cluster states on 216 modes; a fault-tolerant GKP-encoded CV cluster is their next-decade target.
Where this leads next
- Measurement-Based Quantum Computing — what you do with the cluster once it exists: adaptive single-qubit measurements that implement any quantum circuit.
- Measurement-Based Photonics — the photonic specialisation, which motivates fusion as the native approach.
- PsiQuantum — the company building a fab-scale fusion network.
- Xanadu — the continuous-variable alternative.
- Photonic Qubits — the underlying hardware: polarisation, dual-rail, time-bin encodings.
- Surface Code — the fault-tolerance layer the 3D cluster state naturally encodes.
References
- Robert Raussendorf and Hans J. Briegel, A One-Way Quantum Computer (2001), Physical Review Letters — arXiv:quant-ph/0010033.
- Daniel E. Browne and Terry Rudolph, Resource-Efficient Linear Optical Quantum Computation (2005), Physical Review Letters — arXiv:quant-ph/0405157.
- Wikipedia, Cluster state.
- Sara Bartolucci et al. (PsiQuantum), Fusion-based quantum computation (2021) — arXiv:2101.09310.
- Nicolas C. Menicucci et al., Universal Quantum Computation with Continuous-Variable Cluster States (2006) — arXiv:quant-ph/0605198.
- John Preskill, Lecture Notes on Quantum Computation, Chapter 7 — theory.caltech.edu/~preskill/ph229.