Loss-tolerant distributed lattice surgery using fusion networks

summary

The gist

The gist Scaling quantum computers to practically relevant logical qubit counts at low error rates requires more qubits than are typically expected to fit on a single quantum processing unit (QPU)

In short

The research explores loss-tolerant distributed lattice surgery for scaling quantum computers using multiple QPUs connected by a photonic network. It develops hybrid syndrome extraction protocols using ZX calculus to perform this surgery, showing that under low local noise, 50% fusion outcome erasure thresholds are achievable. This demonstrates how tailored protocols can mitigate noise and address hardware limitations in distributed quantum computing.

Key concepts

Distributed Lattice Surgery: This is a method used to perform complex operations on logical qubits that are spread across multiple separate quantum processing units (QPUs). It involves connecting these QPUs via a photonic network to manipulate the overall logical structure, allowing for scalable computation beyond what one single QPU can handle.
Hybrid Syndrome Extraction Protocols: These are specialized procedures constructed using the ZX calculus to extract necessary error information from distributed logical qubits. The protocol cleverly combines measurements performed on matter qubits with syndrome extraction done via fusion networks at the interface, optimizing how errors are detected across the network.
Fusion-Based Quantum Computing (FBQC): This approach decomposes cluster states into smaller resource states connected by linear-optical fusion measurements. It is a method for generating and manipulating quantum resources in a distributed manner, where the connections between these smaller states are established through photon interactions.

Terminology used across episodes

Reinforcement Learning (RL) — explained in 25 episodes
Retrieval-Augmented Generation (RAG) — explained in 16 episodes
Federated Learning — explained in 15 episodes
Interpretability — explained in 15 episodes
Sample Complexity — explained in 15 episodes
Generalization — explained in 13 episodes

This episode discusses

The paper

Loss-tolerant distributed lattice surgery using fusion networks · Read on arXiv

Felix Burt, *Richard Meister, *Sheng-Ku Lin, *Kuan-Cheng Chen, Michael Hanks, Roberto Bondesan, M.S. Kim, Kin K. Leung

Electrical and Electronic Engineering, Imperial College London

Networking matter-based quantum processing units (QPUs) offers a promising route to scaling fault-tolerant quantum computers. This requires distributed logical operations to be performed across photonic links, where noise is characteristically different from and stronger than in local QPUs owing to photon loss and probabilistic linear-optical operations. Measurement- and fusion-based quantum computing are designed to be robust against loss and probabilistic photonic operations, suggesting they could complement circuit-based error correction at the interface between networked QPUs. We use ZX calculus transformations to construct hybrid syndrome extraction protocols and apply them to distributed rotated surface code lattice surgery, demonstrating that several protocols attain a 50% interface-erasure threshold when local noise is absent, including circuit-based lattice surgery using fused Bell pairs and hybrid protocols using linear cluster states. Relative to a straight Bell-pair interface geometry, the hybrid protocols increase the merge-observable interface distance from d+1 to 2d+1 and restore the perpendicular-observable interface distance from (d+1)/2 to d. We calculate how the threshold decreases when using truncated resource states and map correctable regions under resource-state errors, local circuit noise, and fusion erasure. We then convert these erasure thresholds into photon-loss thresholds and probe subthreshold performance using fusion boosting. At circuit and resource-state error rates of 10-3, local errors largely mask the interface-distance advantage. As local noise is reduced to 10-4 and below, the linear-chain protocols improve more rapidly with decreasing erasure, suggesting that interface distance enhancements are effective in low local noise regimes.

Transcript

Introduction to the show: ident: Quantum Radio. Generated commentary on the latest quantum physics and condensed matter papers.

Kai: I'm Kai, and with me are Mira and Lev, guest researcher.

Mira: Today's paper: "Loss-tolerant distributed lattice surgery using fusion networks".

Kai: The gist Scaling quantum computers to practically relevant logical qubit counts at low error rates requires more qubits than are typically expected to fit on a single quantum processing unit…

Mira: First, who's behind it and why it matters.

Title and authors: Kai: So we're looking at the paper Loss-tolerant distributed lattice surgery using fusion networks. It sounds like they’re tackling a really tough problem with scaling up quantum computers by breaking the computation across multiple machines.

Mira: Exactly, Kai. The title suggests they’re focusing on how to do that distributed surgery while being robust against loss, which is a big deal because photon loss is a major hurdle in these kinds of setups compared to working on one QPU.

Lev: From an error correction standpoint, I’m curious if this actually translates to something we can run with real hardware right now. It sounds like they’re trying to build a reliable way for different quantum processors to talk to each other without everything falling apart at the connection points.

Kai: Right, that's what I was thinking when I saw it. They’re using ZX calculus transformations to build these hybrid syndrome extraction protocols, which is a clever way of mapping out the operations for this distributed setup.

Mira: It’s about taking those complex logical operations and breaking them down into something that works across different hardware—a hybrid realization with fusion networks at the interface and circuit-based syndrome extraction elsewhere <ref:2610.01923#pg2>.

Lev: So, when you look at what they’re trying to achieve, it seems like they are replacing some of the traditional sequential measurements with these cluster states that interact with ancilla qubits locally <ref:2610.01923#pg2>.

Kai: That’s right, it’s about creating a different way to manage the interface between the local quantum processors and the network links. It's not just about connecting them; it's about making that connection part of the error correction strategy itself <ref:2610.01923#pg2>.

The paper's summary: Mira: The core of what this paper is doing, according to the summary, is constructing these hybrid syndrome extraction protocols specifically for distributed lattice surgery between distributed logical qubits <ref:2610.01923#pg1>.

Kai: It seems they’ve mapped out how to perform that surgery using ZX calculus and then applied it to a distributed rotated surface code lattice surgery. The goal there is demonstrating that error rates of ten percent can be tolerated at the interface with minimal effect on the local threshold <ref:2610.01923#pg3>.

Lev: Ten percent tolerance at the interface sounds like a solid number, but what about how this compares to just having a straight Bell-pair interface geometry? Is there a trade-off in terms of distance?

Mira: There is, and it’s interesting. The hybrid protocols they construct actually increase the merge-observable interface distance from d plus one to two d plus one, and they restore the perpendicular-observable interface distance from floor(d plus one over two) back down to just d <ref:2610.01923#pg3>.

Kai: So, they’re showing that this hybrid approach isn't just about surviving loss; it’s actively improving the geometric properties of how the network links are managed during the surgery <ref:2610.01923#pg3>.

Lev: That sounds like a significant technical step because it means they’re not just getting lucky with noise; they’re engineering the structure to be more resilient to things like photon loss.

The paper's improvements: Kai: Now, let's talk about the specific improvements they are proposing in this paper. They focus on how these hybrid protocols handle different types of errors, specifically by looking at resource state decomposition and truncation <ref:2610.01923#pg3>.

Mira: They decompose cluster states into smaller resource states connected by linear-optical fusion measurements, which they call fusion-based quantum computing or FBQC <ref:2610.01923#pg3>. This decomposition depends on how the incident legs are partitioned, which shows the design space still has a lot of room to explore <ref:2610.01923#pg3>.

Lev: If we truncate those linear resource states to a fixed size, what happens then? Does that simplify things or introduce new problems when we’re trying to keep the error rates low?

Kai: Truncating those linear resource states leaves both the interface distances unchanged, but it lowers the erasure threshold predictably. For eight-qubit chains, it drops to thirty-eight percent, and for five-qubit chains, it drops to thirty-two percent <ref:2610.01923#pg3>.

Mira: So they show that you can trade off the precise structure of your resource state decomposition for a predictable improvement in performance under erasure noise, which is pretty telling about how much control you have over the system.

Lev: That’s useful because it gives us a concrete number to work with when we start thinking about running this on actual matter-based qubits <ref:2610.01923#pg3>.

Conclusion: Kai: So, wrapping things up, the main thing is that they’ve shown the benefits of these hybrid syndrome extraction protocols for distributed lattice surgery <ref:2610.01923#pg1>. They highlight how you can tailor error correction schemes toward noise sources like photon loss <ref:2610.01923#pg3>.

Mira: And they point out a limitation, though. The paper notes that the principal local-noise limitation of these hybrid interfaces comes from those deterministic boundary fusions between the circuit and resource-state regions <ref:2610.01923#pg1>.

Lev: That deterministic boundary fusion sounds like where the real sticking point is, meaning even with all this engineering, you still have that hard spot to overcome when local noise is high <ref:2610.01923#pg2>.

Kai: Exactly. It seems there’s still a lot of design space left to explore because those deterministic boundary fusions are what limit the performance right now <ref:2610.01923#pg1>.

Mira: We’re looking forward to seeing if we can find alternative interface structures that might bypass that limitation and lead to better overall performance <ref:2610.01923#pg3>.

Lev: I think it’s a necessary step toward building something scalable, even if the deterministic boundary fusion is still the main challenge we have to tackle first <ref:2610.01923#pg1>.

More episodes

← Home