⚛️ quantum physics

Increasing the distance of topological codes with time vortex defects

This paper proposes a method to enhance topological quantum error-correcting codes by introducing "time vortex" defects that reduce the physical qubit overhead by more than half while maintaining or improving logical error rates, as demonstrated through optimization of the Floquet color code and Monte Carlo simulations.

Original authors: Gilad Kishony, Erez Berg

Published 2026-02-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Gilad Kishony, Erez Berg

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

Imagine you are trying to send a fragile message across a stormy ocean. To keep the message safe, you don't just write it once; you write it on many pieces of paper and scatter them across a fleet of ships. This is the basic idea of Quantum Error Correction: protecting delicate quantum information (qubits) from the "noise" of the real world.

However, there's a catch. To protect the message, you need a lot of ships (physical qubits). The bigger the fleet, the safer the message, but the more expensive and difficult it is to build.

This paper proposes a clever trick to make the fleet smaller while keeping the message just as safe. They call this trick a "Time Vortex."

Here is the breakdown of how it works, using simple analogies:

1. The Problem: The "Guard Patrol"

Think of a topological code (like the Floquet Color Code mentioned in the paper) as a city where every building (qubit) is watched by a security guard. These guards don't just stand still; they patrol in a strict, repeating rhythm.

The Rhythm: Every few minutes, the guards check the locks on the doors. If a door is unlocked, they ring a bell (a "syndrome").
The Flaw: If a thief (an error) sneaks in and moves from building to building faster than the guards can check, they might slip through undetected. The "distance" of the code is basically how many steps a thief must take before they are guaranteed to be caught. To make the city safer, you usually have to build a bigger city (more qubits) so the thief has a longer way to go.

2. The Solution: The "Time Vortex"

The authors realized they could cheat the system by messing with the clock, not the buildings.

Imagine the security guards are walking in a circle around a park. Normally, they all walk at the same speed, checking doors in a perfect loop.

The Twist: Now, imagine there is a "Time Vortex" in the center of the park. As the guards walk around this vortex, their watches get slightly out of sync. One guard checks a door at 1:00, the next at 1:01, the next at 1:02, and so on.
The Result: When the guards complete a full circle around the park, they have "lost" a whole hour (or gained one). The rhythm has been sheared.

3. Why This Makes the City Safer

In a normal city, a thief could sneak along a specific path that aligns perfectly with the guards' checks, slipping through the cracks.

But with the Time Vortex, the "cracks" in the security net are twisted.

The Analogy: Imagine a grid of tiles. In a normal grid, you can walk in a straight line from the start to the finish without stepping on a "trap."
The Vortex Effect: The Time Vortex stretches and twists the grid in the time dimension. Now, that straight line you used to take is no longer a straight line; it's a winding, jagged path. To get from start to finish without triggering a trap, the thief now has to walk a much longer, more complicated route.

Because the thief has to travel further to remain undetected, the "distance" of the code increases. And here is the magic: You get a longer distance without building more buildings. You just rearranged the timing of the guards.

4. The Trade-off: A Longer Shift

Is there a downside? Yes.
Because the guards are out of sync, the whole patrol takes longer to complete one full cycle. The "circuit depth" (the time the system is active) increases.

The Catch: If the guards get tired (idle noise) while waiting for the next check, they might make mistakes.
The Verdict: The authors show that as long as the guards don't get too tired while waiting, the benefit of the longer, safer path outweighs the risk of them getting tired.

5. The Results: Doing More with Less

The authors ran computer simulations (like a video game of the city) to test this.

The Old Way: To get a certain level of safety, you needed a fleet of 42 ships.
The New Way (with Time Vortex): You only needed 30 ships to get the same level of safety.

In fact, for very large systems, they found that the Time Vortex method could cut the number of required ships (qubits) by more than half compared to the old method.

Summary

Think of the Time Vortex as a way to "stretch" the fabric of time in a quantum computer. By making the security checks happen at slightly different times depending on where you are, they force errors to take a much longer, more difficult path to escape detection.

This allows scientists to build smaller, more efficient quantum computers that are just as robust as the massive ones we currently think we need. It's like realizing you don't need a bigger maze to hide your treasure; you just need to twist the walls of the maze so the thief gets lost faster.

1. Problem Statement

Quantum error correction (QEC) is essential for scalable quantum computing, but topological codes often require a large number of physical qubits to achieve a desired logical error rate. The efficiency of a code is often characterized by the ratio of physical qubits ( $N$ ) to the square of the code distance ( $D^2$ ).

The Challenge: In standard topological codes (both static and Floquet), increasing the code distance $D$ typically requires a quadratic increase in the number of physical qubits ( $N \propto D^2$ ).
The Goal: The authors aim to reduce the number of physical qubits required to reach a specific code distance and logical error rate without altering the underlying hardware connectivity (i.e., keeping the same set of qubits and local interactions).

2. Methodology

The authors propose a novel construction involving "time vortices," which are space-time defects introduced into the periodic measurement sequence of topological codes.

Concept of Time Vortices:
- A time vortex is created by introducing a spatially varying delay to the periodic measurement schedule.
- As one traverses a homologically non-trivial cycle around the defect core (e.g., around a hole in a torus), the accumulated time delay equals an integer multiple ( $n$ ) of the measurement period ( $T$ ).
- Mathematically, the delay $\tau(\mathbf{r})$ satisfies $\oint \nabla \tau(\mathbf{r}) \cdot d\mathbf{r} = nT$ .
- Crucially, the set of stabilizer checks and the spatial connectivity of the hardware remain identical to the vortex-free code; only the temporal order of measurements is modified.
Mechanism of Action:
- In topological codes, logical errors correspond to undetectable error chains that form non-trivial loops on the lattice.
- By shearing the space-time lattice of detector cells, time vortices force these undetectable error paths to become longer in the deformed topology.
- This effectively increases the code distance ( $D$ ) for a fixed number of physical qubits, or conversely, reduces $N$ for a fixed $D$ .
Framework:
- The primary analysis is conducted on the Floquet Color Code, a state-of-the-art code for hardware with native 2-body Pauli measurements.
- The authors also briefly apply the concept to the Toric Code (Surface Code).
- They optimize the embedding of the code on a torus by varying the basis vectors ( $L_1, L_2$ ) and the number of vortices ( $n_1, n_2$ ) in each direction.
- Constraints are applied to ensure the local measurement order remains valid (i.e., the delay gradient is not so steep that it disrupts the local commutation relations).

3. Key Contributions

Introduction of Time Vortices: The paper formalizes the use of time-varying delays as a topological defect to enhance code performance, distinct from spatial twists or lattice deformations.
Optimization of Floquet Color Code: The authors perform an exhaustive search over code embeddings on a torus to find the optimal configuration of physical qubits and time vortices.
Theoretical Bounds: They derive that asymptotically, the vortexed code requires less than half the number of qubits compared to the optimal vortex-free code to achieve the same distance.
Circuit-Level Validation: Unlike many theoretical proposals, this work includes Monte Carlo simulations using a realistic circuit-level noise model (EM3) and the Stim/PyMatching decoding stack.

4. Results

Asymptotic Improvement:
- For the Floquet color code, the optimal vortex-free configuration yields a resource ratio $R = N/D^2 \approx 4.5$ .
- The optimal vortexed configuration reduces this ratio to $R \approx 2.11$ .
- This represents a reduction in physical qubits by a factor of ~2.13 for large code distances. Even at modest distances (e.g., $D=4$ ), the reduction factor is ~1.71.
- In the limit of large qubit numbers, the distance in the vortexed code is approximately 1.46 times the distance of the vortex-free code for the same $N$ .
Simulation Benchmarks:
- Threshold: The logical error threshold remains roughly the same (~1.6% – 2%) as the vortex-free code, indicating that time vortices do not degrade the noise tolerance.
- Performance: The vortexed code significantly outperforms the vortex-free code for any physical error rate below the threshold when comparing codes with the same number of qubits.
- Specific Example: A vortexed code with 30 qubits ( $D=3$ ) outperforms a vortex-free code with 42 qubits ( $D=3$ ).
Trade-offs:
- The construction increases the circuit depth (duration) because of the accumulated delays, though the total number of gates remains the same.
- This is beneficial provided the idle error rate of qubits is low compared to gate infidelities.

5. Significance

Resource Efficiency: The work demonstrates a pathway to significantly reduce the hardware overhead (number of physical qubits) required for fault-tolerant quantum computing, a critical bottleneck for near-term devices.
Hardware Agnosticism: The method does not require changing the physical layout or connectivity of the qubits. It only requires software-level control over the timing of measurement sequences, making it highly compatible with existing hardware architectures (particularly 2D lattices with 2-body measurements).
Generalizability: While demonstrated on the Floquet color code and Toric code, the authors suggest this approach could be extended to other code families, including LDPC codes and hypergraph product codes, potentially unlocking even better asymptotic parameters.
New Paradigm: It introduces a new dimension (temporal shearing) to the design of topological codes, complementing existing spatial deformation techniques like "twist defects."

In conclusion, Kishony and Berg demonstrate that by manipulating the temporal dimension of error correction cycles via time vortices, one can effectively "stretch" the code distance, achieving superior error protection with fewer physical resources.