⚛️ quantum physics

Towards the Characterization of Logical Errors in Distributed Lattice Surgery

This paper analyzes logical errors in distributed lattice surgery under heterogeneous noise conditions by characterizing the XX merge operation between rotated surface-code patches, deriving distinct bulk and seam error rates to estimate thresholds via a minimum-weight perfect matching decoder, and providing practical guidelines for optimizing surface-code distance and gate fidelities in distributed quantum architectures.

Original authors: Nitish Kumar Chandra, Reza Nejabati, Eneet Kaur

Published 2026-08-03

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Nitish Kumar Chandra, Reza Nejabati, Eneet Kaur

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

Imagine you are trying to build a super-computer out of tiny, fragile glass marbles. These marbles are "qubits," the building blocks of quantum computers. They are incredibly powerful but also incredibly sensitive; a single sneeze of heat or a tiny vibration can shatter their delicate state, causing the calculation to fail. This is the current reality of quantum computing: we have a few hundred marbles, but they are so noisy that we can't do much with them before they break.

To build a truly useful machine, scientists need to connect thousands of these marbles together. But here's the catch: trying to put all those marbles on one single chip is like trying to fit a whole city's traffic into one tiny parking lot. It's too crowded, and the marbles start bumping into each other in bad ways. So, researchers have a new idea: instead of one giant chip, let's build many small, manageable "modules" and connect them with invisible, magical threads called "entangled pairs." Think of these threads as a super-secure, instant telephone line between two distant rooms. If you whisper a secret into one end, the other end hears it instantly, no matter how far apart they are. This is the dream of "distributed quantum computing."

However, there's a problem. Those magical threads are harder to make than the marbles themselves. They are often "noisier," meaning the connection isn't perfect and introduces errors. The big question is: Can we build a fault-tolerant computer using these noisy threads, or will the noise ruin everything? This is the puzzle a team of researchers set out to solve.

The Great Quantum Bridge-Building Experiment

In this study, the researchers acted like architects testing a new way to build a bridge between two islands. The "islands" are two separate quantum computers (modules), and the "bridge" is a process called lattice surgery.

In the world of quantum error correction, the "surface code" is like a safety net woven from data. To perform a calculation, you sometimes need to merge two separate safety nets into one big net, do some work, and then split them back apart. This merging process is called a "merge operation." In a standard, single-chip computer, this is easy because the nets are right next to each other. But in our distributed dream, the nets are on different islands. To merge them, you have to use those noisy "entangled threads" to create a temporary bridge.

The researchers wanted to know: How much noise can that bridge handle before the whole calculation collapses?

The Setup: A Noisy Bridge

To test this, the team created a detailed simulation. They imagined two quantum processors, each holding a patch of a surface code. They then tried to merge these patches using a "bridge" made of entangled pairs.

They knew that the bridge would be noisier than the rest of the computer. To model this, they introduced a "noise multiplier," which they called $k$ .

If $k = 1$ , the bridge is just as clean as the rest of the computer.
If $k = 11$ , the bridge is 11 times noisier than the rest of the system.

They ran millions of simulations (200,000 "shots" for each test) to see how often the logical calculation failed as they made the bridge noisier and noisier. They looked at different sizes of the safety nets (called "distances," ranging from 5 to 13) to see if bigger nets could handle the noise better.

The Findings: The Bridge is Tougher Than We Thought

The results were surprisingly optimistic. The researchers found that even when they made the entangled bridge 11 times noisier than the local parts of the computer, the system didn't fall apart.

Here is what they discovered:

The Threshold: In quantum computing, there is a "threshold" of noise. If the noise is below this line, the error correction works and the computer can run forever. If it's above, the errors pile up faster than they can be fixed.
The Numbers: When the bridge was perfect ( $k=1$ ), the system could tolerate a physical error rate of about 0.8683%. When they cranked the bridge noise up to be 11 times worse ( $k=11$ ), the threshold only dropped slightly to 0.8339%.
The Takeaway: That's a drop of only about 0.034%. Even with a bridge that is significantly noisier than the rest of the machine, the system remains stable.

Why Does This Happen?

The researchers explain this using a simple geometric idea. Imagine the safety net as a large field. The "bridge" is just a thin line where the two nets meet.

The bulk (the main field) has a huge number of qubits (proportional to the square of the size, or $d^2$ ).
The seam (the bridge) has far fewer qubits (proportional to the size, or $d$ ).

Because the bridge is so much smaller than the rest of the field, even if it is very noisy, it doesn't contribute enough errors to overwhelm the whole system. The "bulk" of the computer is so strong that it can absorb the mistakes coming from the noisy bridge.

What This Means for the Future

This study suggests that we don't need to wait for perfect, crystal-clear entangled threads to build distributed quantum computers. We can build them with "good enough" connections.

Currently, making high-quality entangled pairs is slow and difficult. Often, scientists have to "distill" them, which is like filtering dirty water to get clean water, but the process is so slow that you lose most of your water in the filter. This study suggests that because the system can tolerate noisier links, we might not need to filter as much. We could generate entangled pairs faster, even if they are a bit rougher, and still run a fault-tolerant computer.

In short, the paper shows that the "bridge" between quantum modules is more resilient than we feared. It suggests that the path to a massive, distributed quantum computer might be smoother than we thought, allowing us to trade a little bit of connection quality for a lot more speed and scalability. While this was a simulation and not a physical experiment, the results provide a strong, encouraging roadmap for engineers building the next generation of quantum hardware.

Technical Summary: Characterization of Logical Errors in Distributed Lattice Surgery

Problem Statement
Distributed quantum computing (DQC) offers a scalable alternative to monolithic quantum processors by interconnecting smaller modules via shared entangled pairs. However, a central challenge in this architecture is that inter-module quantum operations are inherently noisier than intra-module local gates. While the planar surface code is a strong candidate for fault-tolerant distributed quantum computation (FT-DQC) due to its high threshold and geometric locality, existing analyses often rely on uniform noise models or assume noiseless entanglement links. There is a lack of understanding regarding how the specific noise introduced by non-local operations—specifically imperfect Bell pairs—affects the logical error rates and fault-tolerance thresholds of fundamental lattice surgery operations, such as the merge, under circuit-level noise conditions.

Methodology
The authors analyze the logical errors in an $XX$ merge operation between two rotated surface-code patches hosted on distinct quantum processing units (QPUs). The study employs the following methodological framework:

Noise Modeling: The authors derive an effective phenomenological noise model that distinguishes between "bulk" qubits (within a single QPU) and "seam" qubits (at the interface between QPUs). This model incorporates contributions from local CNOT gates, noisy entangled pairs, idle errors, and readout errors.
- They define a uniform physical error rate $\varepsilon$ for local operations (gates, measurement, idle) and a scaling factor $k$ for Bell-pair errors ( $\varepsilon_B = k\varepsilon$ ).
- Analytical expressions are derived for effective data ( $p$ ) and measurement ( $q$ ) error rates for both bulk and seam regions, showing that seam errors depend linearly on $k$ .
Spacetime Representation: The merge operation is visualized as an H-shaped spacetime diagram. The protocol involves pre-merge syndrome extraction, a bridge phase where joint stabilizers are measured over $d$ rounds, and post-merge extraction.
Decoding and Simulation: Logical $Z$ errors are decoded using a Minimum-Weight Perfect Matching (MWPM) decoder. The authors construct a 3D spacetime syndrome graph where spacelike edges represent data errors and timelike edges represent measurement errors.
Simulation Parameters: Monte Carlo simulations are performed with $200,000$ shots per data point. The study varies the code distance $d \in \{5, 7, 9, 11, 13\}$ and the Bell-pair noise scaling factor $k \in \{1, 3, 5, 7, 9, 11\}$ .

Key Contributions

Heterogeneous Noise Model: The paper presents a phenomenological noise model specifically tailored for distributed lattice surgery, explicitly deriving effective error probabilities for bulk and seam qubits based on underlying circuit-level noise sources (local gates, Bell pairs, idling, and readout).
Logical Error Characterization: The authors characterize logical $Z$ errors in the $XX$ merge operation using the H-shaped spacetime geometry and MWPM decoding, providing a detailed analysis of how logical error rates vary with physical error rates under heterogeneous noise.
Threshold Analysis under Entanglement Noise: The study quantifies the impact of Bell-pair noise by systematically increasing the scaling factor $k$ . It demonstrates that the fault-tolerance threshold of the merge operation remains robust even when the noise at the seam (interface) is significantly higher than the bulk noise.

Results

Threshold Stability: The fault-tolerance threshold ( $\varepsilon_c$ ) for the merge operation decreases only modestly as Bell-pair noise increases. At $k=1$ (uniform noise), the threshold is $\approx 0.8683\%$ . Even at $k=11$ (where Bell-pair noise is 11 times higher than local gate noise), the threshold only drops to $\approx 0.8339\%$ , an absolute reduction of approximately $0.034\%$ .
Bulk Dominance: The results confirm that the asymptotic threshold is dominated by the bulk noise rather than the seam noise. This is attributed to the scaling of qubit counts: the bulk contains $O(d^2)$ qubits per syndrome extraction round, while the seam contains only $O(d)$ qubits. Consequently, as $d \to \infty$ , the contribution of the seam to the total spacetime error volume vanishes.
Comparison to Monolithic Systems: The observed thresholds ( $\approx 0.86\%$ ) align with the range reported for standard rotated surface code memory experiments ( $0.5\% - 1.0\%$ ), suggesting that the complex spacetime structure of the merge operation does not drastically degrade performance compared to memory experiments, even with noisy interconnects.

Significance and Claims
The paper claims that its findings provide practical insights for the design of distributed quantum architectures. Specifically:

Robustness to Imperfect Links: Distributed lattice surgery can tolerate imperfect entanglement links without a catastrophic loss in fault-tolerance thresholds.
Entanglement-Fidelity Tradeoff: The robustness of the merge operation suggests a favorable tradeoff between entanglement rate and fidelity. Systems may achieve significantly higher entanglement generation rates by utilizing lower-fidelity pairs and minimizing the need for extensive entanglement distillation, which is probabilistic and resource-intensive.
Feasibility of Modular Architectures: The results support the feasibility of modular surface-code architectures for fault-tolerant quantum computation, indicating that the stringent requirements for entanglement fidelity can be relaxed relative to the capabilities of local gates.

The authors conclude that while their study focuses on the elementary merge operation, the scaling arguments regarding boundary noise tolerance likely extend to larger logical operations built from merge and split primitives. They identify future work directions including the study of decoders tailored to spatially varying error profiles and the extension of this analysis to CNOTs, magic state distillation, and teleportation under realistic hardware constraints.