Distributed Quantum Error Correction with Bivariate Bicycle Codes in a Modular Architecture

This paper proposes and analyzes a modular, distributed architecture for implementing bivariate bicycle quantum error correction codes across interconnected processors with all-to-all internal connectivity, demonstrating through Monte Carlo simulations that such a setup can achieve competitive fault tolerance thresholds despite the noise introduced by nonlocal operations.

The Gist

Imagine you are trying to solve a massive, incredibly complex puzzle. In the world of quantum computing, this puzzle is a "quantum code" designed to protect fragile information from errors. The specific puzzle the authors are studying is called a Bivariate Bicycle (BB) code.

Think of this BB code as a giant, intricate web of strings connecting hundreds of tiny beads (qubits). If one bead wobbles or breaks, the web has a special way of detecting it and fixing it without ruining the whole picture. This specific web is very efficient—it holds a lot of information compared to older designs—but it has a catch: the strings connect beads that are far apart, not just their immediate neighbors.

The Problem: The "All-in-One" vs. The "Team"

Traditionally, to build this web, you'd need one giant, super-connected machine (a monolithic device) where every bead can talk to every other bead directly. But building a machine that big and that connected is incredibly hard with current technology. It's like trying to build a single city where every house is connected by a private tunnel to every other house; the construction costs and traffic jams would be impossible.

So, the authors ask: What if we split this giant web across several smaller, separate machines (called Quantum Processing Units or QPUs) and connect them like a team?

The Solution: The Star Network

The authors propose a "Star Network" architecture. Imagine a central hub (like a switchboard) with several smaller offices (the QPUs) connected to it.

• Inside an office: The workers (qubits) can talk to each other instantly and perfectly.
• Between offices: To talk, they have to send a message through the central hub. This is like sending a letter via a post office. It takes more time and is more prone to getting lost or corrupted.

In quantum terms, the "letters" are entangled pairs (Bell pairs). When two qubits in different offices need to interact, they use these entangled pairs to perform a "remote" operation.

The Experiment: Splitting the Web

The authors took their giant [[144, 12, 12]] BB code (which has 144 physical beads) and sliced it up in three different ways:

1. 4 Offices: Each office gets a big chunk of the web.
2. 6 Offices: The web is cut into medium chunks.
3. 12 Offices: The web is cut into tiny, thin strips.

They then ran thousands of computer simulations (like running a video game millions of times to test a strategy) to see how well the code held up under different conditions.

The Variable: The "Noise Penalty"

Here is the key variable they tested: How bad is the connection between offices?

• They assigned a "noise penalty" factor, called $\alpha$ (alpha).
• If $\alpha = 1$, the connection between offices is just as good as the connection inside an office (perfect scenario).
• If $\alpha = 7$, the connection between offices is 7 times more likely to fail than the connection inside an office.

They wanted to see: Does splitting the web into more offices make it more fragile, especially if the connections between offices are noisy?

The Findings: The Trade-off

The results revealed a clear trade-off, like balancing on a seesaw:

1. More Offices = More Fragility (when connections are bad):
   When they split the code into 12 offices, they had to use the "remote letter" system (entanglement) much more often. If the connection between offices was noisy (high $\alpha$), the whole system broke down much faster. The "safety threshold" (the point where the code stops working) dropped significantly.

2. Fewer Offices = More Robustness:
   When they split the code into just 4 offices, the workers had to send fewer "letters" to each other. Even if the connections were noisy, the system held up better. It was more tolerant of bad connections because it relied less on them.

3. The "Sweet Spot":
   If the connections between offices were perfect ($\alpha=1$), it didn't matter much how they split the code; all versions performed similarly. But as soon as the connections got a little noisy, the version with fewer offices (4 QPUs) became the clear winner.

The Analogy: The Orchestra

Imagine an orchestra playing a complex symphony (the quantum code).

• Monolithic: All musicians are on one stage, hearing each other perfectly.
• Distributed (4 QPUs): The orchestra is split into 4 small rooms. Musicians in the same room hear each other perfectly. Musicians in different rooms hear each other through a slightly crackly intercom.
• Distributed (12 QPUs): The orchestra is split into 12 tiny rooms. Now, almost every musician has to rely on the crackly intercom to stay in sync with someone else.

The paper found that if the intercom is a bit noisy, having 12 rooms makes the music fall apart quickly. Having only 4 rooms keeps the music in tune much longer, even with the crackly intercom.

Conclusion

The paper concludes that while splitting quantum computers into smaller modules is necessary for building large-scale machines, you have to be careful how you slice the pie. If the connections between the modules aren't perfect, it's better to have fewer, larger modules than many tiny ones. The more you rely on "remote" connections, the more noise hurts your ability to keep the quantum information safe.

They also created a new mathematical formula (an "ansatz") to predict exactly how much the performance would drop based on how noisy the connections are, helping engineers design better future quantum computers.

Technical Summary

Technical Summary: Distributed Quantum Error Correction with Bivariate Bicycle Codes in a Modular Architecture

Problem Statement
Quantum low-density parity-check (qLDPC) codes, specifically bivariate bicycle (BB) codes, offer competitive fault-tolerance thresholds and higher encoding rates compared to planar surface codes. However, their implementation on monolithic hardware is hindered by intrinsically long-range stabilizer structures that require non-local interactions, increasing routing overhead and circuit depth. While modular quantum architectures (interconnected quantum processing units or QPUs) offer a path to scalability, they introduce additional noise through imperfect interconnects and non-local gate operations. The central problem addressed is determining how partitioning a BB code across multiple QPUs and the associated noise from non-local operations jointly affect the code's logical error rates and pseudo-threshold performance.

Methodology
The authors investigate the distributed realization of the [[144, 12, 12]] BB code across a modular architecture. The study employs the following methodological framework:

• Architecture: A star network topology is proposed where multiple QPUs are connected via a central quantum switch. Each QPU possesses all-to-all internal connectivity (feasible on trapped-ion or neutral-atom platforms) and utilizes communication qubits to generate shared Bell pairs for non-local operations.
• Code Partitioning: The [[144, 12, 12]] code, defined on a $12 \times 6$ torus, is partitioned into 4, 6, and 12 QPUs. The partitioning strategy divides the 12 $x$-columns of the torus into contiguous vertical strips assigned to each QPU.
• Noise Modeling: A circuit-level noise model is established where local gates (within a QPU) have a baseline error rate $p$. Non-local gates (between QPUs), mediated by entanglement swapping and Bell-state measurements, are assigned an elevated error rate $p_{NL} = \alpha p$, where $\alpha \in \{1, 3, 5, 7\}$ represents a scaling factor for the cumulative noise penalty of non-local operations.
• Simulation and Decoding: Monte Carlo simulations are performed over 12 syndrome-extraction cycles using BP+OSD (Belief Propagation with Ordered Statistics Decoding) to decode logical errors. The simulations distinguish between local and non-local CNOT gates based on the partition map.
• Analytical Extension: To characterize the threshold behavior under varying noise conditions, the authors extend the standard BB code ansatz. They introduce a quadratic $\alpha$-dependent model where the fitting coefficients ($c_0, c_1, c_2$) vary as functions of $\alpha$, while the leading power-law exponent (determined by the circuit distance) remains fixed.

Key Contributions

1. Distributed Implementation Framework: The paper describes a specific star-network architecture and partitioning scheme for realizing the [[144, 12, 12]] BB code across 4, 6, and 12 QPUs, explicitly defining the mapping of qubits and the classification of local vs. non-local gates.
2. Noise-Aware Modeling: A circuit-level noise model is defined that explicitly scales the error rate of non-local gates by a factor $\alpha$, allowing for the systematic study of interconnect imperfections.
3. Modified Ansätze: The authors propose a modified ansatz that extends the baseline BB-code threshold analysis to the distributed setting. This quadratic $\alpha$-dependent model enables the extrapolation of logical error rates to lower physical error rates and the calculation of pseudo-thresholds across different noise scalings.
4. Performance Characterization: Through extensive Monte Carlo simulations, the study quantifies the trade-off between the number of partitions (modularity) and the noise penalty of non-local operations.

Results

• Threshold Degradation: The pseudo-threshold ($p_0$) decreases monotonically as the non-local noise scaling factor $\alpha$ increases for all partition sizes (4, 6, and 12 QPUs). For instance, in the 12-QPU configuration, the pseudo-threshold drops from approximately $0.0063$ at $\alpha=1$ to $0.0017$ at $\alpha=7$.
• Partition Sensitivity: While all partitions degrade with higher $\alpha$, the impact is more severe for finer partitions. The 12-QPU partition (requiring the most inter-QPU communication) exhibits the lowest pseudo-thresholds for $\alpha \geq 3$. Conversely, the 4-QPU partition consistently yields the highest pseudo-thresholds under high non-local noise conditions.
• Baseline Agreement: At $\alpha=1$ (no non-local penalty), the simulated pseudo-thresholds for all partitions align closely with previously reported values for the monolithic [[144, 12, 12]] code ($\approx 0.0065$), validating the simulation framework.
• Fitting Accuracy: The proposed quadratic $\alpha$-dependent ansatz provides a high-fidelity fit to the simulation data, with $R^2$ values consistently close to unity across the tested range of $\alpha$ and $p$.

Significance and Claims
The paper claims to provide architectural insights and design considerations for implementing high-rate qLDPC codes in modular quantum computing environments. The primary finding is that while modularity is necessary for scalability, it introduces a "scalability-threshold trade-off." Specifically, increasing the number of partitions to accommodate more QPUs increases the frequency of non-local gates, which significantly lowers the fault-tolerance threshold if interconnect noise is not sufficiently suppressed.

The authors modestly conclude that their results highlight the necessity of improving quantum interconnects (reducing $\alpha$) to mitigate the performance penalty of distributed BB codes. They suggest that coarser partitioning (fewer QPUs) may be more favorable in the near term if non-local gate fidelities remain low. The work does not claim to solve the distributed error correction problem entirely but rather establishes a quantitative framework for evaluating the viability of BB codes in modular settings, identifying the specific noise levels at which modularity becomes detrimental to logical performance. Future work is suggested to explore correlated errors, hook errors, and optimized qubit placement strategies.