PaperlayerView exact revision on arXiv

Source-linked AI summary

Fusion-based quantum computation

Sara Bartolucci, Patrick Birchall, Hector Bombin, Hugo Cable, Chris Dawson, Mercedes Gimeno-Segovia, Eric Johnston, Konrad Kieling, Naomi Nickerson, Mihir Pant, Fernando Pastawski, Terry Rudolph, Chris Sparrow

arXiv:2101.09310v1quant-ph

TL;DR

FBQC addresses how to achieve fault-tolerant universal computation using physical primitives such as small entangled resource states and entangling measurements. The paper develops and evaluates this framework, including hardware-agnostic and linear-optical error models, finding thresholds including 10.4% photon loss per fusion. Its architecture uses modular, low-depth operations and separates physical fusion from slower classical decoding.

  • Problem

    Existing resource-state and fusion approaches can require mappings to other computational models, introducing inefficiencies and complex classical processing; a native fault-tolerance framework is needed for these physical primitives.

  • Method

    The paper introduces FBQC, a stabilizer-based framework using constant-sized entangled resource states and fusions, then evaluates pedagogical schemes under hardware-agnostic and linear-optical error models.

  • Results

    10.4% photon loss per fusion is tolerated in a ballistic scheme, while the studied schemes reach 43.2% fusion-failure threshold and 11.98% erasure threshold.

  • Takeaways & Limitations

    FBQC links physical operations to topological fault tolerance while enabling modular, low-depth architectures whose threshold is independent of classical feed-forward timescale once resources are available.

Abstract

from arXiv · show

We introduce fusion-based quantum computing (FBQC) - a model of universal quantum computation in which entangling measurements, called fusions, are performed on the qubits of small constant-sized entangled resource states. We introduce a stabilizer formalism for analyzing fault tolerance and computation in these schemes. This framework naturally captures the error structure that arises in certain physical systems for quantum computing, such as photonics. FBQC can offer significant architectural simplifications, enabling hardware made up of many identical modules, requiring an extremely low depth of operations on each physical qubit and reducing classical processing requirements. We present two pedagogical examples of fault-tolerant schemes constructed in this framework and numerically evaluate their threshold under a hardware agnostic fusion error model including both erasure and Pauli error. We also study an error model of linear optical quantum computing with probabilistic fusion and photon loss. In FBQC the non-determinism of fusion is directly dealt with by the quantum error correction protocol, along with other errors. We find that tailoring the fault-tolerance framework to the physical system allows the scheme to have a higher threshold than schemes reported in literature. We present a ballistic scheme which can tolerate a 10.4% probability of suffering photon loss in each fusion.

I. INTRODUCTION

FBQC builds universal quantum computation from fixed-size entangled resource states and projective entangling measurements, while linking physical architecture to fault tolerance. Its examples use geometrically local fusion networks and achieve low operational depth with relaxed classical-processing timing.

  • I. INTRODUCTION: FBQC uses small constant-sized entangled resource states and projective entangling measurements called fusions as its two primitive operations.The framework explores topological fault-tolerant quantum computation using these primitives directly.
  • I. INTRODUCTION: Native use of resource generation and fusion avoids mapping into another computational model, reducing protocol depth and classical-processing requirements while improving tolerance to erasure and Pauli errors.The paper reports a threshold of 11.98% against erasure and 1.07% against Pauli error in its hardware-agnostic model.
  • A. Principles of FBQC: A fusion network specifies which resource-state qubits undergo entangling measurements, with measurement bases modified to implement algorithms and combined outcomes producing computation outputs.The examples are geometrically local because they target topological fault tolerance.
  • A. Principles of FBQC: Fault-tolerant networks combine fusion outcomes into parity checks, and logical gates can be implemented by changing measurement bases near boundaries, punctures, defects, or twists.For quantum memory, the fusion configuration can be fixed and the measurements can be identical.
  • C. Architecture: Architectures route qubits from repeatedly operating resource-state generators to fusion locations, allowing multiple physical layouts for the same fusion network.Routing can include spatial connections and temporal delay lines, and a 3D network may be generated simultaneously or layer by layer.
  • C. Architecture: Each physical qubit is created and essentially immediately measured, producing extremely low operational depth that limits error accumulation and helps tolerate leakage.The architecture can create a higher-dimensional fusion network from lower-dimensional hardware.
  • C. Architecture: Logical feed-forward and decoding can occur on a slower timescale than resource generation and fusion, so physical qubits need not wait for classical decisions.Fusions can proceed without decoding outcomes, and buffering or ancillary logical qubits can accommodate slower decoding.

II. FUSION

Fusion-based computation starts from small entangled states and creates larger correlations through projective measurements, with Bell fusions providing the principal stabilizer-measurement example. In linear optics, fusion is probabilistic, but its failure produces usable classical information and can be incorporated into fault-tolerant encoding.

  • A. Fusion: FBQC generates large-scale quantum correlations by measuring qubits from distinct fixed-size resource states with entangling projectors.The paper focuses on potentially destructive rank-1 projective measurements rather than general positive operator-valued measurements.
  • A. Fusion: Stabilizer-state projections enable existing stabilizer fault-tolerance methods, and the paper focuses on two-qubit Bell-state projections called Bell fusions.Most error-correction measurements are identical Bell fusions, while logical gates require modified measurements or single-qubit measurements.
  • A. Fusion in Linear Optics: Dual-rail qubits encode 0 and 1 as a single photon in one of two modes, making photon loss heraldable because it leaves the computational subspace.The encoding also tolerates relative phase shifts between modes belonging to different qubits.
  • A. Fusion in Linear Optics: Linear optical Bell fusion has success, failure, and erasure outcomes: failure is intrinsic and reveals one intended outcome, whereas erasure results from system errors such as photon loss.The intended outcomes are X1X2 and Z1Z2.
  • A. Fusion in Linear Optics: In linear optics, fusion failure replaces the intended two-qubit Bell outcomes with separable single-qubit measurements, while one Bell outcome remains recoverable from their product.The failure can therefore be treated as erasure of one Bell-measurement outcome, without generating entanglement.
  • A. Fusion in Linear Optics: Basic type-II fusion has pfail = 50%, while an additional Bell pair reduces failure to 25%; further ancillary photons can suppress it further.Fusion failure is described as more benign than erasure because it is heralded and leaves pure quantum states usable in the computation.
  • A. Fusion in Linear Optics: Encoded fusion can improve tolerance to photon loss and fusion failure by applying physical fusions transversally to qubits encoded with a (2,2)-Shor code.The underlying physical encoding is a [4,1,2] CSS code.
  • A. Fusion in Linear Optics: Single-qubit rotations before Bell fusion change the effective measurement basis, while a switch enables reconfiguration among different fusion measurements.A Hadamard on one input produces an effective fusion measurement ⟨XZ, ZX⟩.

III. RESOURCE STATES

FBQC uses small, fixed-size entangled resource states as the building blocks of computation. These states can be represented as graph states, encoded for redundancy, and generated using platform-dependent operations, including probabilistic linear-optical measurements.

  • Resource-state structure: Resource states are small entangled states whose size is independent of computation size or code distance.They can typically contain O(10) qubits and are measured immediately after preparation, keeping operation depth constant and bounding accumulated errors.
  • Resource-state structure: Qubit stabilizer resource states are represented, up to local Clifford operations, by graph states whose vertices denote qubits and edges denote controlled-Z entangling operations.Their stabilizer generators have the form Xi multiplied by Z operators on the neighboring vertices.
  • Examples: The 6-ring graph state is one example used in a topological fault-tolerant fusion network.Its six stabilizer generators couple each qubit's X operator to Z operators on its two neighboring qubits.
  • Encoding: Each graph-state qubit can be replaced by a (2,2)-Shor encoded qubit to add redundancy against fusion loss and errors.Replacing every qubit in the 6-ring produces the encoded resource state shown in Fig. 3(c).
  • Linear-optical generation: In linear optics, resource states are generated from smaller seed states through projective measurements, with switching networks repeating probabilistic operations and imposing constant resource overhead.The generation protocol determines the resource state's noise profile, while fixed state size bounds accumulated noise and localizes correlations within each state.

IV. FUSION NETWORKS

A fusion network combines small resource states through projective entangling measurements, leaving classical outcomes and quantum correlations on unmeasured qubits. The stabilizer formalism identifies the surviving correlations and relates their signs to fusion outcomes.

  • Network construction: A fusion network arranges resource states and specifies projective entangling measurements, removing the fused qubits while retaining outcomes and possible quantum correlations.The network itself describes entanglement structure rather than an operation ordering.
  • Stabilizer formalism: Stabilizer fusion networks are characterized by a resource-state group R and a fusion group F defining the measurement operators.The fusion group includes −1 because fusion outcomes are determined only after measurement and may be random.
  • Stabilizer formalism: The surviving stabilizer group consists of resource-state stabilizers that commute with every fusion operator.For destructive fusions, its restriction to unmeasured qubits gives output stabilizers whose signs are determined by fusion outcomes.
  • Fault-tolerance connection: Products of fusion measurements that match resource-state stabilizers up to signs generate checks on the classical fusion outcomes.These checks are the redundancy later used for fault tolerance.
  • Example: Fusion measurements can combine smaller graph states into larger graph states whose stabilizer signs depend on the measurement outcomes.The example in Fig. 4 produces a four-qubit linear graph state from three resource states when all fusions succeed with +1 outcomes.

V. FAULT-TOLERANT FUSION NETWORKS

Fault-tolerant fusion networks add redundancy so errors in resource states and fusion measurements can be detected or corrected. Their stabilizer formalism separates checks, output operators, and errors that remain undetectable but may or may not affect computation.

  • Overview: Fault-tolerant fusion networks correct resource-state and fusion-measurement errors when their probabilities are sufficiently low.The construction is guided by quantum error-correction and fault-tolerant cluster-state ideas, but direct translations can be inefficient.
  • Checks and syndromes: Output stabilizers act as logical operators, while check operators provide redundancy for identifying and correcting measurement errors.The surviving stabilizer group contains both check operators and stabilizers involving output qubits.
  • Checks and syndromes: Check operators capture redundancy in fusion outcomes and provide the key mechanism for fault tolerance.In the absence of errors, their generators have positive eigenvalues, so fusion outcomes form a classical binary code.
  • Error representation: Errors are represented as Pauli operators inserted after ideal resource preparation and before ideal fusion measurements.This representation captures both resource-generation imperfections and fusion-measurement noise.
  • Undetectable errors: Undetectable errors are classified by U/T: trivial elements have no effect, whereas non-trivial elements alter output stabilizers and determine code distance.Fault tolerance requires the weight of non-trivial undetectable errors to increase with network size.
  • Error representation: Decoding uses equivalence classes in P/F, preserving locality while grouping errors with equivalent effects on code states and checks.Single-qubit Pauli errors on resource states can appear as measurement errors on fusion generators.

B. Example fault-tolerant fusion network

A small example illustrates how fusion outcomes, check operators, and output stabilizers interact in a fault-tolerant fusion network. The network produces a Bell pair while allowing some measurement errors to be corrected and exposing others as logical errors.

  • Network and output: The example network outputs a Bell pair on qubits 1 and 16 and contains two check operators for correcting certain fusion errors.Its stabilizer groups R, F, S, and C are defined from the resource states and fusions.
  • Syndrome processing: Check operators act as parity checks on classical bits recording fusion measurement outcomes.The output stabilizer group combines these outcome bits with operators on the remaining qubits.
  • Correctable errors: An error in Z4Z13 can flip the sign of the output Bell state's XX stabilizer while remaining correctable because that measurement appears in both checks.The shared check structure identifies the inconsistent outcome.
  • Trivial errors: The error E1 = Z2Z10 is trivial because it flips fusion outcomes without affecting either check or the output stabilizer.It belongs to the resource-state or fusion stabilizer structure.
  • Undetectable errors: The error E2 = Z4 is non-trivial and undetectable, causing an incorrect prediction for the sign of ±Z1Z16.It commutes with the check group but anti-commutes with an output-stabilizer generator.

C. Topological fault-tolerant fusion networks

Topological fault-tolerant fusion networks use local operations and stabilizer structure to realize error correction whose distance grows with network size. Their syndrome graphs support decoding, although graph representations are not universal.

  • LDPC fusion networks bound the number of fusions per check generator and the number of generators involving each fusion.
  • Fault tolerance requires families in which non-trivial undetectable errors have support on at least d qubits for every integer d.
  • Fusion measurement outcomes form a classical LDPC code, enabling combinatorial threshold arguments and existing decoders when syndrome graphs apply.
  • Topological LDPC fusion networks use geometrically local operations, with membranes as surviving stabilizers and closed strings as undetectable errors.
  • Syndrome graphs represent check generators as vertices and fusion generators as edges; flipped outcomes alter adjacent checks, while erasures merge them.
  • The paper presents two pedagogical surface-code fusion networks, but not optimized architectures, and syndrome graphs do not naturally represent all schemes.

A. 4-star fusion network

The paper presents 4-star and 6-ring fusion networks built from small entangled resource states and local projective fusions. The 6-ring design uses fewer resources and measurements while providing an improved threshold.

  • A. 4-star fusion network: The 4-star network uses directly prepared 4-GHZ resource states arranged in cubic unit cells and fusions measuring X1Z2 or Z1X2.
  • A. 4-star fusion network: Each 4-star primal check combines 24 fusion outcomes across the six faces of a cubic unit cell, with identical primal and dual syndrome graphs.
  • A. 4-star fusion network: The 4-star logical operators are two-dimensional membranes formed from connected lattice faces and their fusion measurement outcomes.
  • B. 6-ring fusion network: The 6-ring network requires fewer resource states and fusion measurements for the same code distance and offers a significantly improved threshold.
  • B. 6-ring fusion network: The 6-ring network uses six-qubit ring graph states, with two resource states per cubic unit cell and XX or ZZ two-qubit fusion measurements.
  • B. 6-ring fusion network: The 6-ring check combines 12 fusion measurements, half as many per check as the 4-star network, and its syndrome graph adds diagonal edges.

C. Performance comparison

The paper evaluates 4-star and 6-ring networks under hardware-agnostic and linear-optical error models using Monte Carlo sampling and minimum-weight perfect matching. The 6-ring network has the larger correctable region and higher marginal thresholds.

  • 1. Hardware-agnostic fusion error model: The hardware-agnostic model assigns each fusion measurement an erasure probability perasure and a flip probability perror.
  • 2. Linear optical error model: The linear-optical model assigns each fusion a failure probability pfail and each resource-state photon a loss probability ploss.
  • 1. Hardware-agnostic fusion error model: Thresholds are estimated by Monte Carlo simulations of periodic L × L × L networks decoded with minimum-weight perfect matching.
  • 1. Hardware-agnostic fusion error model: 11.98% is the 6-ring marginal perasure threshold, compared with 6.90% for the 4-star network; the 6-ring perror threshold is 1.07% versus 0.75%.

2. Linear optical error model

The linear optical model accounts for fusion failure and photon loss, while layered encodings and topological structures support fault-tolerant computation. Its evaluation combines physical-error mapping with numerical threshold analysis.

  • Error model: The model includes probabilistic fusion operations, photon loss, and dual-rail photonic qubits.Fusion failure and photon loss contribute to erasure and measurement errors.
  • Encoding: FBQC uses three encoding levels: dual-rail physical qubits, local resource-state encoding, and a topologically protected logical qubit.The highest level is a fusion network defining the protected logical qubit.
  • Encoding: The (2,2)-Shor code locally encodes resource-state qubits to make encoded fusions less susceptible to failure and loss.Encoded fusion outcomes can be reconstructed in multiple ways, suppressing erasure.
  • Evaluation: The linear optical evaluation maps fusion failure and photon loss to the hardware-agnostic erasure parameter and reuses simulated threshold values.This avoids separate numerical simulations for the linear optical model.
  • Results: 43.2% is the marginal fusion-failure threshold for the encoded 6-ring network, while Bell-pair boosting gives 2.7% loss tolerance per photon.With 25% fusion failure, the network remains correctable when at least one photon is lost in a fusion with probability 10.4%.

2. Pauli frame tracking

FBQC tracks random logical Pauli corrections classically while allowing physical fusions to proceed without waiting for decoding. Its architecture uses short-lived qubits, reusable generators, and selectively reconfigurable measurements.

  • Pauli frame tracking: The Pauli frame records logical Pauli corrections caused by teleportation randomness and is tracked through classical logic.A physical state may represent the intended logical state up to a Pauli correction.
  • Pauli frame tracking: Stabilizer codes reduce the classical information needed to describe an n-qubit Pauli frame from 2n bits to approximately half.Most Clifford computation can proceed independently of the tracking information.
  • Logical gates: Universal computation supplements Clifford gates with magic-state injection, which can implement T gates or other small-angle rotations.Injection can use modified fusions, single-qubit π/8 measurements, or special magic resource states.
  • Classical processing: Decoding outputs are required at the logical timescale, not the fusion or physical-qubit timescale.Buffering or ancillary logical qubits can accommodate a decoder slower than the logical clock rate, without changing the threshold.
  • Physical architecture: Each physical qubit is initialized, entangled, and immediately measured, giving operational depth and lifetime independent of code size or computation.Resource-state generators can be reused across time slices, while fixed routing reduces switching requirements.
  • Physical architecture: Logic and topological boundaries are implemented by modifying fusion measurements or switching selected devices to single-qubit measurements.Resource-state generators and fusion routing can be arranged in tileable architectures.

D. Errors in FBQC

FBQC’s error framework models how resource-state and fusion errors propagate through local syndrome structures, while its thresholds rely on simplified assumptions. The architecture also distinguishes bulk-threshold behavior from below-threshold logic scaling.

  • Limitations: The reported thresholds are based on simple error models rather than a complete physical implementation.A full analysis depends on detailed system architecture and physical error models.
  • Error structure: Errors from resource-state generation and long-range entanglement are represented as fusion measurement errors in the syndrome graph.This captures how errors propagate from low-weight physical operations into the fusion network.
  • Error structure: Resource-state and fusion errors are expected to remain local when resource states are created in physically separate systems.The paper emphasizes this locality particularly for linear optics, where photons at different locations do not accidentally entangle.
  • Error structure: Correlations between the two outcomes of a fusion are omitted from the model, although incorporating them into decoding could only improve performance.The presented decoding treats primal and dual syndrome graphs separately.
  • Logic and thresholds: Logic features such as boundaries and twists may have different physical error models from the bulk.The bulk should determine the fault-tolerance threshold, while logic may exhibit different below-threshold scaling.
  • Comparison: FBQC differs physically from CBQC and MBQC while permitting the same fault-tolerant logical operations as both.Differences include resources, operational depth, connectivity, classical processing, and error behavior.
  • Comparison: Unlike MBQC’s computation-sized cluster state, FBQC uses constant-sized resource states whose number grows with computation size.Both models combine resource states and measurements, but differ in resource scale and measurement type.
  • Discussion: The introduced FBQC schemes use constant-sized resources and constant depth while reporting improved thresholds over prior literature.They also separate logical feed-forward from physical operations, avoiding photon-lifetime-scale classical processing.

Appendix A: 4-star and 6-ring fusion networks

The appendix defines 4-star and 6-ring fusion-network geometries and explains how encoded resource states and physical fusions produce fault-tolerant logical measurements. It also derives erasure behavior for linear-optical and Shor-encoded fusions.

  • 4-star fusion network: The 4-star network places six four-qubit resource states per cubic unit cell and uses twelve two-qubit fusion operations.
  • 6-ring fusion network: The 6-ring network distributes resource states on a body-centered cubic lattice, with qubits assigned relative coordinates for edge and face connectivity.
  • Linear-optical fusions: Linear-optical fusion attempts Bell-basis measurements X1X2 and Z1Z2, but photon loss erases both outcomes and fusion failure produces separable single-qubit measurements.
  • Linear-optical fusions: Randomizing the failure basis makes the X1X2 and Z1Z2 measurements share a marginal erasure probability, enabling separate decoding of the primal and dual syndrome graphs.
  • Encoded fusions: The four-qubit (2,2)-Shor code reconstructs encoded XX measurements through alternative pairs of physical fusions, reducing encoded erasure below the physical probability when p0 < 0.5.
  • Encoded fusions: penc = 0.043 is the baseline erasure probability for boosted fusion with η = 1 and pfail = 1/4, where p0 = 1/8.

Appendix C: Simulation methods

The appendix specifies hardware-agnostic and linear-optical error models, then estimates fault-tolerance thresholds by Monte Carlo sampling and decoding of finite periodic fusion-network blocks.

  • Error models: The hardware-agnostic model independently erases each fusion measurement with probability perasure and flips non-erased outcomes with probability perror.
  • Hardware-agnostic simulations: Monte Carlo trials simulate 3D periodic fusion-network blocks with Lcode = 12, 16, 20 unit cells for varied erasure and Pauli-error parameters.
  • Hardware-agnostic simulations: The overall logical error occurs when either the primal or dual syndrome graph has a logical error in any periodic dimension after separate decoding.
  • Linear-optical simulations: The linear-optical model assigns photon loss probability ploss to resource and boosting photons, while fusion failure probability pfail determines the required boosting level.
  • Model scope: The photon-loss model is conservative because boosting photons may have lower hardware-level loss probabilities than resource-state photons.

Appendix D: Pauli frame

The Pauli frame is a classical record used to track corrections and intrinsic measurement randomness in FBQC, allowing logical operations and readout to be interpreted without always applying physical Pauli corrections.

  • Pauli-frame tracking: After every logical gate, FBQC updates the Pauli frame of each logical qubit and uses it to interpret logical readout outcomes.
  • Pauli-frame representation: An n-qubit Pauli frame can be stored classically using 2n bits because the Pauli group contains 4^n elements.
  • Pauli-frame tracking: Decoding syndrome information identifies corrections that need not be physically implemented, because they can instead be tracked in the Pauli frame.
  • Pauli-frame tracking: FBQC combines Pauli corrections from intrinsic fusion-measurement randomness with corrections associated with the most likely decoded physical-fault class.
  • Logical feedforward: Logical feedforward can combine decoder outputs from earlier timesteps and state injection, using extra decoder processors and identity gates to accommodate latency.
  • Logical Clifford gates: Logical Pauli operations can be tracked classically, while a physical gate U′ is chosen with a Pauli-frame update to implement the intended logical operation.
Loading 2101.09310v1…