⚛️ quantum physics

Junction Hook Errors in the Color Code

This paper identifies a previously overlooked class of distance-reducing "junction hook errors" in triangular color codes that arise at the meeting point of three colored strings, demonstrating that while these errors prevent the full restoration of circuit-level distance even with optimized schedules, their limited accumulation on logical operators still allows for a significant improvement over uniform scheduling.

Original authors: Salahedeen Issa, Margaret Martonosi

Published 2026-10-27

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Salahedeen Issa, Margaret Martonosi

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

In the quest to build a working quantum computer, scientists are trying to solve a problem of extreme fragility. The basic units of information, called qubits, are so sensitive that the slightest disturbance can corrupt the data they hold. To fight this, researchers use error-correcting codes, which spread a single piece of information across many physical qubits, creating a safety net. If one qubit fails, the others can reveal the mistake and fix it without destroying the information. One promising design for this safety net is the triangular color code, a pattern of qubits arranged in a triangle where three different colors—red, green, and blue—interact in a specific way. The goal is to make these codes robust enough to run complex calculations, but a persistent threat known as "hook errors" has made this difficult. These errors occur when a single mistake in the measurement process spreads to multiple data qubits, potentially causing a chain reaction that looks like a legitimate piece of information rather than a mistake.

A recent study by Salahedeen Issa and Margaret Martonosi at Princeton University investigates a new method for measuring these codes, a method that was previously thought to have solved the hook error problem. The researchers found that while the new method successfully avoids many types of dangerous errors, it leaves behind a specific, overlooked vulnerability. They discovered a new class of errors, which they call "junction hook errors," that can still slip through the cracks. These errors happen at the precise point where the three colored paths of information meet in the middle of the code. The study shows that these errors are subtle enough to evade the current safety schedule, meaning that even with the new method, the code is not as safe as previously believed unless additional protections are added to the entire system, not just the edges.

To understand the significance of this discovery, one must first visualize how information travels in a triangular color code. Imagine a large triangle made of tiny tiles, where each tile represents a data qubit. The code is designed so that information can flow from one side of the triangle to the other in three distinct colors. A logical piece of information, which is the actual data being protected, can be thought of as a path made of these colored strings. In the most efficient path, a red string might start at the red edge, a green string at the green edge, and a blue string at the blue edge. These three strings travel inward until they meet at a single point in the middle of the triangle. This meeting point is called a junction. The entire structure relies on the fact that these strings stay on their specific paths and do not accidentally jump to a different color or shortcut across the triangle.

The challenge arises during the process of checking for errors. To ensure the qubits are working correctly, the computer must measure them repeatedly. This measurement is done by connecting a helper qubit, called an ancilla, to the data qubits in a specific sequence. If the helper qubit makes a mistake early in this sequence, that mistake can "hook" onto the data qubits it is about to touch, causing a cluster of errors to appear all at once. In the past, researchers believed that by carefully ordering the sequence of connections for each color, they could prevent these hooks from creating shortcuts that would break the code. A recent paper by Kishony and Fowler proposed such a schedule, arguing that it eliminated all dangerous shortcuts in the middle of the code, leaving only the edges vulnerable.

Issa and Martonosi took a closer look at this proposed schedule and found a flaw in the logic. They realized that the previous analysis only looked for errors that shortened a single colored string. However, they identified a new type of error that behaves differently. At the junction where the red, green, and blue strings meet, there is a specific arrangement of data qubits. If a hook error occurs on two specific qubits at this junction, it does not shorten just one string. Instead, it creates a shortcut that connects two different colored strings simultaneously. Because this error bridges two colors at once, it does not fit the definition of the single-color errors the previous schedule was designed to block. It is like a bridge that connects two different rivers at their confluence; it doesn't shorten the path of either river individually, but it allows water to flow between them in a way that bypasses the intended route.

The researchers verified this finding through detailed simulations on codes of various sizes, specifically distances of 7, 9, and 11. In every case, they found that on almost every non-corner tile in the code, the proposed schedule created a situation where a single hook error, combined with a few other small mistakes, could produce a logical error that the system could not detect. This means the code's ability to protect information was reduced by one step, making it less reliable than the original claim suggested. The study explicitly rules out the idea that the schedule is safe for the middle of the code without further changes. The authors demonstrate that to restore the full safety of the code, one would need to add extra protection mechanisms, such as flag qubits, to the tiles in the middle of the triangle, not just the ones on the boundary.

Despite this setback, the new schedule is not a total failure. The researchers explain that the reason the code still performs better than older methods is that these junction errors are rare in a specific way. While a single-color error could theoretically pile up along a long string of data, a junction error can only happen at the one point where the three strings meet. Since a single piece of information has at most one such meeting point, these errors cannot stack up on the same path to cause a catastrophic failure. This limitation explains why the code's performance improved from a very low level to a much higher one, even though it did not reach the perfect safety level originally hoped for. The remaining gap in safety is caused by a different type of error near the edges, which the researchers note is a separate issue.

The work of Issa and Martonosi serves as a crucial correction to the field, highlighting how complex these systems are and how easily a subtle oversight can leave a door open for errors. By identifying the junction hook error, they provide a clear target for future improvements. The study does not claim to have solved the problem of error correction, but it does clarify exactly where the current solution falls short. It suggests that the path to a reliable quantum computer requires a more comprehensive approach to protecting the code, ensuring that every part of the system, from the edges to the very center, is shielded against these specific, tricky shortcuts. The findings remind the scientific community that in the intricate world of quantum error correction, understanding the geometry of how information flows is just as important as the hardware itself.

Technical Summary: Junction Hook Errors in the Color Code

Problem Statement
The triangular color code is a prominent candidate for fault-tolerant quantum computing, but its performance is limited by "hook errors"—correlated errors that propagate from an ancilla qubit to multiple data qubits during syndrome extraction. Recent work by Kishony and Fowler [1] proposed a color-dependent syndrome extraction schedule designed to mitigate these errors. Their approach identifies "malign" hook errors as those that provide a shortcut for a logical operator by shortening a single string of a specific anyon color (red, green, or blue). By assigning distinct CNOT orderings to stabilizers of each color, their schedule successfully avoids these single-color malign hook errors in the bulk, reportedly improving the circuit-level distance from $d/2$ to $d - \lfloor(d + 3)/6\rfloor$ .

However, the classification of malign hook errors in Ref. [1] relies on the premise that a hook error must correspond to a single type of anyon to be distance-reducing. This paper argues that this classification is incomplete. It identifies a previously overlooked class of distance-reducing errors, termed "junction hook errors," which occur at the point where the three colored strings of a minimum weight logical operator meet.

Methodology
The authors analyze the structure of minimum weight logical operators in the triangular color code. They define a "junction" as a data qubit (not part of the logical operator) where the three colored strings of a logical operator terminate on its neighbors.

Definition of Junction Hook Errors: The authors define a junction hook error as a weight-2 correlated error on two data qubits that terminate two different colored strings at a junction. Unlike single-color hook errors, these do not shorten a single string but provide a shortcut connecting two different colored strings simultaneously.
Schedule Analysis: The authors examine the specific CNOT ordering schedule proposed in Ref. [1]. They map the time steps of data qubit coupling to the geometry of the code to identify which pairs of data qubits are susceptible to weight-2 hook errors.
Verification: Using the integer programming tools and circuit simulations (via Stim) provided by the authors of Ref. [1], the authors verify the existence of these errors. They explicitly check non-corner plaquettes for code distances $d=7, 9,$ and $11$.
Fault Injection: They simulate the injection of an ancilla error (after the relevant CNOT) combined with $d-2$ single data qubit errors on a minimum weight logical operator containing the hook. They verify that this combination of $d-1$ faults produces an undetectable logical error (a logical flip with no detector triggers).

Key Contributions

Identification of Junction Hook Errors: The paper introduces the concept of junction hook errors, demonstrating that they are distance-reducing despite not corresponding to a single anyon type. These errors occur when a hook connects the ends of two different colored strings at a junction.
Refutation of "Bulk Safety": The authors demonstrate that the schedule in Ref. [1] does not avoid all malign hook errors in the bulk. Specifically, every non-corner plaquette (both bulk and boundary) admits a scheduled hook error that, combined with $d-2$ data qubit faults, creates an undetectable logical error using only $d-1$ faults.
Re-evaluation of Circuit-Level Distance: The authors show that because junction hook errors exist in the bulk, protecting only the boundary stabilizers (as suggested in Ref. [1]) is insufficient to restore the full circuit-level distance $d$ . Their simulations confirm a circuit-level distance of $d-1$ (e.g., distance 6 for $d=7$ , distance 8 for $d=9$ ) when bulk stabilizers are unprotected, contradicting the claim that the bulk is free of distance-reducing hook errors.

Results

Existence: For $d=7, 9, 11$ , every non-corner stabilizer in the schedule of Ref. [1] contains a junction hook error.
Impact: A single junction hook error, paired with $d-2$ data qubit errors, forms a logical error of weight $d-1$ . This proves that the schedule does not achieve the full distance $d$ without additional protection on bulk stabilizers.
Accumulation Limit: Unlike single-color malign hook errors, which can accumulate along a long string to drastically reduce distance, junction hook errors cannot accumulate on a single minimum weight logical operator. A minimum weight logical operator has at most one junction. Consequently, the distance is not reduced by a factor of two (as might happen with accumulated single-color hooks) but is reduced by exactly one ( $d \to d-1$ ).
Final Distance: The remaining reduction from $d-1$ to the reported $d - \lfloor(d + 3)/6\rfloor$ is attributed to "fractional hook errors" near the boundary, not the junction hook errors in the bulk.

Significance and Claims
The paper modestly claims to correct a specific classification error in the analysis of Ref. [1]. It does not propose a new schedule or a new error correction protocol. Instead, it clarifies that the schedule in Ref. [1] does not "avoid all malign hook errors in the bulk" as previously stated.
The primary significance is practical: for constructions that rely on the Ref. [1] schedule combined with additional protection (such as flag qubits) only on boundary stabilizers, the full circuit-level distance is not restored. To achieve the full distance $d$ with this schedule, bulk stabilizers must also be protected against hook errors. The paper explains why the schedule still offers a significant improvement over uniform scheduling (avoiding the $d/2$ barrier) despite the presence of junction errors: the geometric constraint that a minimum weight logical operator has only one junction prevents the catastrophic accumulation of these specific errors.

More like this