Bare-ancilla fault-tolerant syndrome extraction: General extensions of distance-three codes and structural criteria for graph codes

arXiv:2501.12072 · quant-ph, cs.IT, math.IT · Submitted 2025-01-21 · Read on arXiv

Listen

Transcript

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

Kai: Today's paper: "Bare-ancilla fault-tolerant syndrome extraction".

Mira: Fault-tolerant syndrome extraction in

[n, 1, 3: ] non-CSS codes using graph states provides a systematic framework for constructing bare ancilla codes that are resilient against hook errors.

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

Paper summary: Kai: So Mira, I'm really excited about this paper titled "Bare-ancilla fault-tolerant syndrome extraction: General extensions of distance-three codes and structural criteria for graph codes." Essentially, they’re building a way to construct these non-CSS codes using graph states that are robust against hook errors during syndrome extraction. It seems like the main thesis is providing a systematic framework for creating bare ancilla codes that are resilient against those kinds of correlated errors.

Mira: That sounds very promising, Kai, because hook errors really mess with the code distance in these setups <ref:2501.12072#pg0>. What I find compelling is their focus on extending distance-three codes and finding structural criteria for graph codes within this construction <ref:2501.12072#pg1>. It’s not just about building a code, it's about understanding the underlying structure that makes it fault-tolerant against anisotropic and circuit-level depolarizing noise under those specific models <ref:2501.12072#pg1>.

Lev: From a hardware standpoint, if this framework works, it means we could potentially bypass some of the usual overhead associated with error correction during the syndrome measurement phase <ref:2501.12072#pg3>. What I'm thinking is that if you can handle hook errors with just a bare ancilla qubit instead of needing an extra flag qubit, that simplifies the experimental setup considerably <ref:2501.12072#pg3>.

Kai: Exactly, Lev, and the paper seems to show how they use measurements on graph states to build this family of codes, starting from an undirected graph G = (V, E) <ref:2501.12072#pg0>. They introduce a parity-check matrix H that incorporates both an adjacency matrix and a connection matrix <ref:2501.12072#pg3>.

Mira: The way they describe the encoding procedure in Algorithm one modifying the parity check matrix by selecting pivot rows based on the target qubit index to reduce the dimension from n × two(n + k) to (n − k) × 2n, is a crucial step <ref:2501.12072#pg3>. This systematic approach seems key to deriving these non-CSS codes <ref:2501.12072#pg1>.

Lev: I'm interested in how that dimensionality reduction translates to actual physical qubits and gates we can implement on a quantum computer <ref:2501.12072#pg3>. Does this construction impose any severe constraints on the connectivity or the native gate set we'd need for this BAC family?

Kai: The paper does discuss experimental setups under both anisotropic and circuit-level depolarizing noise, which is important because it tests how well these codes hold up in realistic noisy environments <ref:2501.12072#pg1>. They benchmark these results against the flag-qubit approach, and the simulations suggest their proposed codes can be competitive or even better in terms of logical error performance while potentially needing fewer ancillary resources <ref:2501.12072#pg3>.

Paper summary: Mira: I agree, Kai, the simulation results showing that the proposed BACs provide competitive performance under those noise models is a solid piece of evidence <ref:2501.12072#pg3>. The paper also establishes some conditions based on stabilizer weights to bound the number of uncorrectable hook errors <ref:2501.12072#pg3>. Specifically, Lemma one states that for any stabilizer generator g with weight wg greater than three, the number of uncorrectable hook errors is bounded by Ug ≤ wg − three <ref:2501.12072#pg3>.

Lev: Those bounds are interesting from an error correction perspective because they give us concrete limits on what we can expect regarding uncorrectable errors <ref:2501.12072#pg3>. But Mira, what about correlated two-qubit gate errors? Does the paper offer similar bounds for those scenarios <ref:2501.12072#pg3>?

Mira: It does, and it addresses that directly in Lemma three which shows that if the weight of a stabilizer satisfies wg greater than three, the number of uncorrectable hook errors is at most Ug ≤ three(wg − two) <ref:2501.12072#pg3>. Furthermore, Corollary four provides a condition for fault tolerance against correlated ancilla-data two-qubit gate errors by requiring Su ≥ Xg∈S wg≥three three(wg − two) <ref:2501.12072#pg3>.

Kai: That directly addresses one of the main concerns when moving from theory to practice, Lev, because it gives us a clear structural requirement for the stabilizer generators we need to choose <ref:2501.12072#pg3>. So, what is the process they use to actually select those generators for the bare ancilla code family?

Mira: That selection process involves a two-stage algorithm <ref:2501.12072#pg4>. First, Algorithm two searches for "admissible orderings" of Pauli operators within each stabilizer generator g, specifically chosen to extract distinct syndromes for hook errors <ref:2501.12072#pg4>. Then, Algorithm three performs a global compatibility check to confirm that the selected generators form a valid

[n, one three: ] BAC <ref:2501.12072#pg4>.

Lev: The compatibility check sounds like it's verifying linear independence across the whole set before we start building the final code structure <ref:2501.12072#pg4>. How does that global check handle potential syndrome collisions with syndromes already assigned to correctable single-qubit data errors, which they call set Ωinit?

Kai: It ensures that the set of syndromes for uncorrectable hook errors doesn't overlap with the syndromes already reserved for single-qubit data errors <ref:2501.12072#pg4>. This prevents us from having two different error types mapping to the same syndrome during decoding, which is critical for reliable operation <ref:2501.12072#pg4>.

Mira: And they also verify that each accepted generator is linearly independent through a rank test <ref:2501.12072#pg4>, which confirms the required

[n, one three: ] structure for the bare code <ref:2501.12072#pg4>. This systematic construction seems to be the core contribution here <ref:2501.12072#pg1>.

Lev: So we have a systematic way to generate a family of codes, starting from graph states and applying these checks, that are explicitly designed for fault tolerance against hook errors <ref:2501.12072#pg4>. This feels like a significant step toward making this construction applicable in real quantum hardware environments <ref:2501.12072#pg3>.

Paper summary: Kai: It is, Lev, and the paper analytically proves that this resulting family of codes, denoted as Bn for n ≥ eight preserves the distance-three property of the base code B8 <ref:2501.12072#pg4>. Lemma five shows that the logical operators XL and ZL of the base code B8 commute with all stabilizer generators in Bn and satisfy anticommutativity between themselves <ref:2501.12072#pg4>.

Mira: And Theorem six solidifies this by concluding that if the base code B8 is a distance d = three code, then all codes Bn in the family are also distance d = three codes, ensuring that encoding a single logical qubit preserves this property <ref:2501.12072#pg4>. It shows that the construction doesn't degrade the fundamental protection offered by the base code <ref:2501.12072#pg4>.

Lev: That preservation of distance-three property is what makes these codes very attractive for practical implementation because it guarantees a certain level of error resilience we are aiming for <ref:2501.12072#pg4>. But Kai, the performance evaluation section seems to be where they tie everything together with real-world noise simulations <ref:2501.12072#pg1>.

Kai: Right, and that's where the numerical error rate simulations come in, comparing them against the flag-qubit method under both standard depolarizing noise and anisotropic noise models <ref:2501.12072#pg3>. The simulation results indicate that while the

[six one three: ] BAC doesn't show a pseudo-threshold for standard depolarizing noise, it actually demonstrates asymptotic fault tolerance under the anisotropic noise model with its most optimized code rate <ref:2501.12072#pg3>.

Mira: The comparison against the flag-qubit approach is also interesting, as the simulations suggest that for codes with larger n, like

[seven one three: ] and

[twelve one three: ], the bare method either outperforms or performs similarly to the flag-based method in terms of pseudo-thresholds for depolarizing noise and under anisotropic noise models <ref:2501.12072#pg3>.

Lev: That suggests that for larger systems, this bare method is viable compared to the existing flag-based techniques when considering these specific noise types <ref:2501.12072#pg3>. So, if we look at the performance metrics they are reporting, what does that mean for a researcher trying to actually build this on a machine?

Kai: It means that starting from n=seven or n=twelve the bare method gives you a pseudo-threshold for depolarizing noise that is nearly identical to what the flag method achieves <ref:2501.12072#pg3>. That’s actually quite encouraging news for experimentalists because it suggests their construction isn't just theoretically sound but also practically relevant for achieving better performance metrics <ref:2501.12072#pg3>.

Mira: I think the overall implication is that this paper provides a structured path forward—a systematic protocol—for finding fault-tolerant codes directly from graph states <ref:2501.12072#pg1>. It moves beyond just proposing new code structures to detailing the exact construction steps needed to derive codes like Bn <ref:2501.12072#pg4>.

Paper summary: Lev: So, when we look at the overall impact of the "Bare-ancilla fault-tolerant syndrome extraction: General extensions of distance-three codes and structural criteria for graph codes" paper, it seems to offer a concrete method that bridges the gap between abstract graph theory and practical quantum error correction protocols <ref:2501.12072#pg4>.

Kai: Exactly, Lev, it gives us a systematic way to find FT codes from graph codes and identifies the

[six one three: ] code as a particularly optimized bare ancilla code <ref:2501.12072#pg0>. This feels like the kind of detailed guidance we need when trying to design experiments that actually run <ref:2501.12072#pg3>.

Mira: The structural criteria they propose for stabilizer weights, like the bounds derived from Lemma one and three are very useful theoretical tools for anyone working on non-CSS codes <ref:2501.12072#pg3>. They provide the necessary conditions to ensure that the resulting code family maintains its desired fault-tolerant characteristics <ref:2501.12072#pg4>.

Lev: For the wider quantum error correction community, this work provides a new starting point for constructing QECCs using measurement-based techniques that directly tackles hook errors in syndrome extraction <ref:2501.12072#pg3>. It’s a different route to exploring fault tolerance compared to traditional stabilizer code constructions <ref:2501.12072#pg3>.

Kai: We should definitely keep an eye on the future work mentioned, which suggests extending these constructions to longer distances or even multiple logical qubit codes <ref:2501.12072#pg4>. That points toward realizing more complex quantum computation architectures <ref:2501.12072#pg4>.

Mira: It certainly opens the door for exploring how these graph-based methods can scale up to larger systems while maintaining those crucial distance-three properties <ref:2501.12072#pg4>. The work provides a foundation for scaling this approach beyond the current scope of n=eight <ref:2501.12072#pg4>.

Lev: I think the real implication is that it validates using graph codes as a systematic source for non-CSS QECCs when you're focused on mitigating hook errors during syndrome extraction <ref:2501.12072#pg3>. It shows that these methods can yield performance comparable to other established techniques under certain noise conditions <ref:2501.12072#pg3>.

Kai: So, the paper successfully constructs and analyzes a family of

[n, one three: ] non-CSS QECCs using graph codes that are fault-tolerant against hook errors <ref:2501.12072#pg0>, offering a systematic framework for finding FT codes from graph codes <ref:2501.12072#pg4>.

Mira: The most important points seem to be the systematic protocol for generating these QECCs using graph states and the structural criteria derived from stabilizer weights that ensure fault tolerance against hook errors <ref:2501.12072#pg3>.

Lev: It’s a significant step because it provides a concrete method that bridges abstract graph theory and practical quantum error correction protocols for handling correlated errors during syndrome measurement <ref:2501.12072#pg3>.

Kai: Ultimately, the work successfully constructs and analyzes a family of

[n, one three: ] non-CSS QECCs using graph codes that are fault-tolerant against hook errors <ref:2501.12072#pg0>, providing a systematic framework for finding FT codes from graph codes <ref:2501.12072#pg4>.

Conclusion: Kai: So, to wrap up this discussion, we're focusing on how these bare ancilla codes built from graph states offer fault tolerance against hook errors during syndrome extraction. Mira, what are your thoughts on the title and the authors of this paper?

Mira: I think the title really gets to the core of what they've achieved: extending distance-three codes using graph theory to create codes that handle those specific correlated errors we talked about. The authors clearly laid out how these structural criteria for stabilizer weights are essential, which is crucial because it tells us exactly what kind of code architecture we need to pursue <ref:2501.12072#pg3>.

Lev: From my side, the implication is that if this systematic construction works as described, we could design syndrome measurement circuits that are inherently more robust against those tricky hook errors without needing extra flag qubits, which simplifies the entire experimental setup significantly <ref:2501.12072#pg3>.

Kai: That simplification would be huge for hardware realization, Lev. Mira, regarding the authors' approach, they took a complex idea from graph states and turned it into a concrete building block for non-CSS codes <ref:2501.12072#pg1>. What does that mean in plain terms for someone trying to actually build this on a quantum computer?

Mira: It means they provided the blueprint, showing us exactly how to take an undirected graph and systematically derive a valid bare ancilla code, which is much more actionable than just stating that it's possible <ref:2501.12072#pg4>. The construction process itself becomes a tool for generating new code families <ref:2501.12072#pg4>.

Lev: And the fact that they proved these codes preserve the distance-three property, Theorem six means that whatever logical qubit you encode, its fundamental error protection remains intact even with this bare ancilla construction <ref:2501.12072#pg4>. That structural guarantee is what makes it worth running on real hardware <ref:2501.12072#pg3>.

Kai: Exactly, that distance-three preservation is a solid anchor for any experimentalist because it means we don't lose the core protection of the code when we implement this bare method <ref:2501.12072#pg4>. So, what does this whole body of work suggest for the next steps in this field?

Mira: The future work mentioned points toward extending these constructions to codes with longer distances or even to scenarios involving multiple logical qubits, which would push the boundaries of what's feasible <ref:2501.12072#pg4>. We need more rigorous tests on how these codes perform under even more complex noise models than those discussed <ref:two thousand five hundred one point one two zero seven two#pg3.

Lev: I agree, we still need to see how this scales up beyond the current n=eight examples they've constructed, and understanding those scaling limits is key for any practical quantum hardware development <ref:2501.12072#pg4>.

Kai: So, in summary, the authors have given us a detailed, systematic protocol—a real construction method—for generating distance-three non-CSS codes from graph states that are specifically designed to fight hook errors during syndrome extraction <ref:2501.12072#pg0>. This is a tangible tool for anyone looking to design better error correction circuits.

Mira: That's the essence of it; it moves the research forward by providing a concrete, analytically sound path from graph theory to fault-tolerant quantum codes <ref:2501.12072#pg4>. This systematic generation method is what makes this paper important for theoretical condensed matter physics applied to quantum computing <ref:2501.12072#pg3>.

Harsh Gupta, Mainak Bhattacharyya, Ritik Jain, Ankur Raina

Department of Electrical Engineering and Computer Science, Indian Institute of Science Education and Research Bhopal

quant-ph, cs.IT, math.IT

Submitted: 2025-01-21

Updated: 2026-10-03

Comments: We changed the entire manuscript with the following major changes: We expanded the bare code definition. The earlier eight-qubit extension has been replaced by general pendant-extension and blockwise-composition results for \([[n,k,3]]\) BAC, with their limitations stated clearly, refer to section IV. 21 pages, 6 figures

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

Importance score: 72/100

The gist: Fault-tolerant syndrome extraction in [[n, 1, 3]] non-CSS codes using graph states provides a systematic framework for constructing bare ancilla codes that are resilient against hook errors.

Key concepts

Graph Codes: These are quantum states based on an undirected graph where vertices represent qubits and edges represent CZ gates. The paper uses these structures, derived from Measurement-Based Quantum Computing (MBQC), to systematically construct non-CSS codes by performing specific measurements on the graph state.
Hook Errors: These are specific types of correlated errors that occur when syndrome extraction is performed. They happen when a single Pauli error on an ancilla qubit influences the measurement outcome, causing errors that are hard to correct without special protection.
Bare Ancilla Code (BAC): A BAC is a type of quantum code constructed using ancillary qubits and graph states. The goal here is to use this construction method to build codes that are inherently fault-tolerant against hook errors, ensuring the code's logical properties are preserved.
Distance-Three Codes: A distance-three code is a fundamental type of quantum error correcting code where any two distinct codewords are separated by at least three errors. The paper proves that the constructed codes maintain this crucial property, which is essential for reliable encoding of logical information.

Terminology

CSS Codes — 11× in this paper · explained in 2 episodes
Core — 4× in this paper · explained in 2 episodes
Adjacency Matrix — 3× in this paper · explained in 1 episode
Ancillary Qubits — 3× in this paper · explained in 1 episode
Benchmark — 3× in this paper · explained in 2 episodes
IEEE International Symposium on Information Theory — 3× in this paper
Ancilla Qubits — 2× in this paper · explained in 1 episode
Measurement-Based Quantum Computing — 2× in this paper
Redundancy — 2× in this paper · explained in 2 episodes
Verification — 2× in this paper · explained in 2 episodes
Distance Preservation — 1× in this paper · explained in 2 episodes
Entanglement — 1× in this paper · explained in 3 episodes
Fidelity — 1× in this paper · explained in 2 episodes
Hilbert Space — 1× in this paper · explained in 2 episodes
Stabilizer States — 1× in this paper · explained in 2 episodes
Structural Constraints — 1× in this paper · explained in 2 episodes

Summary

Fault-tolerant syndrome extraction in [[n, 1, 3]] non-CSS codes using graph states provides a systematic framework for constructing bare ancilla codes that are resilient against hook errors. This work constructs and analyzes a family of [[n, 1, 3]] bare ancilla codes (BACs) derived from graph codes to demonstrate fault tolerance against noisy syndrome measurements under anisotropic and circuit-level depolarizing noise models.

Code Construction via Graph Codes

The paper introduces a systematic framework for constructing non-CSS BACs from graph codes using measurements on graph states, rooted in the Measurement-Based Quantum Computing (MBQC) setting. The construction begins with an undirected graph state defined by a graph G = (V, E), where V corresponds to qubits and E represents CZ gates. Encoding is implemented by measuring message qubits in the X basis, leading to a parity-check matrix H = [Hx Hz] which incorporates an adjacency matrix Acc and a connection matrix Acm. The encoding procedure involves an iterative process described in Algorithm 1, which modifies the parity check matrix by selecting pivot rows based on the target qubit index to isolate message qubits and reduce the matrix dimension from n × 2(n + k) to (n − k) × 2n, resulting in a non-CSS [[n, k, d]] code.

Fault Tolerance Against Hook Errors

The core challenge addressed is hook errors—correlated errors on data qubits caused by single Pauli errors on the ancilla qubit during syndrome extraction. The paper establishes conditions for fault tolerance based on stabilizer weights. Lemma 1 states that for any stabilizer generator g with weight wg > 3, the number of uncorrectable hook errors is bounded by Ug ≤ wg − 3. Corollary 2 extends this to bound the total number of abundant unique syndromes required: Su ≥ Xg∈S wg>3 (wg − 3). Furthermore, Lemma 3 addresses correlated two-qubit gate errors, showing that if the weight of a stabilizer satisfies wg > 3, the number of uncorrectable hook errors is at most Ug ≤ 3(wg − 2). Corollary 4 provides a condition for fault tolerance against correlated ancilla-data two-qubit gate errors: Su ≥ Xg∈S wg≥3 3(wg − 2).

Bare Ancilla Code Family Generation

The construction of the BAC family involves a two-stage process. First, Algorithm 2 searches for admissible orderings of Pauli operators within each stabilizer generator g, where the ordering is chosen to extract distinct syndromes for hook errors. Second, Algorithm 3 performs a global compatibility check to ensure that the selected generators form a valid [[n, 1, 3]] BAC. The algorithm ensures that the set of syndromes for uncorrectable hook errors does not collide with syndromes already assigned to correctable single-qubit data errors (set Ωinit), and it verifies that each accepted generator is linearly independent (rank test).

Preservation of Code Properties

The resulting family of codes, denoted as Bn for n ≥ 8, is analytically proven to preserve the distance-three property of the base code B8. Lemma 5 demonstrates that the logical operators XL and ZL of the base code commute with all stabilizer generators in Bn and satisfy anticommutativity between themselves. Theorem 6 concludes that if the base code B8 is a distance d = 3 code, then all codes Bn in the family are also distance d = 3 codes, ensuring that encoding a single logical qubit preserves this property.

Performance Evaluation

The performance of the constructed BACs is validated through numerical error rate simulations comparing them against the flag-qubit method. The simulations are performed under two noise models: standard depolarizing noise and anisotropic noise. The results show that the [[6, 1, 3]] BAC offers no pseudo-threshold for standard depolarizing noise but shows asymptotic fault tolerance under the anisotropic noise model with its most optimized code rate. For codes with larger n, such as [[7, 1, 3]] and [[12, 1, 3]], the bare method either outperforms or performs similarly to the flag-based method in terms of pseudo-thresholds for depolarizing noise and under anisotropic noise models. The analysis confirms that the bare method yields a pseudo-threshold for depolarizing noise that is almost the same as the flag method’s from [[7, 1, 3]] onwards.

Conclusion

The work successfully constructs and analyzes a family of [[n, 1, 3]] non-CSS QECCs using graph codes that are fault-tolerant against hook errors. The findings provide a systematic framework for finding FT codes from graph codes and identify the most optimized BAC, namely the [[6, 1, 3]] code. Future work is suggested in extending these constructions to longer distances or multiple logical qubit codes.

Improvements for AI systems

As a fastidious researcher, I have thoroughly analyzed this paper on fault-tolerant syndrome extraction in non-CSS codes using graph states. The key contributions lie in constructing and proving the properties of a family of [[n, 1, 3]] Bare Ancilla Codes (BACs) derived from graph codes that enable fault tolerance against hook errors using only a single bare ancilla qubit.

Here are the specific improvements to AI systems that can be made based on this research:

Specific Improvements for AI Systems

The core improvement is the development of more robust and resource-efficient quantum error correction (QEC) routines, specifically tailored for architectures involving syndrome measurement overhead.

Development of Optimized Syndrome Extraction Algorithms

The paper introduces a systematic framework (Algorithm 2 and Algorithm 3) for constructing BAC stabilizers by searching through permutations of Pauli operators within stabilizer generators to find orderings that yield unique syndromes for hook errors.

Improve Syndrome Mapping: Implement the permutation-based search (Algorithm 2) to automatically identify locally admissible stabilizer orderings. This allows the AI system to dynamically select the optimal sequence of two-qubit gates during syndrome measurement preparation, minimizing the chance of hook errors propagating into data qubits.

Implement Global Compatibility Check: Integrate Algorithm 3 to perform a global compatibility check on these local choices. The AI should verify that the resulting set of ordered generators is linearly independent (rank test) and that their total syndrome space satisfies the necessary bounds derived from Corollaries 2 and 4, ensuring no syndrome collisions occur between data errors and hook errors.

Enhanced Noise Model Resilience

The research provides explicit simulations under both standard depolarizing noise and anisotropic noise (relevant to ion traps).

Adaptive Decoding for Anisotropic Noise: Train the AI's lookup-table decoder specifically on the syndrome patterns generated under the anisotropic noise model. This allows the system to distinguish between correlated errors arising from two-qubit gate faults and single-qubit data errors more effectively than a standard decoder, leveraging the refined syndrome space bounds derived for this noise type.

Threshold Estimation: Use simulation results (Figure 5 and Figure 6) to dynamically estimate the pseudo-thresholds for different code sizes [[n, 1, 3]] codes under specific noise profiles. This enables the AI to select the most robust code structure (e.g., identifying [[6, 1, 3]] as having the best rate under anisotropic noise).

Resource-Aware Code Selection

The paper demonstrates that certain codes are optimized for specific error types or noise models (e.g., [[6, 1, 3]] for anisotropic noise).

Automated Code Mapping: Develop a module that takes a target quantum channel/noise model as input and automatically selects the corresponding optimal BAC family (e.g., mapping to [[6, 1, 3]] if anisotropic noise is dominant), optimizing the code rate while maintaining fault tolerance.

What the Improved AI System Can Do

The improved AI system will function as a highly sophisticated quantum circuit optimizer and error-correction manager:

Fault-Tolerant Circuit Synthesis: The system can synthesize quantum circuits for computation that are inherently designed to resist hook errors during syndrome extraction. It will automatically embed the optimal, permuted stabilizer measurement sequence into the circuit layout, ensuring that single ancilla faults do not generate uncorrectable data errors.
Real-time Error Diagnosis and Correction: During a live quantum computation, when syndrome measurements are performed, the system will use its lookup table (populated with both standard data syndromes and hook error syndromes) to instantaneously diagnose the type of error that occurred (single-qubit data error vs. correlated hook error). It will then apply the precise correction dictated by the optimized BAC decoding scheme.
Code Design and Parameter Selection: Given a desired logical qubit requirement and an estimated physical noise model (e.g., Ion Trap Anisotropic Noise), the AI will propose the most efficient [[n, 1, 3]] code structure to use, providing a predicted pseudo-threshold for that specific configuration.
Performance Benchmarking: The system can compare the performance of its proposed FT syndrome extraction against alternative methods (like the flag-qubit method) under various noise conditions, allowing researchers to quantitatively determine if the bare ancilla method offers a genuine advantage in terms of logical error rates and required ancillary resources.

Abstract

The reliability of quantum computation critically depends on the performance of quantum error-correcting codes (QECCs). Performance of QECCs can be severely degraded by hook errors, which effectively reduce the code distance. We develop a systematic framework for bare-ancilla syndrome extraction in [[n,k,3]] stabilizer codes. It provides a criterion for a specific single ancilla fault model and jointly searches for suitable stabilizer generators and data-ancilla interaction orders to correct hook errors. We call such stabilizer generator sets bare-ancilla codes (BACs). We also present two constructions that enlarge the set of valid BACs while preserving minimum distance, either by keeping the number of logical qubits fixed or by increasing it. Under the correlated-data error model, 3177 [[7,1,3]] graph codes are found to be BACs out of 3379 and all 335415 [[8,1,3]] graph codes are BACs. We tested 500 [[7,1,3]] and 1000 [[8,1,3]] graph codes in the presence of anisotropic and depolarizing noise. The number of data-ancilla interactions is an important predictor of the pseudo-threshold of these graph codes. In the analyzed codes, the BAC, which works with the bare ancilla method, usually performs well or better than the flag method, particularly for depolarizing noise. Notably, we report new bare ancilla codes, namely [[6,1,3]] and [[7,1,3]] with improved code rate compared to the bare code used in the work of Muyuan Li et al. and Maheshwari et al. respectively.