Distributed Quantum Computing with Slow Interconnects

Evan E. Dobbs of Aalto University, alongside Nicolas Delfosse and Aharon Brodutch of IonQ Inc., have demonstrated that connecting multiple quantum processing units (QPUs) through slow interconnects can surpass the performance of a monolithic architecture. Their work establishes that links producing O(t/ln t) Bell pairs in parallel—where ‘t’ represents the number of QPUs—are sufficient to avoid stalling the distributed CliNR partial error correction scheme. This finding indicates a potential pathway toward near-term multi-QPU devices and envisions a distributed quantum superiority experiment utilizing conjugated Clifford circuits implemented with distributed CliNR, even with entanglement generation times up to five times longer than the gate time.

Distributed Quantum Computing with Slow Interconnects

Distributed quantum computing can outperform monolithic architectures even with slow interconnects. The research focuses on a model where each quantum processing unit (QPU) is linked to only two others, generating one Bell pair at a time, and where Bell pair generation takes up to five times longer than a single QPU’s gate time. This “slow interconnects” model investigates whether connecting multiple QPUs with these limitations offers any advantage over a single, larger QPU, a key question given current limitations in quantum interconnect speeds.

The study proposes a distributed version of the CliNR partial error correction scheme, designed for Clifford circuits, to exploit the potential of this architecture. By distributing resource state preparation and verification across QPUs, the scheme aims to reduce circuit depth and noise. Crucially, the design minimizes entanglement consumption during state injection, allowing a large fraction of required Bell pairs to be pre-prepared, thus avoiding stalls caused by slow interconnects and enabling a potential performance boost.

Simulations with 85-qubit random Clifford circuits distributed across four modules demonstrate that this distributed CliNR scheme achieves both a lower logical error rate and a shorter circuit depth compared to both direct implementation and monolithic CliNR. Furthermore, in an asymptotic regime allowing more parallel links, the research proves that O(T/ln T) parallel links per connection are sufficient to prevent stalling, even as the number of QPUs (T) increases, suggesting scalability for near-term devices.

Model Assumptions for QPU Connectivity

The study introduces a model for distributed quantum computing based on specific assumptions regarding QPU connectivity. Each QPU is linked to only two others, with each link capable of producing one Bell pair at a time. Crucially, the time to generate a Bell pair (τe) is considered to be up to 15 times longer than the gate time of a single QPU. This “slow interconnects” model aims to determine if a distributed architecture can outperform a single, monolithic QPU despite these limitations in entanglement generation speed.

This research focuses on a distributed version of the CliNR error correction scheme. The design utilizes a circular network of QPUs, adhering to the connectivity and speed constraints. A key advantage of this approach is that resource state preparation and verification can be parallelized, reducing the overall circuit depth and noise accumulation. The model proposes that a significant portion of the required Bell pairs can be prepared before state injection, preventing stalling due to entanglement availability.

In an asymptotic analysis, the researchers relaxed the constraint of only one Bell pair produced per link. They proved that, for uniform distribution across T QPUs, a circular network with O(T/ ln T) parallel links per connection is sufficient to implement distributed CliNR without delays. Numerical simulations, using 85 qubits distributed over four modules, demonstrate that this distributed CliNR achieves a lower logical error rate and shorter depth than both direct implementation and monolithic CliNR.

Entanglement Generation and Gate Time Ratio

The primary bottleneck in distributed quantum computing is the rate of entanglement production between quantum processing units (QPUs). Research focuses on a model where each QPU connects to only two others, producing one Bell pair at a time. The time to generate a Bell pair (τe) is a critical factor, potentially being up to five times longer than the gate time of a single QPU. Despite these limitations, simulations demonstrate that a distributed approach can outperform a monolithic architecture, achieving lower logical error rates and shorter circuit depths.

Researchers propose a distributed version of the CliNR partial error correction scheme to leverage this potential. This scheme utilizes a circular network of QPUs, where resource state preparation and verification are performed in parallel. This parallelization reduces circuit depth and noise accumulation, however, slow entanglement generation could still stall the process. The key is that distributed CliNR only consumes n Bell pairs per link, potentially allowing for pre-preparation during resource state tasks.

In an asymptotic regime, allowing more parallel links between QPUs—specifically O(T/ ln T) links, where T is the number of QPUs—avoids stalling the distributed CliNR scheme. This means that for uniformly distributed Clifford circuits, a circular network with this link capacity is sufficient to implement distributed CliNR without delays due to entanglement availability, even as the number of QPUs grows.

CliNR Scheme for Error Reduction

The research introduces a distributed version of the CliNR partial error correction scheme designed for quantum computers built with multiple interconnected QPUs. This approach splits Clifford circuits into subcircuits, implementing each on a different QPU via state injection. Resource states for each subcircuit are prepared and verified in parallel, reducing circuit depth and noise accumulation. The key is leveraging this parallel preparation to minimize reliance on potentially slow entanglement generation between QPUs during state injection.

This distributed CliNR scheme is specifically designed to function effectively with “slow interconnects” – a model where each QPU links to only two others, and each link generates only one Bell pair at a time. Simulations using 85-qubit random Clifford circuits distributed over four modules demonstrate that this scheme achieves both a lower logical error rate and shorter circuit depth compared to direct implementation or monolithic CliNR. This suggests an advantage can be realized even with limited interconnect speeds.

In an asymptotic regime, the research proves that scaling the number of parallel links between QPUs to O(T/ ln T) – where T is the number of QPUs – is sufficient to avoid stalling distributed CliNR, regardless of the number of qubits per QPU. This finding highlights the potential for distributed CliNR in near-term multi-QPU devices and suggests a path toward a quantum superiority experiment using conjugated Clifford circuits.

Distributed CliNR Implementation Details

The research focuses on a distributed quantum computing model designed for slow interconnects. This model assumes each quantum processing unit (QPU) is linked to only two others, and each link generates one Bell pair at a time. Crucially, the time to generate a Bell pair (τe) is considered up to five times longer than the gate time. This setup explores whether connecting multiple QPUs with slower connections can still outperform a single, monolithic QPU, particularly when using the CliNR partial error correction scheme.

A distributed version of the CliNR scheme is proposed, leveraging parallel resource state preparation and verification on different QPUs. This approach aims to reduce circuit depth and noise accumulation. The key is minimizing entanglement consumption during state injection; the structure allows for a large fraction of required Bell pairs to be prepared before injection, preventing stalls. Simulations with 85 qubits distributed across four modules demonstrate that distributed CliNR achieves a lower logical error rate and shorter depth than direct or monolithic implementations.

In an asymptotic regime, allowing more parallel links—specifically O(T/ln T) per connection, where T is the number of QPUs—avoids stalling the distributed CliNR implementation. This suggests that even with increasing numbers of QPUs, a relatively small increase in parallel link capacity can maintain performance. The research demonstrates the potential for distributed quantum superiority experiments utilizing conjugated Clifford circuits implemented with this distributed CliNR approach.

State Injection and Resource State Preparation

The research introduces a distributed quantum computing model addressing slow interconnects, specifically focusing on a CliNR (partial error correction) scheme. This approach splits Clifford circuits into subcircuits, implementing each via “state injection.” Crucially, resource states for each subcircuit are prepared and verified on different QPUs in parallel, reducing overall depth and noise. The model assumes each QPU links to only two others, generates one Bell pair at a time, and that Bell pair generation takes τe times longer than the gate time.

A key finding is that distributed CliNR can outperform both direct implementation and monolithic CliNR, achieving a lower logical error rate and shorter depth in simulations with 85 qubits distributed across four modules. The success hinges on preparing resource states in parallel, minimizing delays. The state injection process itself consumes only ‘n’ Bell pairs per link in a circular network, enabling a large portion of required entanglement to be prepared during resource state preparation, thus avoiding stalls.

In an asymptotic regime, allowing more parallel links, the research proves that O(T/ ln T) parallel links per connection are sufficient for distributed CliNR, where T is the number of QPUs. This means that, for uniformly distributed Clifford circuits, a relatively small increase in link capacity allows the system to function without entanglement-related delays, demonstrating the potential for scalability and highlighting a path toward multi-QPU devices even with slow interconnects.

Simulation of Distributed vs. Monolithic CliNR

Researchers investigated whether connecting multiple quantum processing units (QPUs) with slow interconnects could outperform a single, monolithic QPU. Their model assumes each QPU links to only two others, generating one Bell pair at a time, with Bell pair generation taking up to five times longer than a single QPU gate. This study focuses on a “slow interconnects” scenario, limiting links and parallel generation, even as the number of qubits per QPU grows, to realistically model current quantum interconnect technology.

The team proposed and simulated a distributed version of the CliNR partial error correction scheme. This scheme splits Clifford circuits into subcircuits, preparing resource states on different QPUs in parallel, reducing depth and noise. Crucially, the structural design of distributed CliNR minimizes entanglement consumption during state injection, enabling the system to avoid stalling even with slow interconnects.

Simulations using 85-qubit random Clifford circuits distributed across four QPUs demonstrated that distributed CliNR achieves both a lower logical error rate and shorter circuit depth compared to direct implementation and monolithic CliNR. Furthermore, relaxing the limitation on parallel links, the team proved that O(T/ln T) parallel links per connection are sufficient to implement distributed CliNR without entanglement-related delays, where T is the number of QPUs.

Asymptotic Behavior with Parallel Links

In a distributed quantum computing model, researchers investigated the potential of connecting multiple Quantum Processing Units (QPUs) despite slow interconnects. Their model assumes each QPU links to only two others, generates one Bell pair at a time, and has an entanglement generation time up to fifteen times longer than the gate time. Numerical simulations using an 85-qubit Clifford circuit distributed over four modules demonstrate that this distributed approach can achieve a lower logical error rate and shorter depth compared to direct or monolithic implementations.

The team focused on a distributed version of the CliNR partial error correction scheme, utilizing a circular network of QPUs. A key advantage lies in parallelizing resource state preparation and verification, reducing overall depth and noise. Importantly, the structure of distributed CliNR minimizes entanglement consumption, allowing a significant portion of required Bell pairs to be prepared before state injection, thus preventing stalling due to slow interconnects.

In the asymptotic regime, relaxing the limitation of one Bell pair per link, the research proves that O(T/ ln T) parallel links per connection are sufficient to implement distributed CliNR without delay, where T represents the number of QPUs. This finding is crucial as it suggests scalability for near-term multi-QPU devices and opens possibilities for quantum superiority experiments using conjugated Clifford circuits.

Scaling Entanglement with Number of QPUs

The primary bottleneck in distributed quantum computing is the speed of entanglement production between quantum processing units (QPUs). Research demonstrates that even with slow interconnects – where generating a Bell pair takes up to fifteen times longer than a single QPU’s gate time – a distributed architecture can outperform a monolithic system. This is achieved using a distributed version of the CliNR partial error correction scheme, designed for circuits distributed across multiple QPUs linked by only two connections each.

Numerical simulations using 85-qubit random Clifford circuits distributed across four QPUs show that this distributed CliNR achieves both a lower logical error rate and shorter circuit depth compared to direct implementation or monolithic CliNR. The key lies in parallelizing resource state preparation and verification, reducing the need for entanglement during these stages. This minimizes potential delays caused by slow entanglement generation between QPUs.

In an asymptotic analysis, the research indicates that scaling entanglement production is manageable. Specifically, a circular network with O(T/ ln T) parallel links – where T represents the number of QPUs – is sufficient to avoid stalling distributed CliNR, regardless of the number of qubits per QPU. This suggests a viable pathway towards building large-scale quantum computers composed of interconnected QPUs.

Advantages of Distributed Architecture

A distributed quantum computing architecture can outperform a monolithic design even with slow interconnects. Simulations demonstrate that a distributed version of the CliNR partial error correction scheme achieves a lower logical error rate and shorter depth compared to both direct implementation and monolithic CliNR—even when Bell pair generation takes up to five times longer than a single QPU’s gate time. This advantage stems from parallelizing resource state preparation and verification across multiple QPUs.

The proposed model for distributed computing operates under specific constraints: each QPU links to only two others, each link generates one Bell pair at a time, and the time to generate a Bell pair (τe) is up to 15 times longer than the gate time. Despite these limitations—described as “slow interconnects”—the distributed CliNR scheme is effective because state injection consumes a limited number of Bell pairs per link, allowing much of the required entanglement to be prepared before state injection begins, avoiding stalls.

In an asymptotic regime, allowing parallel links between QPUs, the study proves that O(T/ln T) parallel links – where T is the number of QPUs – is sufficient to implement distributed CliNR without delays due to entanglement availability. Simulations using 85 qubits distributed across four modules show the advantage, suggesting that distributed quantum computing with CliNR is a viable path toward building larger quantum computers with potentially millions of qubits.