Fusion-Based Quantum Computation

• Fusion-Based Quantum Computation (FBQC) is a scalable model that uses small, entangled resource states and fusion measurements to dynamically construct large, fault-tolerant quantum networks.
• The model leverages low-depth, localized operations and geometric network designs to enable efficient on-demand state generation and robust error correction via topological codes.
• FBQC demonstrates practical fault tolerance with numerical thresholds, such as 10.4% photon loss in 6-ring networks, highlighting its suitability for integrated photonic implementations.

Fusion-Based Quantum Computation (FBQC) is a model of universal quantum computation in which all operations are reduced to (i) the generation of small, constant-sized entangled "resource states" (often graph or stabilizer states) and (ii) "fusion" measurements—multi-qubit projective measurements that entangle and join resource states to construct a large computational network. FBQC departs from both monolithic circuit-based computing and the canonical cluster-model measurement-based paradigm by building the logical computational fabric dynamically from local operations on small resource modules. Architecturally, FBQC is closely matched to the physically available operations in platforms such as photonics, enabling extremely low operational depth per qubit, modular hardware, and favorable fault tolerance characteristics, as demonstrated by both theoretical analyses and simulation (Bartolucci et al., 2021).

1. Fundamental Principles: Resource States and Fusion

FBQC is constructed on two primitives:

1. Resource State Generation: Small entangled states (commonly stabilizer states such as 4-qubit GHZs or 6-qubit rings) are generated in constant-depth circuits. These states are highly modular and can be produced on demand by repeated, identical quantum devices.
2. Fusion Operations: Fusions are entangling, rank-1 projective measurements executed between qubits belonging to two (or more) distinct resource states. For photonic qubits, such fusions are realized via linear-optical Bell measurements—probabilistic but heralded via photon detection events.

The fusion operation typically corresponds to the simultaneous measurement of commuting two-qubit Pauli operators, such as $X_1 X_2$ and $Z_1 Z_2$ in the Bell basis, or $X_1 Z_2$ and $Z_1 X_2$ depending on local Clifford operations. The outcomes of these measurements form the raw classical data out of which the global logical computational state emerges (Bartolucci et al., 2021).

The overall computation unfolds as a "fusion network": a dynamically growing 2D/3D graph in which local fusions stitch resource states together to realize long-range entanglement and topological encoding in “bulk” structures analogous to the surface code.

2. Stabilizer Formalism and Fusion Networks

FBQC analysis relies on a stabilizer formalism that extends standard graph-state frameworks to the context of dynamically assembled fusion networks. This involves:

• Resource State Stabilizer Group ($R$): The group of stabilizer generators characterizing the small entangled states (GHZ, ring, etc.).
• Fusion Measurement Group ($F$): The group generated by all fusion measurement observables (including possible signs, to handle anticommutation).
• Surviving Stabilizer Group ($S = \mathcal{Z}_R(F)$): The centralizer of $F$ in $R$, representing logical operators that survive after all fusion measurements.
• Check Operators ($C = R \cap F$): The intersection identifies parity checks whose outcomes, as products of individual fusion results, encode the logical syndrome necessary for error correction.

This formalism can be articulated as

$S = \mathcal{Z}_R(F)$

with checks

$m s_{\mathrm{out}} \in S_{\mathrm{out}}$

for measured outcomes $m$ and surviving output stabilizer $s_{\mathrm{out}}$. This compactly captures the propagation of Pauli frame updates and the emergence of correlated measurement errors from real physical operations.

Fusion networks can be visualized geometrically with resource states as nodes and fusions as edges/ovals (as in Figure 1 of (Bartolucci et al., 2021)), providing a combinatorial and topological backbone for logical code constructions.

3. Example Fault-Tolerant Schemes: 4-Star and 6-Ring Networks

Two instructive network constructions illustrate the concepts:

• 4-Star Fusion Network: Uses 4-qubit GHZ states as resource blocks. Arranged on a cubic lattice (with resource states on edges and faces), 24 pairwise Bell fusions per unit cell produce a syndrome graph isomorphic to the surface code. Each check operator is a parity check over many fusions, providing redundancy for error correction.
• 6-Ring Fusion Network: Utilizes 6-qubit ring graph states, deployed on a body-centered cubic lattice (two resource states per unit cell). Here, the syndrome graph requires only 12 fusions per check, reducing measurement overhead and enhancing threshold performance. Further, replacing each physical qubit with a $(2,2)$-Shor code encoded block further suppresses erasures, demonstrating code-compatibility and increased tolerance.

Thresholds determined via extensive Monte Carlo simulations in (Bartolucci et al., 2021) are:

Scheme	Erasure Threshold	Pauli Error Threshold
4-Star network	6.90%	0.75%
6-Ring network	11.98%	1.07%

Encoding with $(2,2)$-Shor code further improves the tolerance by mitigating erasure errors from photon loss/fusion failures.

4. Error Models and Loss Analysis

FBQC supports precise error modeling through both hardware-agnostic and photonic-specific models:

• Hardware-Agnostic Model: Fusion outcomes are erased with probability $p_\text{erasure}$ or flipped with probability $p_\text{error}$. These error rates map directly onto the syndrome graph established by the fusion network’s check operators for error decoding.
• Linear-Optical Error Model: In photonic realizations, a fusion can "fail" (i.e., only yield one outcome; the other is erased) with probability $p_\text{fail}$, and each photon is lost with probability $p_\text{loss}$. The marginal erasure rate for an individual measurement is then

$$p_0 = 1 - (1 - p_\text{fail}/2) \; \eta^{1/p_\text{fail}},$$

where $\eta = 1 - p_\text{loss}$. Boosting protocols (e.g., ancillary Bell states) reduce $p_\text{fail}$ but require more photons per fusion, which amplifies loss. For encoded fusions (e.g., with $(2,2)$-Shor encoding), the effective erasure rate is evaluated as

$$p_\text{enc} = \frac{ [1 - (1-p_0)^2]^2 + [1 - (1 - p_0^2)^2] }{2}$$

by combining two independent reconstruction paths.

Threshold regions in the $(p_\text{erasure}, p_\text{error})$ plane are explicitly mapped out; for the 6-ring network, photon loss per fusion is tolerable up to approximately 10.4% when using boosted and encoded schemes.

5. Architectural and Hardware Simplifications

FBQC makes several architectural simplifications that enable scalable fabrication and minimized error accumulation:

• Module Uniformity and Low Depth: All resource states are small and fixed in structure, fostering extreme modularity and ultra-low operational (circuit) depth. Each photon is generated, possibly entangled via a fusion, and immediately measured, sharply reducing memory requirements.
• Geometric Locality and Ballistic Routing: The fusion network is assembled with locally-connected resource modules arranged on a regular lattice (2D or 3D) with fixed geometric connections. In ballistic FBQC, the routing is static and pre-engineered—no fast feedforward is required on physical timescales.
• Separated Time Scales: Error correction and logical feedforward (needed for quantum algorithms) are run asynchronously at the logical level, allowing the physical qubits to be operated and measured at much faster rates than logical feedback cycles.

A schematic (see Fig. 1 in (Bartolucci et al., 2021)) demonstrates how resource state generators (e.g., integrated photonic chips) can be networked and routed via fixed or fiber delay lines into passive fusion modules, greatly reducing the need for advanced switching or shuffling.

6. Quantum Error Correction in FBQC

FBQC is intrinsically equipped for topological error correction:

• Check Operators: Derived directly from the overlap between resource and fusion groups ($C = R \cap F$), these parity checks form a syndrome graph analogously to the surface code. Each logical qubit and fault-tolerant gate may be identified with topologically nontrivial boundaries or defects ("twists," "domain walls") engineered by modifying fusion patterns or resource block arrangements.
• Pauli Frame Tracking: Because fusion outcomes are stochastic, logical operations are governed by dynamically tracking a classical Pauli frame as syndrome data is processed. Surviving stabilizer generators, together with decoded syndrome outcomes, dictate corrections.
• Decoding Algorithms: Minimum-weight perfect matching and related decoders can be directly applied on the syndrome graph constructed by the fusion network, yielding real-time error correction suitable for logical operations and active feedforward.

7. Implementation and Scalability Considerations

FBQC is hardware-friendly and highly scalable, particularly for photonic architectures:

• Resource State Generation: Fabrication is reduced to producing a massive array of identical small-scale entangled photon sources. This modularity significantly lowers the cost and complexity of scaling.
• Ballistic and Loss-Tolerant Operation: Ballistic operation (no dynamic switching) minimizes photon latency and reduces opportunities for error accumulation. Loss and failure are natively absorbed into the error-correction scheme, provided that system loss rates stay below established thresholds (e.g., $p_0 < 12\%$ for 6-ring network).
• Classical Processing: Classical post-processing is confined to logical-level syndrome tracking and decoding and need not operate at the ultrafast photonic clock rate.
• Experimental Feasibility: Provided that resource photonic states can be generated and detected with combined efficiency $\eta_{\text{total}}$ above the threshold (e.g., 0.973), and that circuit losses are minimized (propagation $\lesssim 0.5$ dB/cm and beamsplitter loss per device $\lesssim 0.05$ dB), error-corrected, fault-tolerant operation is feasible even with current optical platforms (Melkozerov et al., 21 Mar 2024).

8. Broader Implications and Theoretical Context

FBQC constitutes a distinct and flexible model, not limited to specific hardware or operational primitives:

• By eliminating the need to instantiate large cluster states and lengthy gate sequences, FBQC achieves quantum computation with minimized circuit depth, modular hardware, and strong adaptability to photonic, modular atomic, or potentially hybrid implementations.
• The detailed stabilizer formalism allows direct mapping between physical operations and logical structure, enabling systematic error modeling and code design tailored to physical limitations such as loss, non-determinism, and restricted connectivity.
• The native compatibility with topological error correction, geometric network design, and asynchronous logical processing makes FBQC an attractive candidate for scaling quantum computation beyond current experimental capabilities.

A strong numerical result from (Bartolucci et al., 2021) is that the ballistic 6-ring fusion network can, under a hardware-agnostic fusion error model, tolerate up to 10.4% loss per photon in each fusion with boosted and encoded resource states—significantly exceeding earlier loss thresholds in the literature.

9. Summary Table of Key Quantitative Results

Fusion Network	Resource State	Erasure Threshold	Pauli Error Threshold	Encoded Threshold (erasure)	Ballistic Loss Tolerance
4-Star	4-qubit GHZ	6.90%	0.75%	--	--
6-Ring	6-qubit Ring	11.98%	1.07%	Up to $\sim$12%	10.4% per photon

All numerical values as reported in (Bartolucci et al., 2021); the ballistic (fixed-path) hardware implementation achieves loss-tolerance up to the regime practical for current integrated photonic technologies.

All technical content, formalism, results, and numerical thresholds are as detailed in "Fusion-based quantum computation" (Bartolucci et al., 2021).