⚛️ quantum physics

Feasibility of Distributed Fault-Tolerant Quantum Computing: From Quantum Links to Algorithms

This paper demonstrates that distributed fault-tolerant quantum computing using superconducting processors connected by limited communication resources is feasible, as even a single physical channel can significantly reduce per-node qubit requirements at the cost of increased execution time, thereby providing a quantitative framework for balancing link performance, processor size, and runtime.

Original authors: Takumi Kobayashi, Hodaka Kurokawa, Yasunari Suzuki, Hideo Kosaka

Published 2026-10-27

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Takumi Kobayashi, Hodaka Kurokawa, Yasunari Suzuki, Hideo Kosaka

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Building a practical quantum computer is one of the most ambitious goals in modern science, promising to solve problems that would take today's supercomputers thousands of years to finish. However, the path to this future is blocked by a simple physical reality: the machines are incredibly difficult to build. To make a quantum computer powerful enough to be useful, scientists need to connect millions of tiny particles called qubits. Currently, the most advanced devices can only hold a few hundred or a few thousand of these particles. The challenge is that as you try to pack more qubits into a single machine, the cooling systems, wiring, and control electronics become too large and complex to manage within a single laboratory setup. It is like trying to fit an entire city's power grid into a single house; the space and resources simply run out.

To solve this, researchers have proposed a different approach: instead of building one giant machine, they could build many smaller ones and link them together. This idea, known as distributed quantum computing, involves connecting separate quantum processors through a network, allowing them to work as a single, massive system. The catch is that these processors must share information instantly and perfectly, which requires creating a special type of connection called an entangled link. Creating these links between distant machines is technically very hard, and until now, it was unclear whether the communication links would need to be perfect to make the system work, or if the system could tolerate some imperfections.

A team of researchers has now mapped out exactly how this distributed system would function, balancing the limits of current technology against the needs of complex calculations. They did not just theorize about the idea; they built a detailed simulation that traces the journey of information from the moment two distant machines try to connect, through the process of cleaning up errors in that connection, all the way to the execution of a real mathematical problem. Their work reveals a surprising trade-off: it is possible to build a massive, fault-tolerant quantum computer using only a single communication channel between each node, but doing so comes at a significant cost to speed.

The researchers focused on superconducting quantum processors, which are currently among the most advanced types of quantum hardware. They modeled two different ways these processors could talk to each other: using microwave signals, which travel well over short distances, and using optical light, which is better for long distances but currently suffers from more noise and loss. They started by calculating how many "entangled pairs" of particles—essentially the raw material for communication—could be generated per second with realistic hardware. They found that while microwave links could potentially generate a million of these pairs per second, optical links might only manage a thousand, and only if the technology improves significantly.

Once these raw connections are made, they are often too noisy to be used directly for calculations. The researchers simulated a process called distillation, where multiple noisy connections are combined to produce a single, high-quality connection. This step is crucial because it allows the system to work even if the initial links are imperfect. However, this purification process takes time and consumes resources. The team discovered that if the initial connection rate is too slow, the waiting time for a clean link becomes so long that the quantum information inside the processors fades away before it can be used. This sets a hard limit: for the system to work efficiently, the physical links need to generate entangled pairs at a rate of at least one hundred thousand per second, a threshold that is currently achievable with microwave technology but remains a distant goal for optical links.

With these hardware limits in mind, the team moved to the next stage: generating "logical" connections. These are the error-corrected links that the actual computer algorithms use. They compared two methods for creating these links. One method, known as lattice surgery, requires a very high number of simultaneous connections and extremely high-quality links. The other method, called state injection, is more flexible and can work with fewer connections and noisier links, though it requires more complex processing to clean up the errors. Their simulations showed that the injection method is far more forgiving. It allows the system to function even if the physical links are not perfect, provided there is enough time to process the errors.

Finally, the researchers tested how these hardware constraints would affect the actual speed of running a quantum algorithm. They simulated running standard mathematical tasks, such as factoring large numbers or estimating the energy of molecules, across a network of ten separate quantum processors. The results were clear and quantifiable. By splitting the work across ten nodes, they could reduce the number of physical particles needed in each individual machine by a factor of ten. This is a massive relief for engineers, as it means each machine could be smaller, easier to cool, and simpler to build. However, this benefit came with a penalty: the total time to finish the calculation increased by roughly ten times.

The study concludes that distributed quantum computing is feasible even with limited communication resources. A system with just one communication channel per node can perform the necessary calculations, provided the hardware can generate entangled pairs at a rate of about one million per second with high fidelity. If the hardware is slower or noisier, the system can still work, but the wait times grow, and the total computation time stretches out significantly. To make the system run as fast as a single, giant machine, the communication links would need to be far superior, requiring hundreds of parallel channels and near-perfect fidelity, which is currently beyond our technological reach.

This work provides a realistic roadmap for the future. It shows that we do not need to wait for perfect, flawless quantum links to build a useful distributed quantum computer. Instead, we can build smaller, manageable machines and connect them with current or near-future technology, accepting that the calculations will take longer. The researchers have quantified exactly how much longer, and what specific improvements in communication speed and quality are needed to make those calculations faster. Their findings suggest that the path forward is not a single leap to perfection, but a series of manageable steps where hardware constraints and algorithmic design are balanced to achieve practical results.

Technical Summary: Feasibility of Distributed Fault-Tolerant Quantum Computing: From Quantum Links to Algorithms

Problem Statement
Realizing practical fault-tolerant quantum computers (FTQCs) requires millions of physical qubits, a scale that poses significant challenges for monolithic architectures due to constraints on control lines, cooling power, and physical space. Distributed architectures, which interconnect multiple smaller quantum processor modules via quantum networks, offer a potential solution. However, the technical feasibility of such systems remains unclear due to the difficulty of generating high-fidelity, high-rate remote entanglement (Bell pairs). Existing studies often rely on simplified or fixed assumptions about communication layers, leaving a gap in understanding the quantitative trade-offs between realistic quantum-link performance (generation rates and fidelities), hardware overhead (physical qubits per node), and algorithmic execution time.

Methodology
The authors present a unified, end-to-end resource estimation framework connecting physical hardware parameters to application-level performance for superconducting processors connected by microwave or optical links. The analysis proceeds through five distinct steps:

Physical Bell-Pair Generation (Step I): The authors model two primary schemes for remote entanglement: photon-interference-based (single-photon and two-photon protocols) and photon-absorption-based. They analyze generation rates ( $r_{Bell}^{phys}$ ) and fidelities ( $F_{Bell}^{phys}$ ) as functions of transmission efficiency and noise, establishing benchmark parameters for microwave links (e.g., 1 MHz, 90% fidelity) and optimistic optical links (e.g., 1 kHz, 80–90% fidelity).
Physical Bell-Pair Distillation (Step II): To mitigate noise, the study evaluates cascaded distillation protocols (e.g., Z2B, ZX3B, [[5,1,3]]) to improve fidelity at the cost of generation rate. The analysis incorporates waiting-time decoherence using Monte Carlo simulations to determine practical throughput limits, particularly for low-rate links.
Logical Bell-Pair Generation (Step III): The framework compares two methods for generating logical Bell pairs from physical ones: Lattice Surgery (requiring high-rate, high-fidelity links and extensive multiplexing) and State Injection (more robust to lower rates and fidelities but producing noisier initial logical states).
Logical Bell-Pair Distillation (Step IV): For injection-based schemes, logical distillation is analyzed to achieve target error rates ( $\le 10^{-12}$ ). The authors model both sequential (single-channel) and parallel (multi-channel) distillation architectures, accounting for memory errors and code distance optimization.
Algorithm Execution (Step V): The estimated logical entanglement resources are integrated into a distributed FTQC simulator. The authors compile and execute benchmark subroutines (SELECT, PREPARE, ADDER) relevant to factoring and ground-state energy estimation across various network topologies (circle, mesh, tree, full) and node counts. They optimize code distance to meet failure probability thresholds and calculate total execution time and physical qubit counts.

Key Contributions and Results

Single-Channel Feasibility: The analysis demonstrates that distributed FTQC is feasible even with a single physical communication channel per node. Under forward-looking microwave-link assumptions (1 MHz generation rate, 90% fidelity), distributing a computation across $\sim 10$ nodes can reduce the required physical qubit count per node by approximately an order of magnitude (e.g., from $\sim 10^5$ to $\sim 10^4$ ).
Time-Resource Trade-off: This reduction in hardware size comes with a significant cost in execution time. Under the single-channel microwave scenario, the execution time increases by roughly a factor of 10 compared to a single-node monolithic system.
Optical Link Limitations: For optical links with lower generation rates (1 kHz), physical Bell-pair distillation becomes impractical due to waiting-time decoherence unless generation rates exceed $\sim 100$ kHz. Consequently, achieving useful logical rates with optical links requires extensive multiplexing (hundreds of channels) or accepting very low logical generation rates.
Distillation Overhead: Logical Bell-pair distillation units impose a practical lower bound on the physical qubit count per node, requiring approximately $10^4$ physical qubits. While this limits how small a node can be, the distillation overhead remains manageable (up to $\sim 50\%$ of total resources) when nodes are sized in the $10^4$ – $10^5$ qubit range.
Backward Requirements: To reduce the execution-time overhead to a factor of 1–3 (near-monolithic performance), the system requires logical Bell-pair generation rates of $\sim 4$ kHz. Achieving this with a single channel demands extremely high physical link performance (1 MHz rate, 99% fidelity). Alternatively, using injection-distillation with 1 MHz/90% links requires multiplexing over $\sim 100$ parallel channels.

Significance
The paper provides a quantitative basis for balancing quantum-link performance, processor size, and execution time in distributed FTQC. It establishes that while distributed architectures can significantly relax the physical qubit constraints of individual nodes (making million-qubit scale computations more feasible in terms of wiring and cooling), they introduce substantial execution-time penalties unless communication resources (rate, fidelity, and multiplexing) are significantly advanced. The work bridges the gap between quantum communication hardware capabilities and algorithm-level resource requirements, offering specific targets for quantum interconnect development to enable practical distributed fault-tolerant quantum computing.

More like this