Logical information localisation in stabiliser codes via single-qubit measurements

arXiv:2609.39980 · quant-ph · Submitted 2026-09-30 · Read on arXiv

Listen

Radio episode about this paper

Transcript

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

Kai: Today's paper: "Logical information localisation in stabiliser codes via single-qubit measurements".

Mira: Stabiliser path finding (SPF) has previously been introduced as a method to localise logical information in a stabiliser code undergoing loss onto a single pre-specified target qubit,

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

Paper summary: Kai: So we're looking at this paper, "Logical information localisation in stabiliser codes via single-qubit measurements," and what it claims is about using Stabiliser Path Finding, or SPF, to find lost logical information. It seems like the core idea is extending that original SPF method to handle multiple targets.

Mira: Exactly, Kai; the thesis of this paper centers on introducing g-SPF, which lets you localize information onto up to g unspecified target qubits instead of just one pre-specified qubit as in the earlier SPF method. It claims they establish a localization threshold for the planar surface code based on this generalized approach.

Lev: From a researcher standpoint, establishing that threshold at p=one/two is significant because it tells us when this process actually becomes reliable enough to run on real hardware, which is what I'm focused on.

Kai: It’s interesting how they frame it; they use the planar surface code as their main example to analyze the generalized g-SPF problem. They are arguing that if you lose qubits with a probability p less than one/two you can find that pair of logical operators (X, Z) for constant g and succeed with probability converging to one as the code size gets very large.

Mira: That analytical argument relies on combining percolation theory in two dimensions with how disjointness works within stabiliser codes, specifically deriving a lemma about the relationship between the "disjointness of a stabiliser code to the minimum intersection size of the logical operator pairs (X, Z)". It's quite a deep theoretical foundation they build their claim upon.

Lev: For real hardware, that convergence to one probability is what matters; if we can actually implement the measurement sequence and get that success rate as predicted, then it means we have a robust method for fault-tolerant communication. But I'm wondering how much overhead these measurements introduce when we scale up to larger surface codes.

Kai: That's a good question, Lev; the paper does propose two computational algorithms to tackle this, one deterministic and one heuristic. The deterministic finder formulates g-SPF as constrained quadratic optimization problems which they solve using integer linear programs.

Mira: And the objective in both of those problems is to minimize the total support size, defined as support(X) support(Z), while satisfying two main conditions: no support on lost qubits and a specific anti-commutation condition related to g. For the generalized problem, this is relaxed to alpha(X, Z) g, which is the number of qubits where X and Z anti-commute.

Lev: Minimizing that support size sounds like a practical goal for us; smaller supports mean fewer physical qubits are involved in the logical operation, which directly impacts our error budget calculations. But how does the heuristic approach compare to the deterministic one in terms of speed when dealing with these optimization problems?

Paper summary: Kai: The paper shows that their heuristic algorithm, called H-LoFi, is orders of magnitude faster than the deterministic finder. They encode g-SPF as a type of most-likely-error decoding problem that they solve using a decoder.

Mira: That speed advantage is interesting, but we have to be careful; the paper also mentions that for very large codes, the runtime of the deterministic finder scales better than previous state-of-the-art algorithms like those in Ref. twenty-four, which allows them to study substantially larger stabiliser codes. That's a nuanced point about scaling performance.

Lev: Scaling is definitely the bottleneck on hardware; if the deterministic approach scales better for large codes, that gives us more room to explore meaningful error correction distances, which is crucial for our fault-tolerant teleportation goals. However, what about the limitations they themselves flag?

Kai: They do point out that the procedure in Ref. twenty-one, which they used numerically, provided no analytical guarantee that loss tolerance persists at large sizes. That means this new analytical work is providing a stronger foundation than what was previously available for larger systems.

Mira: They also state that the paper focuses on the planar surface code as their primary example, which implies that generalizing these specific analytical arguments to other types of graph codes will require further development. It sets a clear boundary for where their current analytical proof holds firm.

Lev: So, if we take the main results—Theorem one proving the p=one/two threshold for constant g on planar surface codes—how does that translate into what we can actually build right now with current superconducting qubits or trapped ions? It sounds like a long-term goal.

Kai: The immediate impact is showing us a concrete analytical limit, which is valuable regardless of the hardware state. Even if we can't run the full simulation yet, knowing that this threshold exists for the surface code guides our expectations for future implementations.

Mira: I think what matters most is that they successfully extended SPF to handle multiple targets, moving beyond the single pre-specified target qubit concept. This opens up new ways to localize information in complex stabilizer codes that might be relevant for certain fusion-based computation schemes.

Lev: It suggests that we can design measurement protocols that are more flexible, which is a good direction for developing adaptive fusions tolerant to qubit losses. We need to see how their numerical validation holds up when we start moving from planar codes to those triangular or crazy graph codes they mention later in the paper.

Paper summary: Kai: So, to wrap up this part of the discussion about "Logical information localisation in stabiliser codes via single-qubit measurements," the main point is that they provide an analytical and computational study showing that localization via g-SPF works with high probability for planar surface codes when qubit loss is below a certain rate, establishing a threshold at p=one/two.

Mira: And they showed that this works for constant g by proving the existence of such a pair as the code size grows, which implies that success rates approach one asymptotically. This is supported by their numerical validation where H-LoFi approximates D-LoFi results closely.

Lev: The implication for the community is that we have a more rigorous theoretical framework to guide experimentalists in designing measurement strategies for error correction. We can use this threshold knowledge to set realistic performance targets for our hardware experiments.

Kai: And looking at the title, "Logical information localisation in stabiliser codes via single-qubit measurements," it really highlights that this technique is a practical tool for fault-tolerant communication when we're dealing with limited resources and flying qubits.

Mira: Indeed; the work moves beyond just proposing a method to show how it performs under various theoretical constraints, which is what makes this paper substantial. It connects abstract graph theory to concrete error correction limits.

Lev: For us working on actual hardware, understanding the scaling behavior described in the paper means we can better estimate the resource requirements for achieving a specific level of logical protection. That practical guidance is what's most useful right now.

Kai: It sounds like this paper gives us a solid theoretical backbone, even if the actual implementation still requires careful engineering to handle those complex optimization problems.

Mira: Precisely; the analytical proof of Theorem one is what anchors these computational findings in something more fundamental about stabilizer codes and percolation theory. It shows the underlying mathematical structure that supports the success rate convergence.

Lev: So, when we look ahead, it points toward needing better tools to handle non-planar codes effectively, which is where their application to graph codes comes in. We need to see if these analytical methods can be adapted for those structures.

Kai: That's the next step; taking this theoretical success and seeing if we can build algorithms that work efficiently on those different code geometries, which is what the D-LoFi algorithm seems designed to do.

Mira: And ultimately, this paper provides a comprehensive study of localisation via SPF, giving us a clear idea of where the current limits are for planar codes and setting a path forward for future theoretical work on more complex stabilizer structures.

Conclusion: Kai: So, to wrap up our discussion on this paper, "Logical information localisation in stabiliser codes via single-qubit measurements," we've seen how they use SPF to track lost data and establish a threshold for surface codes.

Mira: I agree; the title itself really sets the stage by focusing on how we can pinpoint where logical info goes using just simple single-qubit measurements.

Lev: From a hardware standpoint, knowing that p=one/two is a hard limit for this localization to be reliable gives us something concrete to aim for in our error correction schemes.

Kai: Exactly; it moves the discussion from theoretical possibility to a measurable success rate on real systems like the surface code.

Mira: The implication here is that we can design measurement circuits that are much more flexible when dealing with noisy qubits during computation.

Lev: That flexibility is key, because if we can build protocols where information doesn't just disappear after a few errors, the whole fault-tolerant architecture becomes much more feasible.

Kai: It suggests that future quantum computers won't just be about building bigger and bigger codes, but about designing smarter ways to read and recover data within them.

Mira: And this work opens up avenues for exploring different types of stabilizer codes beyond the planar surface code, which is where the real theoretical meat is.

Lev: We need to see how these localization ideas translate when we start looking at those triangular or crazy graph codes they mentioned later in their analysis.

Jelena Mackeprang, Hemant Sharma, Jonas Helsen

QuSoft and CWI · QuTech, TU Delft

quant-ph

Submitted: 2026-09-30

Updated: 2026-09-30

Code: https://github.com/arr0w-hs/graph_code_decoding

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 91/100

The gist: Stabiliser path finding (SPF) has previously been introduced as a method to localise logical information in a stabiliser code undergoing loss onto a single pre-specified target qubit, using only one

Key concepts

Stabiliser Path Finding (SPF)
SPF is a technique used to pinpoint where logical information has been lost in a quantum stabilizer code. It attempts to locate this missing information by performing just one set of single-qubit measurements on the remaining qubits.
g-SPF
g-SPF generalizes SPF to handle multiple potential target qubits, allowing localization onto at most 'g' unspecified locations instead of just one. This generalization is crucial for analyzing more complex loss scenarios in stabilizer codes.
Localization Threshold
The localization threshold is the critical probability level (p=1/2) below which the SPF method successfully localizes logical information with high probability. Establishing this threshold proves when this method becomes a reliable tool for error correction.
Planar Surface Code
The planar surface code is a specific type of stabilizer code used as the primary example in this study. It is a well-known structure in quantum error correction, and the paper uses it to test and prove the performance limits of g-SPF.

Terminology

Summary

Stabiliser path finding (SPF) has previously been introduced as a method to localise logical information in a stabiliser code undergoing loss onto a single pre-specified target qubit, using only one round of single-qubit measurements. This work provides an analytical and computational study of localisation via SPF, introducing g-SPF to localize information onto at most g unspecified target qubits and establishing a localization threshold for the planar surface code.

Analytical Framework and Threshold Proof

The paper analyzes the generalized SPF problem, denoted as g-SPF, using the planar surface code as a primary example. The main analytical result is Theorem 1, which states that for i.i.d. qubit loss with probability p < 1/2 and sufficiently large planar surface codes, localisation via g-SPF for constant g succeeds with a probability converging to one, establishing a localization threshold at p = 1/2. This threshold coincides with the standard erasure threshold from Ref. [28]. The proof relies on combining known statements about bond percolation in two dimensions with the notion of sets of disjoint logical operators in stabiliser codes. Specifically, it derives a lemma relating the disjointness of a stabiliser code to the minimum intersection size of the logical operator pairs (X, Z).

Formalization as an Optimization Problem

The SPF problem is formalized into an optimization problem. The goal is to find a pair of logical representatives X and Z that satisfy two main conditions:

  1. The Lost-Qubits condition: support(X) ∪ support(Z) ∩ L = ∅, meaning they have no support on the lost qubits.

  2. The Target condition (for Target-SPF, where g=1): They must fulfil qubit-wise anticommutation only on the target qubit t and commutation otherwise, defined as:

(Xt, Zt) = 0, [Xi, Zi] = 0 ∀ i ≠ t.

For the generalized problem (g-SPF), this is relaxed to the g-condition:

(α(X, Z) ≤ g), where α(X, Z) is defined as the number of qubits on which X and Z anti-commute.

The objective in both problems is to find a pair that minimizes the total support size: min support(X) ∪ support(Z).

Computational Algorithms

The paper proposes two algorithms to solve SPF.

  1. Deterministic Localisation Finder (D-LoFi): This algorithm formulates Target-SPF and g-SPF as constrained quadratic optimisation problems, which we formulate as integer linear programs (ILPs) and solve using an ILP solver. It minimizes the size of the total support for a given loss configuration.

  2. Heuristic Localisation Finder (H-LoFi): This algorithm encodes g-SPF as a type of most-likely-error decoding problem that we solve using a decoder. It first searches for a short Z representative and then finds an X representative that anti-commutes qubit-wise with Z on a small set of qubits.

Numerical Validation and Performance

The algorithms are validated numerically by reproducing the localization threshold for the surface code.

(Figure 1) demonstrates that our H-LoFi algorithm closely approximates the exact success rates obtained by D-LoFi.

The paper shows that H-LoFi is orders of magnitude faster than D-LoFi (Fig. 2(a)). Furthermore, for large codes, the runtime of D-LoFi scales better than that of previous state-of-the-art algorithms (like those in Ref. [24]), allowing for the study of substantially larger stabiliser codes.

Key Findings and Applications

The work establishes that:

(Theorem 1) proves the existence of a g-SPF threshold at p = 1/2 for the planar surface code.

(Corollary 11) shows that with a probability converging to one, the disjointness of the surviving elements of XR and ZR scales with (Λ − 1), which implies that there exists a constant g such that, for large enough n, the g-SPF success rate asymptotically approaches 1.

The results are applied to demonstrate that D-LoFi can reproduce loss thresholds for graph codes (triangular and crazy graph codes) and extend the analysis to larger sizes than previously considered. The work opens doors for applications such as fault-tolerant teleportation and efficient logical fusion.

Algorithm Details

The algorithms involve several complex steps:

  1. Pre-processing (Algorithm 1): This involves updating the stabiliser tableau T to represent the reduced code after loss by finding a solution to linear equations, checking for logical loss, and updating T using the solution space of a linear equation.

Improvements for AI systems

Here are the specific improvements that can be made to AI systems based on this research, along with a description of what these improved systems could achieve:

) 1. Optimization of Quantum State Preparation/Measurement Strategies (Target-SPF and g-SPF)

The core contribution is providing fast, scalable algorithms (D-LoFi for exact ILP optimization and H-LoFi for heuristic decoding) to solve the Stabilizer Path Finding (SPF) problem under qubit loss.

The improved AI system can perform real-time, fault-tolerant strategy selection during quantum computation.

Specifically:

a) When a quantum processor experiences qubit loss (or when using flying qubits), the AI can instantly determine the optimal single-qubit Pauli measurements required to localize logical information onto a constant number of target qubits (g-SPF success).

b) It can select between an exact optimization approach (D-LoFi, useful for verification) and a fast heuristic approach (H-LoFi, useful for speed in real hardware).

c) For fusion-based computation, it can dynamically choose measurement patterns to maximize the probability of successful logical fusion despite qubit losses.

  1. Fast and Scalable Quantum Error Correction Code Design/Verification

The paper establishes a concrete threshold for localization on the planar surface code (p=1/2), which is vital for designing codes that can operate in lossy environments. Furthermore, it provides tools to analyze general stabilizer codes beyond graph codes (e.g., the crazy graph code).

The improved AI system can serve as an automated tool for designing and verifying resilient quantum error correcting codes (QECCs).

Specifically:

a) Automated Code Search: The system can use the established localization threshold analysis to efficiently search for or rank stabilizer codes (beyond simple graph structures) that exhibit high g-SPF thresholds against a given loss probability.

b) Robustness Analysis: It can assess the vulnerability of a specific code structure to qubit loss by calculating the expected success rate of logical information retrieval under various i.i.d. loss models, potentially identifying weak points in code topology before fabrication or execution.

  1. Efficient Resource Management for Measurement-Based Quantum Computation (MBQC)

The research provides methods to rapidly find logical operators (X and Z) that satisfy specific anti-commutation constraints while minimizing qubit support, which directly relates to the efficiency of measurement circuits in MBQC.

The improved AI system can optimize the sequence and resource allocation for MBQC protocols.

Specifically:

a) Measurement Circuit Optimization: It can generate highly compressed or minimal measurement sequences required for logical information localization, significantly reducing the number of required single-qubit measurements compared to exhaustive search methods.

b) Adaptive Protocol Selection: In quantum communication and teleportation tasks, the AI can adapt the SPF strategy based on real-time channel feedback (loss detection) to maintain a high success probability of long-distance logical operations.

  1. Advanced Decoder Design for Noisy/Lossy Channels (H-LoFi Implementation)

The H-LoFi algorithm is formulated as a decoding problem, and the paper details how to adapt it using sophisticated decoders like BP-OSD or three-block representations to handle non-standard error models (like those involving Y errors).

The improved AI system can be deployed as a next-generation decoder for quantum communication channels.

Specifically:

a) Non-Standard Error Correction: It can utilize the H-LoFi framework to find logical operators even when the underlying noise model is complex, such as one where single-qubit Y errors are treated with equal weight to X and Z errors.

b) Real-Time Decoding: By using reinforcement learning (as hinted in Section 6.3) or fast decoding methods on the reduced stabilizer tableau, it can perform near real-time error correction on quantum states suffering from photon loss during transmission.

  1. Comparative Benchmarking and Algorithm Selection

The paper provides rigorous runtime comparisons between the exact ILP solver (D-LoFi) and the heuristic decoder (H-LoFi), along with empirical evidence showing H-LoFi's favorable scaling for large codes.

The improved AI system can act as an intelligent algorithm selector.

Specifically:

a) Dynamic Algorithm Switching: When faced with a specific problem instance (code size, loss probability, required precision), the AI can select the most appropriate solver—D-LoFi for high-precision threshold calculations or H-LoFi for fast, scalable approximations.

b) Performance Prediction: It can predict whether an exact solution is computationally feasible within a given timeframe by estimating the complexity scaling (runtime) of D-LoFi versus the heuristic gains offered by H-LoFi.

Abstract

Stabiliser path finding (SPF) has previously been introduced as a method to localise logical information in a stabiliser code undergoing loss onto a single pre-specified target qubit, using only one round of single-qubit measurements. When working with limited resources and flying qubits, this fast read-out of logical information is a helpful tool for fault-tolerant communication. In this work, we provide a broad analytical and computational study of localisation via SPF. We introduce g-SPF, where the task is to localise the logical information onto a set of at most g unspecified target qubits. Through analytical arguments based on percolation theory and the disjointness of stabiliser codes, we prove that for i.i.d. qubit loss with probability p<1/2 and sufficiently large planar surface codes, localisation via g-SPF for constant g succeeds with a probability converging to one, which establishes a localisation threshold. Furthermore, we propose and implement two algorithms to solve SPF. The first is exact and formulates SPF as an integer linear program, whereas the second is heuristic and formulates SPF as a decoding problem. We validate both algorithms by numerically reproducing the localisation threshold for the surface code and demonstrate that the heuristic algorithm is considerably faster. Our work significantly reduces the time required to solve SPF compared to current state-of-the-art algorithms, allowing us to study localisation in substantially larger stabiliser codes than previously considered in the literature. Together, these theoretical and computational results open the door to various applications, such as fault-tolerant teleportation and efficient logical fusion.

Sources

Related papers