Networked Realization of Quantum LDPC Codes

This paper proposes and evaluates the networked implementation of quantum low-density parity-check codes, specifically bivariate bicycle codes, demonstrating through circuit-level simulations that they can achieve competitive fault-tolerant performance despite the challenges of long-range connectivity and imperfect entanglement.

The Gist

Imagine you are trying to build a massive, incredibly complex puzzle. In the world of quantum computing, this puzzle is a "code" designed to protect fragile information from noise and errors.

For a long time, scientists have tried to build these puzzles on a single, giant table (a monolithic processor). However, the best puzzles (called QLDPC codes) have pieces that need to be connected to other pieces that are very far away. Trying to stretch wires across a single giant table to connect these distant pieces is like trying to build a bridge across a canyon with a single strand of spaghetti—it's physically difficult and prone to breaking.

This paper proposes a different way to build the puzzle: The Networked Approach. Instead of one giant table, imagine building the puzzle across several smaller tables (nodes) that are connected by high-speed, magical delivery trucks (quantum networks).

Here is a breakdown of what the authors did, using simple analogies:

1. The Two Types of Puzzles

The paper studies two specific types of quantum puzzles:

• Surface Codes: These are like a standard grid. Every piece only needs to talk to its immediate neighbors. They are easy to build on one table, but they require a huge number of pieces to store just a little bit of information.
• Bivariate Bicycle (BB) Codes: These are the "super puzzles." They are much more efficient (you get more storage for fewer pieces), but they have a catch: some pieces need to talk to pieces that are far away. This is why the authors think splitting them across a network is a great idea.

2. The "Teleportation" Trick

When a puzzle piece on Table A needs to talk to a piece on Table B, they can't just reach out and touch. They have to use a Teleported CNOT.

• The Analogy: Imagine two people on different islands who need to pass a secret note. They can't swim. Instead, they use a pre-prepared "magic rope" (a Bell pair) that connects them. They pull the rope to send the message instantly.
• The Catch: If the magic rope is frayed or weak (low fidelity), the message gets garbled. The paper tests how strong these ropes need to be for the puzzle to still work.

3. How They Tested It

The authors didn't build a real quantum computer. Instead, they built a super-accurate video game simulation called Stim.

• Step 1 (The Warm-up): They first recreated the "Surface Code" puzzle on their network. They wanted to see if the old theories held up when they simulated every tiny error (like a glitch in the game) rather than just guessing the average. They found that yes, the network works, but the "magic ropes" (Bell pairs) need to be very high quality.
• Step 2 (The Main Event): They then took the efficient "Bivariate Bicycle" codes and cut them in half, putting one half on Node A and the other on Node B.
  • They used a smart algorithm (like a traffic planner) to decide which pieces go on which table, trying to keep the number of "magic ropes" needed to a minimum.
  • They simulated the puzzle running with different qualities of magic ropes.

4. The Results

The simulation revealed a very clear "Goldilocks" zone:

• The Good News: If the magic ropes are very strong (about 99% perfect), the networked puzzle works almost as well as if it were all on one giant table. The "super puzzles" (BB codes) still offer their efficiency benefits.
• The Bad News: If the magic ropes are even slightly weaker (dropping to 96% perfect), the puzzle starts to fall apart. The errors introduced by the weak connections overwhelm the benefits of the efficient code.
• The Threshold: The authors found that for this networked approach to be useful, the connection between the nodes must be incredibly reliable. If the connection is too noisy, it's better to just keep the whole puzzle on one table (if you can manage the wiring).

5. The Bottom Line

This paper is a "stress test" for a new way of building quantum computers.

• The Idea: Splitting complex codes across multiple small computers connected by a network is a promising way to build better quantum computers.
• The Reality Check: It only works if the network connections are nearly perfect. The authors showed that you can't just use "okay" connections; you need "excellent" connections, or the whole system fails.

In short, the paper says: "We can split the best quantum puzzles across multiple computers, but only if the internet connecting them is perfect. If the connection is shaky, the puzzle breaks."

Technical Summary

1. Problem Statement

Quantum Low-Density Parity-Check (QLDPC) codes, such as Bivariate Bicycle (BB) codes, offer superior encoding rates and lower qubit overhead compared to traditional topological codes like the surface code. However, their stabilizers often require non-local, long-range connections between qubits, which are difficult to engineer in a single monolithic quantum processor.

While networked quantum computing (interconnecting multiple smaller modules) offers a solution to bypass these connectivity constraints, it introduces significant challenges:

• Non-local Syndrome Extraction: Stabilizer measurements spanning multiple nodes require shared entanglement (Bell pairs) and teleportation, which are noisy and slower than local gates.
• Lack of Systematic Study: Prior work on networked architectures focused primarily on surface codes (which are geometrically local and thus less dependent on networking) or assumed idealized noise models. There is a critical gap in understanding the circuit-level noise performance of networked QLDPC codes, specifically how Bell pair fidelity impacts logical error rates.

2. Methodology

The authors developed a comprehensive simulation framework using the Stim stabilizer-circuit simulator to model fault-tolerant quantum computing at the circuit level. Their approach involved two main stages:

A. Baseline Validation: Networked Surface Codes

• Reproduction: They recreated the networked surface code architecture proposed by Nickerson et al. [1], where each node holds one data qubit and ancilla qubits.
• Noise Modeling: Unlike previous superoperator-based analyses, they implemented a full circuit-level noise model. This includes:
  • Stochastic depolarizing errors on gates, resets, and measurements.
  • Specific noise modeling for GHZ state generation (used for syndrome extraction across nodes), treating the infidelity of the GHZ state as a distinct noise source.
• Decoding: Used PyMatching (Sparse Blossom algorithm) for decoding surface code syndromes.

B. Novel Contribution: Networked Bivariate Bicycle (BB) Codes

• Architecture: Instead of placing an entire BB code in one module, they partitioned a single BB code across two networked nodes.
• Graph Partitioning:
  • Constructed a combined X-Z Tanner graph representing both X-type and Z-type stabilizers and data qubits.
  • Applied a balanced min-cut algorithm (using pymetis) to split the graph into two partitions of roughly equal size.
  • Objective: Minimize "bridge edges" (stabilizers straddling the two nodes) to reduce the number of required inter-node entangling operations.
• Teleported Operations:
  • Local Stabilizers: Implemented via standard local CNOTs.
  • Cross-Partition Stabilizers: Implemented using teleported CNOTs. These consume a pre-shared Bell pair and rely on local operations + classical communication.
  • Noise Parameterization: The quality of the Bell pair is parameterized by fidelity ($F_{Bell}$), which directly dictates the error rate of the teleported CNOT.
• Decoding: Used Belief Propagation with Ordered Statistics Decoding (BP-OSD), which is better suited for the non-local structure of QLDPC codes than matching-based decoders.

3. Key Contributions

1. Circuit-Level Validation of Networked Surface Codes: The authors provided the first circuit-level noise simulation of the Nickerson et al. protocol. They confirmed that the theoretical thresholds hold under realistic circuit noise and identified a specific GHZ noise threshold (~1.5%) required for fault tolerance.
2. First Networked QLDPC Analysis: They introduced a novel framework for partitioning QLDPC codes (specifically BB codes) across network nodes, moving beyond the assumption that codes must reside entirely within a single monolithic chip.
3. Quantitative Trade-off Analysis: They established a direct relationship between Bell pair fidelity and logical error rates for networked QLDPC codes.
4. Optimization Strategy: Demonstrated that balanced min-cut partitioning on the combined Tanner graph is an effective method to minimize the entanglement overhead (number of Bell pairs) required for syndrome extraction.

4. Key Results

• Surface Code Thresholds:
  • The networked surface code maintains a threshold of ~0.75% for intra-node gate errors, consistent with prior theoretical estimates.
  • The GHZ state preparation must have an infidelity below ~1.5% ($p_{err} \approx 1.5\%$) to maintain fault tolerance.
• BB Code Performance:
  • Threshold: For networked BB codes (split across two nodes), a local gate noise threshold of ~1% exists.
  • Bell Pair Fidelity Requirement: To match the performance of a monolithic implementation, the Bell pair fidelity must be at least 99% ($p_{Bell} \le 0.0125$).
  • Degradation: If Bell pair fidelity drops to 96% ($p_{Bell} = 0.05$), the logical error rate degrades significantly, causing the partitioned code to lose its advantage over the uncoded baseline near physical error rates of $10^{-3}$.
  • Scaling: Higher-distance BB codes (e.g., [[144, 12, 12]]) show superior error suppression in the sub-threshold regime but are highly sensitive to the quality of the inter-node link.

5. Significance and Outlook

• Hardware Implications: The study provides concrete engineering targets for networked quantum architectures. It suggests that while networking is essential for implementing high-performance QLDPC codes on modular hardware, the quality of the quantum interconnect (Bell pairs) is the bottleneck. Fidelity must exceed 99% to make the networked approach competitive.
• Scalability: The work proves that QLDPC codes can be distributed across modules without losing their error-correction advantages, provided the network overhead is managed via efficient graph partitioning and high-fidelity entanglement.
• Future Directions: The authors identify open questions regarding:
  • Scaling the partitioning to more than two nodes.
  • Optimizing Bell pair purification schedules to match syndrome measurement cycles.
  • Implementing logical gates (e.g., fold-transversal gates) in a distributed setting.
  • Extending these findings to other advanced QLDPC families like Hypergraph Product and Lifted Product codes.

In conclusion, this paper bridges the gap between theoretical QLDPC code design and practical networked hardware implementation, demonstrating that while networked QLDPC codes are feasible, their success is critically dependent on the fidelity of the shared entanglement resources.