A Unitary Encoder for Surface Codes

summary

Video file (mp4)

The gist

The gist: This work proposes a new non-local unitary circuit to encode a surface code state based on a code conversion between rotated and regular surface codes, which halves the gate count of the

In short

This work proposes a new non-local unitary circuit to prepare surface code states by converting between rotated and regular surface codes. This method halves the gate count compared to previous fastest encoders, achieving an asymptotic circuit depth of log n. The new encoder outperforms local and conventional methods in terms of logical error rates and preparation time for experimentally relevant noise levels.

Key concepts

Surface Code Variants (Reg(d) vs Rot(d))
The paper compares two types of surface codes: the regular code (Reg(d)) and the rotated code (Rot(d)). They are both defined on square lattices but differ in how their boundaries are structured. The rotated code requires fewer data qubits for the same distance, making it potentially more efficient for encoding.
Local Unitary Encoders
These are encoding circuits that only use local two-qubit gates. They require a depth of Omega(d) time steps to prepare surface code states. This method is limited by the finite speed at which entanglement can spread across the lattice, making it slower than non-local approaches.
Non-local Unitary Encoders
These circuits use gates that are not restricted to nearest neighbors, allowing them to achieve an asymptotic circuit depth of Omega(log n). This is achieved through techniques like MERA or graph-state decomposition, enabling much faster state preparation for large codes.
Code Conversion Circuit
This is the core mechanism proposed: a unitary circuit that transforms a Rot(d) surface code into a Rot(2d - 1) code in just four stages. This conversion is used as the basis for the new, highly efficient non-local encoder.

Terminology used across episodes

This episode discusses

The paper

A Unitary Encoder for Surface Codes · Read on arXiv

Pei-Kai Tsai, Shruti Puri

Yale University · Yale Quantum Institute

The surface code is a promising candidate for fault-tolerant quantum computation and has been implemented in many quantum hardware platforms. In this work, we propose a new non-local unitary circuit to encode a surface code state based on a code conversion between rotated and regular surface codes, which halves the gate count of the fastest encoder known previously. While the unitary encoders can be used to increase the code distance, the fault-distance remains fixed. Nonetheless, they can be used for space-time efficient realization of eigenstates of the surface code operators that can't be easily accessed transversally such as the Pauli Y-eignestate and Clifford eigenstates. It may be expected that error propagation in the non-local circuit will make decoding more challenging compared to local unitary encoding circuits. However, we find this not to be the case and that conventional matching decoders can be effectively used. Furthermore, we perform numerical simulations to benchmark the performance of our encoder against a previous local unitary encoder and the conventional stabilizer-measurement based encoder for preparing the Pauli Y-eigenstate and find that our encoder can outperform these in experimentally relevant noise regimes. Therefore, our encoder provides practical advantage in platforms where non-local interactions are available such as neutral atoms and trapped ions.

DOI: 10.1038/s41534-026-01322-y

Transcript

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

Kai: We're looking at the paper: "A Unitary Encoder for Surface Codes".

Mira: Here's the gist of the paper. The gist: This work proposes a new non-local unitary circuit to encode a surface code state based on a code conversion between rotated and regular surface codes, which halves the gate count of the fastest encoder known previously.

Kai: Quantum error correction (QEC) codes are essential for fault-tolerant quantum information, with the quantum surface code being a promising candidate due to its geometrically local structure and high error correcting noise threshold <ref:2506.04084#pg2>.

Mira: Target states in QEC codes are prepared either by initializing qubits in a product state that is an eigenstate of the logical operator and then measuring all stabilizer generators several times, or by using a unitary encoding circuit that maps an initial product state to an n-qubit code state <ref:2506.04084#pg2>.

Kai: While local unitary encoding circuits have a lower bound of depth omega(√n) due to the finite spreading speed of entanglement, non-local unitary encoding circuits based on multi-scale entanglement renormalization ansatz (MERA) or graph-state decomposition can achieve an asymptotic circuit depth lower bound of omega(log n) <ref:2506.04084#pg4>.

Title and authors: Kai: We’ve seen how this new approach aims to reduce the gate count by using a specific conversion circuit between rotated and regular surface codes, which is what "A Unitary Encoder for Surface Codes" is all about.

Mira: It's basically about finding a way to prepare a surface code state that takes fewer steps than the existing best method, which usually requires exponential time or at least polynomial time in the distance.

Lev: If we can really cut down the gate count, even with this non-local approach, it means less noise during preparation and potentially faster overall computation on real hardware.

Kai: The paper lays out that they are focusing on two types of surface codes: the regular surface code and a rotated surface code.

Mira: And these two variants differ mainly in how their boundaries are structured, specifically whether they use three-body stabilizers or two-body stabilizers along the edge of the lattice.

Lev: The difference between those boundary conditions seems to be what opens up this possibility for a more efficient unitary encoding circuit, so it’s a structural change driving the speedup.

The paper's summary: Kai: So what is this new non-local unitary encoder actually doing? The paper introduces a protocol that grows a rotated code from distance d to distance 2d minus one in just four steps <ref:2506.04084#pg2>.

Mira: That four-step process is the core mechanism of their proposed circuit, transforming a Rot(d) to a Rot(2d minus one) surface code state <ref:2506.04084#pg2>.

Lev: The paper suggests this is achieved by placing qubits in specific states on stabilizer faces and bulk sites during these initial steps, which then leads into the final four-step sequence.

Kai: They also mention that this non-local approach is better than just local unitary encoders, which take about d time steps to increase the code distance.

Mira: The summary highlights that while local methods are polynomial in the distance, this non-local circuit achieves an asymptotic depth bound of omega(log n), which is much faster for large codes.

Lev: That logarithmic depth is what really matters for scaling up to very large surface codes, because if the circuit depth grows slowly with the size of the code, it keeps preparation time manageable.

The paper's improvements: Kai: The authors highlight that this new non-local encoder can outperform both local unitary encoders and the conventional approach based on stabilizer measurements in terms of logical error rates.

Mira: They found that for small but relevant final code distances, like df less than or equal to nine their non-local encoder actually yields the lowest logical error rates compared to the others.

Lev: That's a big deal because it means lower error accumulation during state preparation when we’re trying to prepare something useful in a noisy environment.

Kai: Furthermore, at df equals seventeen their non-local encoder is even better than the local encoder and beats the conventional approach which gets slowed down by those length measurements <ref:2506.04084#pg3>.

Mira: The paper also suggests that this method is space-time efficient for realizing eigenstates of surface code operators that are hard to access directly, like the Pauli Y-eigenstate and Clifford eigenstates.

Lev: That makes sense because standard methods often require more complex sequences to access those specific states, but this circuit seems to provide a cleaner path for those things.

Conclusion: Kai: So wrapping up the paper "A Unitary Encoder for Surface Codes," the main point is that this non-local unitary encoder beats both the local and conventional methods in terms of logical error rates and preparation time.

Mira: It’s a bit more complex to implement, but if you have nonlocal two-qubit interactions available on your hardware, like trapped ions or neutral atoms, it's perfectly suited for this approach.

Lev: And because the circuit depth is so low for doubling the distance from d to 2d minus one at four steps, it should translate directly into faster expected time per kept shot compared to local encoders <ref:2506.04084#pg2>.

Kai: The authors stress that error propagation in their non-local circuit doesn't make decoding harder; conventional matching decoders still work effectively with it.

Mira: They also point out that this protocol can be used for preparing low-error magic states through cultivation or distillation, which is a practical application for high fidelity states.

Lev: If we look at the full picture of "A Unitary Encoder for Surface Codes," this work shows how structural code conversion can lead to a lower complexity circuit depth, which is something we need when scaling up error correction.

More episodes

← Home