⚛️ quantum physics

A Unitary Encoder for Surface Codes

This paper proposes a novel non-local unitary circuit for encoding surface codes that halves the gate count of previous methods, enables efficient preparation of inaccessible eigenstates, and demonstrates superior performance in relevant noise regimes for platforms with non-local interactions like neutral atoms and trapped ions.

Original authors: Pei-Kai Tsai, Shruti Puri

Published 2026-10-20

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Pei-Kai Tsai, Shruti Puri

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 machine that can solve problems beyond the reach of today's computers, scientists are turning to a field called quantum error correction. Imagine trying to keep a delicate message safe while it travels through a stormy sea; the waves and wind represent the constant noise and interference that plague quantum computers, threatening to scramble the information they hold. To survive this, researchers do not rely on a single, fragile piece of information. Instead, they weave that information into a complex, entangled pattern spread across many physical particles, creating a safety net. If some particles get knocked off course by the noise, the pattern itself reveals the mistake, allowing the system to fix it without ever looking directly at the secret message. This approach is essential for building a reliable quantum computer, and one of the most promising patterns used for this safety net is known as the surface code. It arranges particles on a flat grid, using local connections to check for errors, much like neighbors checking on one another to ensure everyone is still in their proper place.

The challenge, however, lies in how to create these intricate patterns in the first place. Before a quantum computer can begin its work, it must first prepare a specific starting state, a kind of "ready" position for the entire grid. The standard way to do this involves a slow, repetitive process of measuring the neighbors and adjusting the particles based on the results, a method that works well but takes a significant amount of time. A new study by researchers at Yale University proposes a different path. They have designed a faster way to build these starting patterns using a specific type of circuit that connects particles across the grid in a non-local way, rather than just between immediate neighbors. By treating the process as a transformation between two slightly different versions of the grid pattern, they found a method that cuts the time required to prepare the state nearly in half compared to the fastest known alternative.

The researchers focused on a specific type of grid pattern called the surface code, which comes in two main flavors: a regular version and a rotated version. While both serve the same purpose of protecting information, they differ in how their edges are shaped and how many particles they require to hold the same amount of data. The team's breakthrough came from realizing that these two versions could be converted into one another using a sequence of simple operations. They devised a four-step process that starts with a small, rotated grid and transforms it into a larger, regular grid, and then transforms that regular grid into an even larger rotated grid. This sequence effectively doubles the size of the protective pattern in just four moments of time, a speed that previous methods could not match. While other fast methods existed, they required seven steps to achieve the same growth, making the new approach significantly more efficient.

To ensure this speed did not come at the cost of reliability, the team ran extensive computer simulations to test how their new circuit would behave in the presence of noise. They compared their non-local method against the traditional, slower measurement-based approach and a local method that only connects neighboring particles. The results showed that for the sizes of grids that are currently relevant for experiments, the new non-local circuit actually produced fewer errors than the traditional method. This was a surprising finding, as it was previously thought that connecting particles across long distances would spread errors more easily, making the final result more fragile. The simulations revealed that the errors still behaved in a way that could be corrected by standard tools, meaning the speed advantage did not sacrifice safety. In fact, because the new method avoids the slow measurement steps that plague other techniques, it could generate the necessary starting states much faster, especially on hardware where measurements are slow, such as systems using trapped ions or neutral atoms.

The study highlights that this new encoder is particularly well-suited for platforms where particles can be moved or connected over long distances, a capability found in certain advanced quantum hardware. By bypassing the need for the standard, time-consuming measurement cycles, the researchers offer a practical shortcut for preparing the complex states needed for quantum computation. Their work suggests that for specific types of quantum states, which are difficult to create and essential for performing advanced calculations, this faster, non-local approach could be the key to unlocking more efficient and reliable quantum machines. The findings provide a concrete path forward for experimentalists, showing that a different way of thinking about how to build these protective patterns can lead to better performance in the noisy, real-world conditions of a laboratory.

Technical Summary: A Unitary Encoder for Surface Codes

Problem Statement
Preparing logical states in quantum error correction (QEC) codes, particularly the surface code, is a fundamental step for fault-tolerant quantum computation. The standard approach involves initializing qubits in a product state and repeatedly measuring stabilizer generators to entangle the system into the desired logical eigenstate. While effective for Pauli eigenstates (e.g., $|0_L\rangle$ , $|+_L\rangle$ ), this method is not fault-tolerant for non-Clifford states (e.g., $T$ -magic states) and can be time-consuming, especially on hardware where measurements are slow compared to gate operations.

Alternative approaches use unitary encoding circuits to map a small initial code state to a larger one. However, existing local unitary encoders are constrained by the finite speed of entanglement propagation, requiring a circuit depth of $\Omega(d)$ (where $d$ is the code distance). Non-local encoders based on Multi-scale Entanglement Renormalization Ansatz (MERA) or graph-state decomposition can achieve logarithmic depth $\Omega(\log d)$ , but they often incur significant overhead; for instance, MERA-based circuits require seven time steps to double the code distance. Furthermore, there is a concern that non-local circuits might propagate errors in ways that render conventional decoders ineffective.

Methodology
The authors propose a new non-local unitary encoding circuit that achieves the asymptotic depth lower bound of $\Omega(\log d)$ while reducing the constant overhead by nearly half compared to previous non-local methods. The protocol is based on a code conversion strategy between two variants of the surface code: the rotated surface code (Rot) and the regular surface code (Reg).

The encoding process to grow a code from distance $d$ to $2d-1$ (specifically transforming $\text{Rot}(d)$ to $\text{Rot}(2d-1)$ ) is executed in two stages, each taking two time steps, for a total depth of four:

Stage 1 (Rot to Reg): Starting with a $\text{Rot}(d)$ code, additional "face qubits" are introduced on the stabilizer faces. A sequence of CNOT gates (applied in two parallel rounds) converts the $\text{Rot}(d)$ state into a $\text{Reg}(d)$ state. This stage effectively utilizes the first half of a standard stabilizer measurement circuit.
Stage 2 (Reg to Rot): Starting with the resulting $\text{Reg}(d)$ , another set of face qubits is added. A second sequence of CNOT gates (applied in two parallel rounds) converts the $\text{Reg}(d)$ into a $\text{Rot}(2d-1)$ code.

The authors prove the validity of this conversion by tracking the evolution of stabilizers and logical operators through the circuit, demonstrating that the four-step gate sequence correctly maps the stabilizer group of the initial code to that of the final, larger rotated code.

Key Contributions

Reduced Circuit Depth: The proposed encoder doubles the code distance in four time steps. This is a significant improvement over MERA-based non-local encoders, which require seven steps to achieve a similar expansion. Consequently, the total depth to prepare a $\text{Rot}(d)$ code from a small initial block is $4 \log_2 d + O(1)$ , compared to $7 \log_2 d + O(1)$ for MERA.
Decoder Compatibility: Contrary to the intuition that non-local error propagation would complicate decoding, the authors demonstrate that a single physical error (X or Z) propagates to a Pauli string that still anti-commutes with only a pair of stabilizers. This allows the use of conventional Minimum-Weight Perfect Matching (MWPM) decoders (specifically PyMatching) without modification.
Efficient Preparation of Hard-to-Access States: The encoder is particularly suited for preparing eigenstates of operators that are difficult to access transversally, such as the Pauli $Y$ -eigenstate ( $|+i_L\rangle$ ) and Clifford eigenstates.

Results
The authors performed numerical simulations comparing three methods for preparing the $|+i_L\rangle$ state:

The proposed non-local unitary encoder.
A previously proposed local unitary encoder.
The conventional stabilizer-measurement approach.

Key findings include:

Logical Error Rates: In experimentally relevant noise regimes (where two-qubit gate and measurement errors are dominant), the non-local encoder outperforms both the local unitary encoder and the conventional stabilizer measurement approach for code distances up to $d_f \approx 9$ and even at $d_f = 17$ . The local encoder suffers from increased idle errors due to its larger circuit depth, while the conventional method is limited by the error accumulation in the initial small code and fixed measurement rounds.
Time Efficiency: The non-local encoder is significantly faster. Assuming measurements are an order of magnitude slower than two-qubit gates (a common constraint in neutral atom and trapped ion platforms), the non-local encoder requires fewer steps to reach a target distance and avoids the latency of repeated stabilizer measurements. It is faster than the conventional method for $d_f \lesssim 17$ .
Noise Dependence: The performance advantage of the non-local encoder over the local encoder widens as the final code distance increases, provided that single-qubit idle errors are not negligible compared to gate errors.

Significance and Claims
The paper claims that this non-local unitary encoder provides a practical advantage for quantum hardware platforms that support non-local interactions, specifically neutral atoms and trapped ions. In these systems, long-range connectivity allows the implementation of the non-local gates, while the slower measurement speeds make the unitary approach (which bypasses repeated measurements) highly attractive.

The authors emphasize that while unitary encoders generally do not increase the "fault-distance" (the error-correcting capability remains limited by the initial code block), they offer a space-time efficient realization of specific logical states. The work suggests that this protocol is a viable alternative for preparing non-Clifford states and could be integrated into existing surface code infrastructure, as the gate sequences resemble the first half of standard stabilizer measurement cycles. The authors conclude that this method opens directions for generating low-error magic states via cultivation and preparing ansatz states for quantum algorithms.

Technical Summary: A Unitary Encoder for Surface Codes

More like this