⚛️ quantum physics

Logical information localisation in stabiliser codes via single-qubit measurements

This paper introduces and analyzes the $g$ -SPF method for localizing logical information in stabiliser codes onto a small set of qubits using single-qubit measurements, proving a localization threshold for surface codes and providing efficient algorithms that enable the study of larger codes for applications like fault-tolerant teleportation.

Original authors: Jelena Mackeprang, Hemant Sharma, Jonas Helsen

Published 2026-10-01

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Jelena Mackeprang, Hemant Sharma, Jonas Helsen

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

Quantum computers promise to solve problems that are currently impossible for classical machines, from designing new medicines to cracking complex encryption. However, these machines are incredibly fragile. The particles they use to store information, such as photons or electrons, are prone to vanishing or getting corrupted by their environment. To build a useful quantum computer, scientists must protect this information using error-correcting codes. These codes spread a single piece of data across many physical particles, so that if a few disappear, the original information can still be recovered. A major challenge arises when these particles are lost during transmission, such as when sending quantum data over long distances. If too many particles vanish, the information is destroyed. Researchers have long sought a way to quickly check if the information is still safe and, if it is, to gather it all onto a single particle so it can be read out or used immediately. This process is known as localisation.

In a recent study, researchers Jelena Mackeprang, Hemant Sharma, and Jonas Helsen investigated a method called stabiliser path finding to solve this problem. They focused on a specific type of error-correcting code used in quantum computing, known as a stabiliser code. Their goal was to determine if it is possible to find a way to concentrate the scattered logical information onto just one or a few remaining particles, even after many others have been lost. They explored two scenarios: one where the target particle for the information was fixed in advance, and a more flexible version where the information could be gathered onto any small group of surviving particles. By combining mathematical proofs with computer simulations, they discovered that for a widely used code called the planar surface code, this localisation is possible with near certainty as long as the rate of particle loss stays below a specific limit. They also developed two new computer algorithms to find these solutions much faster than previous methods, allowing them to test much larger systems than ever before.

The core of their work addresses a critical bottleneck in quantum communication. Imagine a network of particles where each one holds a tiny piece of a larger puzzle. If some pieces are lost, the puzzle might still be solvable, but the remaining pieces are scattered and hard to read. The researchers asked: can we rearrange the remaining pieces so that the entire picture is concentrated on just one or a few spots? This is what they call localisation. If successful, it allows for a fast read-out of the data, which is essential for technologies like quantum repeaters that send information across vast distances. The team proved mathematically that for the planar surface code, if the probability of any single particle being lost is less than fifty percent, there is almost always a way to gather the information onto a constant number of particles, regardless of how large the system is. This threshold of fifty percent is significant because it matches the known limit for simply keeping the information alive, suggesting that localisation is just as robust as the code's ability to survive loss in the first place.

To reach these conclusions, the authors first had to overcome a major computational hurdle. Previous methods for finding these localisation paths were incredibly slow, requiring the computer to check an exponentially growing number of possibilities. This limited researchers to studying very small systems, leaving the behavior of large, practical codes unknown. Mackeprang, Sharma, and Helsen introduced two new algorithms to tackle this. The first is a precise, deterministic method that guarantees finding the best possible solution if one exists. The second is a faster, heuristic approach that finds a very good solution quickly, though not necessarily the absolute best one. Both methods work by translating the problem into a format that standard optimization software can solve efficiently. They used these tools to simulate the planar surface code under various conditions of particle loss.

The results of their simulations confirmed the mathematical predictions. When the loss rate was below fifty percent, the algorithms successfully found a way to localise the information in nearly every case, even for very large codes. When the loss rate exceeded fifty percent, the success rate dropped to zero, confirming that the information was truly lost. Furthermore, the researchers showed that the faster, heuristic algorithm performed almost as well as the precise one in terms of the quality of the solution, but it was orders of magnitude faster. This speedup is crucial because it allows scientists to study codes with thousands of particles, a scale that was previously impossible to analyze with existing tools. The ability to handle such large systems means that engineers can now systematically search for the best codes for future quantum networks.

The study also refined the definition of the problem itself. Earlier work assumed that the target particle for the information was never lost, an assumption that might not hold in real-world scenarios where any particle can vanish. The researchers relaxed this condition, allowing the information to be gathered onto any small set of surviving particles. They proved that this flexibility does not weaken the system; the same fifty percent threshold applies. This finding suggests that fault-tolerant quantum communication systems can be designed with a high degree of confidence, knowing that as long as the hardware keeps the loss rate below this limit, the information can be reliably retrieved and concentrated. The work provides both a theoretical guarantee and a practical toolkit, bridging the gap between abstract mathematical proofs and the engineering realities of building a quantum internet.

By establishing that localisation is possible up to the same limit as the code's survival, the researchers have opened the door to more efficient quantum protocols. Their fast algorithms enable the design of systems that can adapt to loss in real-time, gathering information onto specific qubits for immediate use. This capability is vital for tasks like quantum teleportation and the fusion of quantum states, where speed and reliability are paramount. The study does not claim to have solved all problems in quantum error correction, but it provides a clear path forward for one of its most challenging aspects: ensuring that information remains accessible even when the physical medium carrying it is imperfect. The combination of rigorous proof and scalable computation offers a solid foundation for the next generation of quantum technologies.

Technical Summary: Logical Information Localisation in Stabiliser Codes via Single-Qubit Measurements

Problem Statement

The paper addresses the challenge of localising logical information in a stabiliser code undergoing qubit loss onto a small set of target qubits using only a single round of single-qubit measurements. This capability is critical for fault-tolerant communication and measurement-based quantum computation (MBQC), particularly in photonic systems where photon loss is a primary error source.

The core task, termed Stabiliser Path Finding (SPF), was previously introduced by Morley-Short et al. [24] and Bell et al. [21]. The objective is to find a pair of logical representatives, $\bar{X}$ and $\bar{Z}$ , that satisfy two conditions:

Lost-Qubits Condition: Neither operator has support on any lost qubits.
Target Condition: The operators anti-commute qubit-wise on exactly one designated target qubit $t$ and commute on all other qubits.

Existing methods for solving SPF rely on exhaustively listing all non-trivial logical representatives. This approach scales exponentially with the number of qubits, rendering it infeasible for codes larger than approximately 12 qubits. Furthermore, previous formulations assumed the target qubit is never lost, an assumption that may lead to sub-optimal success rates in practical scenarios.

Methodology

The authors propose a comprehensive analytical and computational framework to address these limitations.

1. Generalisation: g-SPF

The paper introduces a relaxed version of the problem called g-SPF. Instead of requiring anti-commutation on a single designated target, g-SPF seeks a pair $(\bar{X}, \bar{Z})$ that anti-commutes on at most $g$ arbitrary target qubits. This relaxation allows for the selection of target qubits dynamically based on the loss configuration, potentially improving success rates.

2. Analytical Approach: Percolation and Disjointness

To establish theoretical guarantees, the authors analyse the planar surface code under independent and identically distributed (i.i.d.) qubit loss with probability $p$ .

Percolation Theory: They map the existence of logical representatives to the existence of open paths in a 2D lattice. Using bond percolation results, they show that for $p < 1/2$ , there exist many edge-disjoint paths from left-to-right (for $\bar{X}$ ) and top-to-bottom (for $\bar{Z}$ ) with probability converging to one as the code size $n \to \infty$ .
Disjointness Lemma: They derive a lemma (Lemma 2) relating the disjointness of a stabiliser code (the number of pairwise disjoint representatives) to the minimum intersection size of $\bar{X}$ and $\bar{Z}$ supports.
Synthesis: By combining the scaling of disjoint representatives (which scales as $\sqrt{n}$ ) with the intersection bound, they prove that the minimum intersection size between surviving $\bar{X}$ and $\bar{Z}$ representatives remains bounded by a constant $g$ as $n$ increases, provided $p < 1/2$ .

3. Computational Algorithms

The authors propose two algorithms to solve SPF and g-SPF, both utilizing the symplectic representation of stabiliser codes and a pre-processing step to handle the "Lost-Qubits" condition by updating the stabiliser tableau.

D-LoFi (Deterministic Localisation Finder):
- Formulation: Encodes the problem as a constrained quadratic optimisation problem, which is then transformed into an Integer Linear Program (ILP).
- Mechanism: It minimises the total support size $|\text{support}(\bar{X}) \cup \text{support}(\bar{Z})|$ subject to the commutation constraints.
- Properties: It is exact; if a solution exists, D-LoFi finds the one with minimal support.
H-LoFi (Heuristic Localisation Finder):
- Formulation: Casts g-SPF as a most-likely-error decoding problem.
- Mechanism: It operates in two stages:
  1. Find a low-weight $\bar{Z}$ representative by treating an initial $\bar{X}$ as a stabiliser and decoding for an error that commutes with all stabilisers except $\bar{X}$ .
  2. Find a low-weight $\bar{X}$ representative that anti-commutes with the found $\bar{Z}$ on a small set of qubits, using a similar decoding approach.
- Properties: It is significantly faster than D-LoFi and approximates the exact success rates closely, though it does not guarantee the absolute minimum support.

Key Results

1. Localisation Threshold

The authors prove Theorem 1, establishing that the planar surface code exhibits a localisation threshold for g-SPF at $p = 1/2$ .

For any loss probability $p < 1/2$ , there exists a constant $g$ such that the probability of finding a g-SPF pair converges to 1 as the code size $n \to \infty$ .
For $p > 1/2$ , the success probability converges to 0.
This threshold coincides with the standard erasure threshold of the surface code, despite localisation being a distinct task from standard erasure decoding.

2. Numerical Validation

Threshold Reproduction: Both D-LoFi and H-LoFi were used to numerically reproduce the $p=1/2$ threshold for the rotated surface code.
Performance Comparison:
- Speed: H-LoFi is orders of magnitude faster than D-LoFi.
- Accuracy: H-LoFi closely approximates the exact success rates and support sizes found by D-LoFi.
- Scalability: The authors compared D-LoFi against the algorithm from Ref. [24] using "crazy graph" codes. While the Ref. [24] algorithm exceeded a 16-hour runtime limit for codes with more than 18 qubits, D-LoFi successfully computed thresholds for significantly larger codes.

Significance and Claims

The paper claims to provide the first theoretical and numerical analysis of localisation via SPF. Its primary contributions are:

Theoretical Guarantee: Proving the existence of a localisation threshold for the planar surface code at $p=1/2$ for constant $g$ , establishing that fault-tolerant localisation is possible even with significant qubit loss.
Algorithmic Efficiency: Introducing D-LoFi and H-LoFi, which reduce the computational time required to solve SPF by orders of magnitude compared to state-of-the-art methods. This enables the systematic study of localisation in substantially larger stabiliser codes than previously possible.
Practical Utility: The ability to rapidly solve SPF allows for the identification of suitable codes for fault-tolerant schemes, such as adaptive fusions and logical teleportation, in highly lossy channels.

The authors maintain a modest tone regarding the heuristic nature of H-LoFi, noting that while it performs well, an analytical proof for the specific case of $g=1$ (Target-SPF) remains an open question, though numerical evidence suggests the threshold holds for $g=1$ as well. The work opens the door to applications in fault-tolerant teleportation and efficient logical fusion but does not propose specific new experimental hardware or protocols beyond the theoretical framework.