Fault-tolerant syndrome extraction in [[n,1,3]] non-CSS code family generated using measurements on graph states

This paper introduces a family of fault-tolerant $[[n,1,3]]$ non-CSS quantum error-correcting codes generated via graph states and the bare-ancilla method, demonstrating their resilience against hook errors and superior performance compared to existing flag-qubit and bare-ancilla approaches under various noise models.

The Gist

The Big Picture: Fixing a Leaky Boat

Imagine you are trying to sail a boat (a quantum computer) across a stormy ocean. The boat is made of many small planks (qubits). The problem is that the ocean is rough, and the planks are constantly getting hit by waves (noise), causing them to rot or break. If too many planks break, the boat sinks (the calculation fails).

To keep the boat afloat, you need a repair crew (Quantum Error Correction). Their job is to constantly check the planks for damage and fix them before the boat sinks.

The Problem:
Usually, the repair crew uses special tools (ancilla qubits) to check the planks. But here's the catch: if the tool itself breaks or slips while checking, it can accidentally knock over multiple planks at once. This is called a "hook error." It's like a clumsy inspector who, while trying to fix one loose nail, accidentally rips out three others. This makes the repair crew less effective than they should be.

The Solution: A Smarter Inspection Routine

The authors of this paper have designed a new, smarter way for the repair crew to inspect the boat. They created a family of new "repair codes" (called Bare Ancilla Codes) that can handle these clumsy inspectors without needing extra safety gear.

Here is how they did it, broken down into simple steps:

1. The Blueprint: Graph States

Instead of guessing how to arrange the planks, the authors used a specific type of blueprint called a "Graph State."

• Analogy: Imagine a map of a city where the intersections are the planks and the roads are the connections between them.
• The authors used this map to generate a specific set of rules (stabilizers) for how the planks should behave. They found that by rearranging the order in which the inspectors check the planks on this specific map, they could prevent the "hook errors" from causing chaos.

2. The Trick: Rearranging the Order

In the old methods, inspectors had to use extra "flag" qubits (like having a second inspector stand by to shout "Stop!" if the first one dropped their tool). This required more resources (more planks/tools).

The authors found a way to do it with just one inspector (a "bare" ancilla) by simply changing the order in which they check the planks.

• Analogy: Imagine a security guard checking a line of people. If they check Person A, then Person B, then Person C, and the guard trips at Person B, they might accidentally bump Person C.
• The Fix: The authors realized that if the guard checks them in a specific, different order (e.g., C, then A, then B), a trip at Person B only affects Person A, and the pattern of the "trip" is unique enough that the system knows exactly what happened and can fix it without needing a second guard.

3. The Result: A Family of Codes

They didn't just find one solution; they found a whole family of solutions (codes) that work for different sizes of boats — they ran simulations for sizes from 6 planks up to 16, and gave a mathematical proof that a code exists for any size n greater than 6.

• They proved mathematically that these new codes can catch errors even if the single inspector makes a mistake.
• They showed that these codes are just as good, and sometimes better, than the older methods that required extra "flag" qubits.

What They Tested

To make sure their idea actually works, they ran computer simulations (digital experiments) with two types of "storms":

1. Standard Storm: Random waves hitting from all directions (Depolarizing noise).
2. Biased Storm: Waves that hit in a specific, predictable pattern (Anisotropic noise, common in ion-trap computers).

The Findings:

• Their new "Bare Ancilla" method works very well.
• In some cases, it performs just as well as the older, more expensive methods that use extra "flag" qubits.
• In other cases (specifically with the "Biased Storm"), their method is actually better and requires fewer resources.
• They found a specific code (the [[6, 1, 3]] code) that is the most efficient (highest "code rate") for the biased storm, meaning it gets the most work done with the least amount of extra material.

Summary

The paper is about building a more efficient repair system for quantum computers. By using a clever mathematical map (Graph Codes) and simply changing the order in which checks are performed, they created a system that stops "clumsy inspector" errors (hook errors) without needing extra hardware. This makes quantum computers potentially cheaper and more reliable to build.

Technical Summary

Technical Summary: Fault-Tolerant Syndrome Extraction in [[n, 1, 3]] Non-CSS Code Family

Problem Statement
The reliability of fault-tolerant (FT) quantum computation is critically dependent on the performance of Quantum Error-Correcting Codes (QECCs). A significant barrier to achieving high fidelity is the "hook error," a phenomenon where a single physical fault on an ancilla qubit during syndrome extraction propagates through two-qubit interactions to generate correlated errors on multiple data qubits. If unmitigated, these errors effectively reduce the code distance, compromising the code's error-correcting capability. While various FT syndrome extraction schemes exist (e.g., Steane's, Shor's, Knill's, and the flag-qubit method), many incur significant resource overhead. Specifically, the "bare-ancilla" method, which uses a single ancilla qubit without additional verification or flag qubits, has been demonstrated for specific codes like the [[7, 1, 3]] code by Muyuan Li et al., but a systematic framework for generating a broader family of such codes, particularly non-CSS codes with improved rates, has been lacking.

Methodology
The authors propose a systematic framework for constructing a family of [[n, 1, 3]] non-CSS QECCs that are fault-tolerant against hook errors using the bare-ancilla method. The approach integrates three primary components:

1. Graph Code Construction: The authors utilize the Measurement-Based Quantum Computing (MBQC) framework. They start with a graph state (cluster state) and encode logical information by measuring message qubits in the X-basis. This process transforms the graph state into a stabilizer code, where the parity-check matrix is derived from the graph's adjacency matrix. This provides a systematic way to generate non-CSS stabilizer codes.
2. Syndrome Space Analysis and Bounds: The paper derives explicit conditions under which stabilizer codes support bare-ancilla FT syndrome extraction. By analyzing the weight of stabilizer generators ($w_g$), the authors establish quantitative bounds on the number of "abundant" (unused) syndromes required to uniquely identify hook errors.
   • For uncorrelated ancilla errors, the number of uncorrectable hook errors is bounded by $|U_g| \le w_g - 3$.
   • For correlated two-qubit gate errors (a more practical model), the bound is $|U_g| \le 3(w_g - 2)$.
   • The total number of available unused syndromes ($S_u$) must satisfy specific inequalities to ensure all hook errors can be assigned unique syndromes distinct from single-qubit data errors.
3. Algorithmic Construction: Two algorithms are presented to construct the codes:
   • Algorithm 2: Performs a local search to find admissible orderings (permutations) of Pauli operators within each stabilizer generator. It discards orderings that result in trivial syndromes or degenerate (non-unique) syndromes for hook errors.
   • Algorithm 3: Performs a global search to combine locally valid ordered generators into a full stabilizer set. It ensures the resulting code is commuting, linearly independent, has the correct rank ($n-1$), maintains distance $d=3$, and satisfies the syndrome space bounds derived in the theoretical analysis.

Key Contributions

• Systematic Framework: The paper establishes the first general bounds and a systematic algorithm for constructing Bare Ancilla Codes (BACs) from graph codes, moving beyond ad-hoc discovery.
• New Code Family: The authors construct a new family of [[n, 1, 3]] non-CSS BACs for all $n \ge 8$. This family is derived by extending a base graph code, $B_8$ (an [[8, 1, 3]] code), and analytically proving that the fault-tolerant properties (specifically the ability to assign unique syndromes to hook errors) are preserved under this extension.
• Optimized Code Rate: The work identifies a new bare ancilla code with an improved code rate compared to previous works. Notably, the [[6, 1, 3]] code is identified as having the most optimized code rate in the family, showing asymptotic fault tolerance under anisotropic noise, despite lacking a pseudo-threshold under standard depolarizing noise.
• Benchmarking: The performance of the proposed BACs is benchmarked against the flag-qubit method (Chao et al.) using custom lookup-table decoders under both anisotropic and circuit-level depolarizing noise models.

Results
Numerical simulations using the CHP (CNOT-Hadamard-Phase) stabilizer simulator yielded the following findings:

• Performance Comparison: The proposed bare-ancilla codes demonstrate competitive, and in several cases superior, logical error rates compared to the flag-qubit method.
• Pseudo-thresholds:
  • Under anisotropic noise, the bare method performs almost equally to or better than the flag method for codes starting from [[6, 1, 3]].
  • Under standard depolarizing noise, the bare method yields pseudo-thresholds comparable to the flag method for codes from [[7, 1, 3]] onwards.
  • The [[6, 1, 3]] BAC shows no pseudo-threshold for depolarizing noise due to insufficient syndrome space for correlated hook error correction, but it does exhibit a non-zero pseudo-threshold under anisotropic noise.
• Resource Efficiency: The proposed BACs achieve these results while requiring fewer ancillary resources (only one bare ancilla qubit) compared to the flag-qubit method, which typically requires additional qubits for verification.

Significance
The paper claims that its primary significance lies in providing a constructive pathway to discover FT codes directly from graph structures. By demonstrating that a systematic extension of a base graph code ($B_8$) preserves the bare-ancilla property, the authors show that high-rate, fault-tolerant non-CSS codes can be generated without the overhead of flag qubits. The identification of the [[6, 1, 3]] code as a highly optimized candidate for anisotropic noise environments (common in trapped-ion systems) highlights the practical utility of this framework. The work bridges the gap between theoretical graph code constructions and practical fault-tolerant syndrome extraction, offering a resource-efficient alternative to existing FT schemes.