We adopt a method of the quantum gate teleportation for converting circuit-based quantum computation primitives into fusion networks. By using the presented scheme for the CNOT gate we construct translation of the circuit for the foliated surface code into a fault tolerant fusion network. Finally, we construct two new fusion based quantum computation models and study their fault tolerance properties.
We adopt a method of the quantum gate teleportation for converting circuit-based quantum computation primitives into fusion networks. By using the presented scheme for the CNOT gate we construct translation of the circuit for the foliated surface code into a fault tolerant fusion network. Finally, we construct two new fusion based quantum computation models and study their fault tolerance properties.
Fault-tolerant complexes describe surface-code fault-tolerant protocols from a single geometric object. We first introduce fusion complexes that define a general family of fusion-based quantum computing (FBQC) fault-tolerant quantum protocols based on surface codes. We show that any 3-dimensional cell complex where each edge has four incident faces gives a valid fusion complex. This construction enables an automated search for fault tolerance schemes, allowing us to identify 627 examples within a moderate search time. We implement this using the open-source software tool Gavrog and present threshold results for a variety of schemes, finding fusion networks with higher erasure and Pauli thresholds than those existing in the literature. We then define more general structures we call fault-tolerant complexes that provide a homological description of fault tolerance from a large family of low-level error models, which include circuit-based computation, floquet-based computation, and FBQC with multi-qubit measurements. This extends the applicability of homological descriptions of fault tolerance, and enables the generation of many new schemes which have not been previously identified. We also define families of fault-tolerant complexes for color codes and 3d single-shot subsystem codes, which enables similar constructive methods, and we present several new examples of each.
The standard primitives of quantum computing include deterministic unitary entangling gates, which are not natural operations in many systems including photonics. Here, we present fusion-based quantum computation, a model for fault tolerant quantum computing constructed from physical primitives readily accessible in photonic systems. These are entangling measurements, called fusions, which are performed on the qubits of small constant sized entangled resource states. Probabilistic photonic gates as well as errors are directly dealt with by the quantum error correction protocol. We show that this computational model can achieve 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, which corresponds to a 2.7% probability of loss of each individual photon. The architecture is also highly modular and has reduced classical processing requirements compared to previous photonic quantum computing architectures.
We introduce a construction for protocols for fault-tolerant quantum computing based on code concatenation and transversal gates. These protocols can be interpreted as families of quantum circuits of low-weight stabilizer measurements without strict locality constraints, effectively implementing concatenated codes. However, we primarily study these protocols in the context of photonic fusion-based quantum computing (FBQC), where they yield families of fusion networks with constant-sized resource states. Their high erasure thresholds relative to their resource-state cost establish them as promising candidates to replace surface codes in the context of FBQC. Examples include protocol families using 8-, 10- and 12-qubit resource states, with erasure thresholds of 13.8%, 19.1% and 11.5%, and footprint-per-logical-qubit scaling as O(d), O(d1.46) and O(d0.58), respectively, where d is the code distance. We also present techniques for performing logical operations, decoding, and implementing the protocols in photonic hardware. Although we focus on photonic FBQC, these ideas may also be of interest in other settings.
Circuit-based quantum computing (CBQC) has far remained the most intuitive and experimentally mature model of universal quantum computation, serving as the basis for today’s noisy intermediate-scale quantum (NISQ) devices and emerging fault-tolerant quantum computation (FTQC) due to its well-developed control and error-correction techniques. Nevertheless, scalability challenges and suitability to photonic platforms have motivated the exploration of alternative computational models such as measurement-based quantum computing (MBQC), which separates entanglement generation from actual computation and is considered more natural for scalable and distributed architectures. More recently, fusion-based quantum computation (FBQC), and in particular its encoded variant (EFBQC), have been proposed to alleviate many of the practical limitations of traditional MBQC by using constant-size resource states and encoded fusion operations with controllable failure behavior, thus improving practicality, flexibility, and fault-tolerance. Motivated by these potential advantages of measurement-based approaches while recognizing the continued prominence and circuit-level versatility of CBQC, in this work, we propose a hybrid approach that combines CBQC with (E)FBQC to improve long-range connectivity and Clifford-dominated subroutine execution under threshold-compatible operating conditions, enabling higher performance in the context of fault tolerance and architectural scalability. In detail, we propose an encoded-fusion- assisted teleportation (EFAT) mechanism, with two configurations for different scenarios: (1) the Minimal Hybrid, in which (E)FBQC acts as a logical entanglement bus that supplies encoded Bell pairs for teleportation-based connectivity between CBQC modules, thus replacing distance-dependent routing with teleportation and reducing routing overhead when routing dominates the logical schedule, while remaining compatible with the derived surface-code threshold condition; (2) the Extended Hybrid, in which (E)FBQC additionally participates in the computation alongside CBQC nodes, so that encoded cluster fragments can be used to execute Clifford subroutines in constant depth. Our performance analysis shows that the Minimal Hybrid can reduce routing-dominated logical depth while remaining compatible with the derived fault-tolerance condition, whereas the Extended Hybrid can further compress Clifford-dominated subroutines and may improve the temporal scheduling of magic-state supply, at the expense of higher photonic throughput and tighter synchronization requirements. Together, these results indicate a practical route toward scalable, modular, and fault-tolerant quantum computing based on encoded-fusion-assisted hybrid architectures.
Fusion-based quantum computation is a promising quantum computing model where small-sized photonic resource states are simultaneously entangled and measured by fusion gates. Such operations can be readily implemented with scalable photonic hardware: resource states can be deterministically generated by quantum emitters and fusions require only shallow linear-optical circuits. Here, we propose fusion-based architectures tailored to the capabilities and noise models in quantum emitters. We show that high tolerance to dominant physical error mechanisms can be achieved, with fault-tolerance thresholds of 8% for photon loss, 4% for photon distinguishability between emitters, and spin noise thresholds well above memory-induced errors for typical spin-photon interfaces. Our construction and analysis provide guidelines for the development of photonic quantum hardware targeting fault-tolerant applications with quantum emitters.
Fusion-based quantum computing (FBQC) offers a powerful approach to building a fault-tolerant universal quantum computer using photonic components -- single-photon sources, linear-optical circuits, single-photon detectors, and optical switching with feedforward control. Both individual optical switches and sophisticated switch networks are needed where it is necessary to perform operations conditionally, using feedforward of previous photon-detection outcomes, within the lifetime of remaining photons. Most visibly, feedforward switching is required for fault-tolerant operations at the level of logical qubits, which are needed in turn for useful quantum algorithms. However, switch networks are also required for multiplexing ("muxing") stages that are needed for generating specific small entangled resource states, where it is used to boost the probabilities for allocating quantum states to fusion gates and other operations -- a task which dominates the footprint of photonic FBQC. Despite their importance, limited attention has been paid to exploring possible designs of switch networks in this setting. Here we present a wide range of new techniques and schemes which enable major improvements in terms of muxing efficiency and reductions in hardware requirements. Since the use of photonic switching heavily impacts qubit losses and errors, our schemes are constructed with low switch depth. They also exploit specific features of linear-optical circuits which are commonly used to generate entanglement in proposed quantum computing and quantum network schemes.