Dense packing of the surface code: code deformation procedures and hook-error-avoiding gate scheduling

This paper presents a detailed code-deformation procedure and a hook-error-avoiding CNOT gate scheduling strategy for densely packed surface codes, demonstrating through circuit-level simulations that this approach reduces space overhead while achieving lower logical error rates than standard surface codes when specific error-mitigation techniques are employed.

The Gist

The Big Problem: Too Much Space for Too Few Things

Imagine you are trying to build a massive library of books (quantum information) that never gets damaged by dust or spills (errors). To protect these books, you decide to put every single one inside a heavy, reinforced steel safe.

The problem is that these "safes" (called Surface Codes) are huge. To store just one book, you need a massive amount of steel and space. If you want to build a library with millions of books, you would need a city-sized building just to hold the safes. This is the main bottleneck for building a powerful quantum computer: we don't have enough physical "bricks" (qubits) to build all these safes.

The Solution: The "Tetris" Packing Trick

The authors of this paper propose a clever way to rearrange these safes. Instead of placing them side-by-side with empty gaps between them (like standard parking spots), they figured out how to fuse them together into a tight, interlocking cluster.

Think of it like Tetris.

• Standard Method: You place your Tetris blocks (safes) in a row with gaps. It's safe, but it wastes a lot of floor space.
• Dense Packing: You slide the blocks together so they interlock perfectly. The paper claims this allows you to fit the same number of books into a space that is only three-quarters the size of the original layout. You save about 25% of the space.

The Catch: The "Hook" Problem

However, just squishing these safes together creates a new problem. In the world of quantum computers, errors can spread like a chain reaction.

Imagine a "hook" error. If a tiny mistake happens on the edge of one safe, it can snag the book inside and pull it out, or worse, drag a mistake from a neighbor into your safe. In the standard, spaced-out layout, these hooks are easy to manage. But when you pack the safes tightly together, the "hooks" can easily reach across the boundaries and cause a chain reaction that ruins the whole library.

The Fix: A New "Traffic Schedule"

To solve this, the authors didn't just pack the safes; they invented a new traffic schedule for the workers inside the library.

In a quantum computer, "workers" (gates) constantly check the books to make sure they are safe. The authors realized that if these workers check the books in a specific, carefully timed order, they can prevent the "hooks" from spreading.

• Old Schedule: Workers check things quickly, but sometimes a mistake slips through the cracks and spreads.
• New Schedule (Hook-Avoiding): The workers take a slightly longer, more deliberate path. They check the books in a specific sequence that ensures if a mistake happens, it gets caught immediately and doesn't drag the neighbors down.

The Results: Better Safety in a Smaller Space

The authors ran computer simulations to test this new "Tetris" library with the new "traffic schedule." Here is what they found:

1. Space Savings: They confirmed that you can indeed pack the quantum codes tightly, using about 25% less space than the old method.
2. Safety: When the physical components are very good (low error rates), this new dense packing is actually safer than the old spaced-out method. The tight packing creates a situation where it takes more mistakes to break the code, effectively making the library more robust.
3. The Condition: This safety boost only happens if you use the new "hook-avoiding" traffic schedule. If you just pack them tight without changing the schedule, the library becomes less safe because the hooks spread too easily.

The Vision: A Hierarchical Library

Finally, the paper suggests a way to use this in a real computer. Imagine a library with two sections:

• The Active Desk: Where you are currently reading and writing. This uses the standard, spaced-out safes because it's fast and easy to access.
• The Archive: Where you store books you aren't using right now. This uses the new "Dense Packing" method. It takes a little more effort to pull a book out (you have to shift the rows), but it saves a massive amount of space, allowing you to store much more data in the same building.

Summary

The paper proposes a way to shrink the physical size of quantum computers by packing their error-correcting codes tightly together (like Tetris). To make this safe, they invented a new timing schedule for the computer's operations to stop errors from spreading like hooks. Their simulations show that if the computer's parts are good enough, this method saves space and keeps the data safer than the old way.

Technical Summary

Technical Summary: Dense Packing of the Surface Code

Problem Statement
The surface code is a leading candidate for large-scale fault-tolerant quantum computing (FTQC) due to its high error threshold and compatibility with two-dimensional architectures. However, a primary bottleneck is the substantial physical qubit overhead required per logical qubit, which scales with the square of the code distance ($d^2$). While previous studies proposed "dense packing"—fusing multiple surface code patches to reduce the physical qubit requirement to approximately three-quarters of the standard layout—concrete procedures for transitioning between standard and dense states, as well as quantitative analyses of logical error rates in these configurations, remained unexplored. Furthermore, standard gate scheduling strategies risk introducing "hook errors," where errors on measurement qubits propagate to multiple data qubits, potentially degrading the code's effective distance.

Methodology
The authors address these gaps through three primary methodological components:

1. Code Deformation Procedures: The paper details a specific sequence of code deformation steps to transform multiple standalone surface code patches into a single, densely packed, connected configuration. This process involves:

   • Initializing ancillary physical qubits in $|0\rangle$ or $|+\rangle$ states adjacent to existing patches.
   • Defining new stabilizer generators that bridge the patches.
   • Performing $d$ rounds of syndrome measurements to fuse the patches.
   • Measuring specific data qubits to contract the code distance and finalize the dense layout.
   • The reverse process allows for the extraction of individual logical qubits. The authors calculate that fusing patches requires $2d$ rounds plus measurement time, while extraction requires $d$ rounds plus measurement time.

2. Hook-Error-Avoiding Gate Scheduling: Recognizing that dense packing alters the geometry of logical operators relative to stabilizer measurements, the authors propose a modified CNOT gate scheduling scheme for syndrome extraction circuits. Unlike standard scheduling, this scheme utilizes five time steps (compared to four in standalone patches) to ensure that hook errors do not propagate parallel to the logical operators for the majority of the code. While a small subset of stabilizers still permits parallel propagation, the authors argue this impact is localized and minimal.

3. Conceptual Microarchitecture: The authors propose a hierarchical memory microarchitecture inspired by classical Load/Store designs. This architecture utilizes a "computational region" with standalone patches for high-speed, parallel operations and a "memory region" employing densely packed rows for space-efficient storage of infrequently accessed logical qubits. A "hallway" of empty qubits allows for the selective shifting of dense rows to access specific logical qubits via code deformation.

Key Results
The authors performed circuit-level Monte Carlo noise simulations using the stim library and pymatching decoder to evaluate the logical error rates of the proposed configurations. The simulations compared three scenarios:

• Standalone: Standard surface code patches.
• Hook-prone dense: Densely packed patches using standard gate scheduling (susceptible to hook errors).
• Hook-avoiding dense: Densely packed patches using the proposed five-step scheduling.

The numerical results demonstrate:

• Space Overhead: As the number of logical qubits ($n$) increases relative to the code distance ($d$), the area per logical qubit in the dense configuration asymptotically approaches $3/4$ of the standalone configuration.
• Logical Error Rates:
  • The "hook-prone" dense configuration exhibits higher logical error rates than the standalone code due to unmitigated hook error propagation.
  • The "hook-avoiding" dense configuration initially shows slightly higher error rates at physical error rates around $10^{-2}$ due to the increased number of time steps (idle qubit errors).
  • However, as the physical error rate decreases and the code distance increases ($d \geq 7$), the logical error rate of the "hook-avoiding" dense configuration becomes lower than that of the standalone surface code.
• Mechanism of Improvement: The authors attribute this crossover to the fact that in dense configurations, logical errors spanning fused regions require more than $(d+1)/2$ physical errors to occur, whereas standalone patches are vulnerable to errors with as few as $(d+1)/2$ physical errors.

Significance and Claims
The paper claims that dense packing, when combined with specific code deformation procedures and hook-error-avoiding gate scheduling, offers a viable path to reducing the spatial overhead of FTQC without sacrificing error correction performance. The authors assert that:

• Dense packing can reduce the physical qubit requirement per logical qubit to approximately three-fourths of the standard layout.
• The proposed "hook-avoiding" scheduling is essential; without it, the dense configuration suffers from degraded logical error rates.
• For sufficiently low physical error rates and large code distances, the dense configuration not only saves space but also achieves superior logical error protection compared to standard layouts.
• The proposed hierarchical microarchitecture provides a practical framework for integrating these dense memory layers with standard computational regions, potentially reducing the overall spatio-temporal overhead of large-scale quantum computers.

The work concludes that while the dense configuration introduces complexity in scheduling and deformation, the trade-off yields a net benefit in space efficiency and, under realistic noise conditions, improved logical fidelity.