Fusion-Based Quantum Computing

Every thread of this module now gets tied. Dual-rail qubits whose single-qubit gates are free; entanglement bought only probabilistically, with heralds; loss as the error that matters. The architecture that weaves them together is fusion-based quantum computing (FBQC) — the design behind PsiQuantum's bet that the first million-qubit machine will be printed in a semiconductor fab. Its starting point is the photonic version of measurement-based computing: compute by measuring an entangled cluster state. But it immediately confronts an awkward photonic truth — a photon cannot wait around while you build a billion-photon cluster. Photons fly at the speed of light and die by absorption; there is no "holding register". FBQC's answer is radical: never build the big cluster at all. Build only small, constant-size entangled resource states, fresh every clock cycle, and stitch their fates together with two-photon measurements called fusions. The full cluster exists only abstractly, in the correlations of the measurement record — the machine itself never holds more than a few nanoseconds of photons at once.

Fusion: entangling by destroying

A fusion is a joint Bell-basis measurement on two photons — one from each of two resource states. It asks the pair a joint question ("which Bell state are you in?") and, in answering it, destroys both photons. The payoff is what happens to the survivors: measuring two photons in an entangled basis projects their respective partners into entanglement with each other, exactly the measurement-induced trick of the KLM lesson. In graph-state language: fusing a leaf photon of one small graph with a leaf of another welds the two graphs into one — minus the two photons spent. Entanglement is not wired between modules; it is relayed through sacrificed photons.

Linear optics collects its usual toll. A Bell measurement built from beamsplitters and detectors can distinguish only two of the four Bell states: bare fusion succeeds with probability \tfrac12. Boosting with ancilla photons lifts this — with 2^k - 2 extra ancillas, success reaches

p_{\text{fusion}} \;=\; 1 - \frac{1}{2^{\,k}} \qquad (k = 1: \tfrac12,\;\; k = 2: \tfrac34,\;\; k = 3: \tfrac78, \dots)

and — the saving grace inherited from KLM — failure is heralded: the detector pattern announces it, and a failed fusion is equivalent to accidentally measuring the two photons in a known single-photon basis instead. That is not a disaster but a defect: a missing weld at a known location, which the architecture is designed to route around.

The fusion network

Picture the machine as a production line. Every clock cycle, an army of identical sources emits small resource states — say four-photon stars. A fixed lattice of fusion devices measures chosen pairs of leaf photons between neighbouring states. The successes weld a growing fabric of entanglement; the pattern of fusion outcomes, plus single-photon measurements on the remaining photons, is the computation, exactly as in measurement-based computing. Step through the elementary move:

Tile that move in space (a lattice of fusion devices) and in time (fresh resource states each cycle, with previous cycles' outcomes feeding forward), and the fusion record reconstructs precisely the measurement statistics of an enormous 3-D cluster state — one that never physically existed. The choice of which measurements implement which logical gates is inherited wholesale from measurement-based computing; FBQC's contribution is making the resource manufacturable.

Why this beats holding a cluster: the loss ledger

The deep advantage is written in the exponent of the loss law. In a gate-model photonic circuit, a photon must survive a chain of components whose length grows with the algorithm — survival \eta^{N} with N unbounded, the exponential death sentence from the start of this course. In FBQC, every photon lives a constant-depth life: born in a resource-state generator, through a few components, into a fusion or a measurement, within nanoseconds — regardless of whether the computation runs for a microsecond or a month. Loss per photon is therefore a fixed, engineerable number, and the architecture converts it into an erasure error: a silent detector flags exactly which photon vanished. Known-location errors are the kindest kind, and the machinery of fault tolerance handles them with unusually generous thresholds:

universal fault-tolerant quantum computation can be built from two primitives only: constant-size entangled resource states and two-photon fusion measurements (plus single-photon measurements and feedforward);
fusion failure and photon loss are both heralded, and the fusion network's decoding treats them as erasures on a known lattice;
with encoded fusions — each logical fusion performed redundantly on small error-protected photon groups — the scheme tolerates roughly 1% photon loss per fusion alongside the ~25% fusion-failure rates of boosted linear optics;
no photon's optical path depends on the length of the computation — loss per photon is constant by construction.

The encoded fusions deserve one more sentence, because they close the module's loop: each logical fusion is implemented as several physical fusions on photons of a small code (a Shor-type (2,2) encoding in the original proposal), so that any single physical failure or loss still leaves enough information to complete — or gracefully abort — the weld. The whole error stack, top to bottom, is measurement, heralds and codes; nowhere does any photon interact with any other.

Worked example: counting the factory's output

A toy budget makes the industrial scale vivid. Join a line of s-photon resource states into one connected cluster: each junction needs one fusion, so c states cost c - 1 fusions and 2(c-1) sacrificed photons — with boosted fusions at p = \tfrac34, roughly a quarter of the welds fail (heralded) and must be routed around by the decoder. Now scale: a fault-tolerant machine running a useful algorithm needs on the order of 10^6 physical photonic qubits per clock cycle, each cycle a nanosecond. That is billions of fresh resource states per second, which is why FBQC's proponents talk less like physicists than like manufacturing engineers: the problem is yield, uniformity and throughput of identical photonic components — precisely the problem semiconductor fabs solved for transistors.

Founded in 2016, PsiQuantum made a strategic wager unique in the industry: no intermediate-scale device, no cloud demos, no publishable qubit counts for years — nothing until a fault-tolerant, million-qubit machine. The reasoning is pure FBQC: since the architecture needs astronomical volumes of identical, high-yield photonic components rather than a few exquisite ones, the enabling technology is not a physics lab but a production line. So the company partnered with GlobalFoundries to run its silicon-photonic resource-state chips through a standard 300-mm semiconductor process — waveguides, interferometers and superconducting single-photon detectors printed by the wafer, with fibre delay lines standing in for memory and cryogenic plants cooling only the detectors, not the qubits. Whether the bet pays is genuinely open: resource-state generation efficiency and per-component loss must still improve by orders of magnitude. But the wager's shape is the lesson — it takes seriously this course's oldest theme, that photonics wins exactly where it can ride the manufacturing and networking infrastructure electronics already built.

Two misreadings of the fusion diagram cause endless confusion. First: fusion is not a cable. The measured photons are destroyed — their detectors click, their modes empty — and the new entanglement appears between the surviving partners, conjured by the projection. Nothing physical flows along the dashed line; you cannot "fuse harder" to get a stronger link. The resource being consumed is the pre-existing entanglement inside each resource state, and once spent it is gone — which is why the machine must manufacture entanglement continuously, like a power station, rather than accumulate it like a battery. Second: heralded failure is not fault tolerance. A failed fusion tells you where the weld is missing; it does not by itself protect any quantum information. The protection comes from the encoded fusions and the erasure-decoding lattice built on top. Herald first, then encode, then decode — remove any layer and the architecture collapses.

Module close: the quantum thread, tied off

Step back and the module tells one continuous story. Photons make superb qubits that refuse to interact; linear optics gives single-qubit gates for free; Hong–Ou–Mandel interference supplies a single, strange two-photon resource; KLM leverages it — through ancillas and measurement — into entangling gates at a probabilistic price; boson sampling and its Gaussian cousin cash the physics out for quantum advantage without ever paying for universality; and fusion networks pay the full price on an industrial plan, converting probabilistic entanglement and heralded loss into a fault-tolerant architecture with constant optical depth. The through-line is always the same trade: interaction is bought with measurement, and reliability with volume. With the quantum frontier surveyed, the course's next module returns to classical territory of a different flavour — neuromorphic and emerging photonics, where light imitates neurons instead of qubits.