⚛️ quantum physics

Injection is all you need: parallel universal logic in high-rate concatenated self-dual codes

This paper proposes a quantum architecture that achieves addressable and parallel universal fault-tolerant logic in high-rate concatenated self-dual codes by injecting diverse resource states via flag-at-origin and concatenated cultivation protocols, resulting in significant spacetime overhead reductions compared to surface code methods.

Original authors: Joseph Sullivan, David Amaro, Michael A. Perlin

Published 2026-10-22

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Joseph Sullivan, David Amaro, Michael A. Perlin

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

Quantum computers promise to solve problems that would take ordinary machines millennia to crack, but they are notoriously fragile. The smallest whisper of heat or vibration can scramble the delicate information they hold. To build a machine that actually works, scientists must wrap their data in layers of protection, a technique called quantum error correction. This involves spreading a single piece of information across many physical particles so that if a few go wrong, the whole message survives. For years, researchers have been chasing a specific kind of protection: codes that are efficient, storing a lot of data without requiring a massive army of extra particles. These "high-rate" codes are like a compact, high-capacity hard drive. However, a major roadblock has always stood in their way. While these codes are excellent at storing data, they are notoriously difficult to use for actual calculations. The very structure that makes them efficient also makes it hard to address individual pieces of information to perform operations, forcing the computer to work in a slow, serial fashion rather than the fast, parallel processing needed for complex tasks.

A team of researchers from JPMorgan Chase and Quantinuum has proposed a new architecture that bypasses this bottleneck entirely. Instead of trying to force the code to do the work, they suggest a method of "injection." Imagine the quantum computer as a factory floor where the machinery is fixed and rigid. Rather than trying to rewire the factory to build new products, the team proposes bringing in pre-assembled, high-quality components and swapping them into the system. In their scheme, the computer performs calculations by consuming special, pre-prepared states of matter that carry the necessary instructions. This approach allows the system to perform any required logical operation in parallel, unlocking the full speed of these efficient codes. The researchers demonstrated that by combining small, simple error-correcting codes into larger, more complex structures, they could prepare these special components with high reliability. Their simulations show that this method not only solves the addressability problem but also drastically reduces the physical space and time required to produce the necessary resources compared to existing methods.

The core of their innovation lies in how they handle the two types of operations a quantum computer needs: the standard, predictable ones and the more exotic, difficult ones. For the standard operations, the team uses a technique called teleportation, which moves information from one place to another by consuming a pre-made resource. They found that by using a specific family of codes that allow for global operations, they could break down any complex calculation into a sequence of simple steps, each requiring only a handful of these pre-made resources. This eliminates the need for the slow, step-by-step processing that has plagued high-rate codes. For the difficult operations, which are essential for the computer to be truly powerful, they developed a method they call "concatenated cultivation." This is a process of growing high-quality states through layers of verification. They start with a basic, imperfect state and use a series of checks to filter out errors. By repeating this process across multiple layers of the code, they can drive the probability of an undetected error down to an incredibly low level.

The researchers tested their ideas by simulating the preparation of these resource states using specific examples of codes. They looked at combinations of small codes, such as those based on the Hamming code, and built them up into larger, two-level structures. Their results were striking. In these simulations, the new method of growing these states proved to be at least ten times more efficient in terms of the space and time required than the current leading approach used in surface codes, which are the most common type of error correction today. While the surface code method requires a massive amount of physical hardware to achieve the same level of reliability, the new architecture achieves it with a fraction of the resources. The team also showed that they could prepare the resources needed for the standard operations with a much smaller physical footprint than traditional methods, which often require large factories of qubits just to produce a single usable component.

This work does not claim to have built a working quantum computer, nor does it solve every remaining problem in the field. The results presented are based on detailed computer simulations that model how these systems would behave under realistic noise conditions. The researchers acknowledge that as these codes are scaled up to handle even larger calculations, the methods for decoding errors will need to evolve from simple look-up tables to more sophisticated algorithms. Furthermore, while the simulations show a clear path forward, the actual construction of these circuits in a physical lab will present its own engineering challenges. However, the study provides a concrete blueprint for how to make high-rate codes practical. By showing that universal, parallel computing is possible without the massive overhead previously thought necessary, the paper suggests that the path to a useful quantum computer may be shorter and less resource-intensive than many had feared. The key insight is that by changing how we feed instructions into the system—injecting them rather than building them into the code—we can unlock the potential of the most efficient error-correcting structures available.

Technical Summary: "Injection is all you need: parallel universal logic in high-rate concatenated self-dual codes"

Problem Statement
High-rate quantum error-correcting (QEC) codes offer asymptotically low physical overheads for quantum memory but face a fundamental "addressability problem." In these codes, it is often unclear how to perform logical gates on specific subsets of qubits without serializing operations, which limits computational bandwidth. Existing strategies, such as generalized lattice surgery or code automorphisms, struggle to provide addressable and parallel universal logic within a single code block. Furthermore, standard approaches to fault-tolerant Clifford gates often rely on costly distillation protocols that require large factory sizes to produce single resource states.

Methodology
The authors propose a quantum architecture that circumvents the addressability problem by "injecting" almost all logical gates via teleportation gadgets (Steane-QEC and Knill-QEC) that consume fault-tolerantly prepared resource states. This approach simultaneously performs quantum error correction and mitigates leakage noise. The architecture relies on a specific family of codes: concatenated codes built from Self-Dual with Equivalent Logicals (SWEL) CSS seed codes.

Key methodological components include:

SWEL Codes: The scheme utilizes seed codes where global logical Hadamard ( $\bar{H}^{\otimes k}$ ) and Phase ( $\bar{S}^{\otimes k}$ ) operators are transversal. This property allows the reduction of arbitrary logical Clifford circuits to CSS resource states.
Clifford Injection via Bruhat Decomposition: Any $k$ $k$ -qubit logical Clifford unitary is decomposed into a sequence of nine gates (using the Bruhat decomposition). The authors demonstrate that each stage of this decomposition can be injected by consuming a constant number (at most 9) of CSS resource states.
- Resource State Preparation: Instead of distillation, the authors employ the Flag-at-Origin (F@O) method to prepare these CSS states. This method avoids the large overheads of distillation factories.
- Gate Types: $S^{\otimes k}$ and $H^{\otimes k}$ gates are injected using Steane-QEC gadgets consuming tensor products of logical $|0\rangle$ and $|+\rangle$ states. CNOT layers are injected using Knill-QEC gadgets consuming two-block resource states.
Non-Clifford Injection (Magic States): To achieve universality, the scheme consumes logical $|H\rangle^{\otimes k}$ $∣ H ⟩^{\otimes k}$ magic states.
- Concatenated Cultivation: The authors introduce a protocol called "concatenated cultivation" to prepare high-fidelity $|H\rangle^{\otimes K}$ states in concatenated codes. This involves iteratively applying Zero-Level Distillation (ZLD) at each concatenation level.
- Error Suppression: By measuring transversal $\bar{H}^{\otimes k}$ operators at successive levels and cross-referencing outcomes, the protocol suppresses the probability of undetectable logical errors to $O(p^{2\ell})$ at concatenation level $\ell$ , where $p$ is the physical error rate. This leverages the transversal nature of $\bar{H}^{\otimes k}$ in SWEL codes as a built-in flagging mechanism.

Key Contributions

Addressable Parallel Universal Logic: The paper demonstrates a method to execute arbitrary $k$ -qubit Clifford and non-Clifford circuits in parallel on high-rate concatenated codes without the addressability bottlenecks of previous methods.
Distillation-Free Clifford Preparation: The authors show that the availability of global transversal $H$ and $S$ gates in SWEL codes allows all Clifford resource states to be prepared via the Flag-at-Origin method, eliminating the need for large distillation factories.
Concatenated Cultivation Protocol: A novel protocol for preparing high-fidelity magic states in concatenated codes that achieves $O(p^{2\ell})$ suppression of undetectable logical errors, surpassing the $O(p^2)$ barrier of single-level parity measurements.
Benchmarking: The authors provide numerical benchmarks for three specific two-level concatenated codes: $J36, 4, 4K$ , $J48, 8, 4K$ , and $J96, 14, 6K$ (constructed from $J6, 2, 2K$ and $J15, 7, 3K$ seed codes).

Results

Magic State Performance: Proxy simulations for the cultivation of $|H\rangle^{\otimes K}$ states show that logical error rates scale as predicted: $O(p^3)$ for distance-4 codes and $O(p^4)$ for distance-6 codes (when accounting for decoder heralded post-selection).
Spacetime Overhead: The concatenated cultivation protocol offers a significant reduction in spacetime cost compared to surface code cultivation. For the benchmarked codes, the spacetime cost is at least one order of magnitude lower than producing equivalent magic states via surface code cultivation.
Clifford Resource States: Benchmarks for Flag-at-Origin circuits show that depth-optimized circuits outperform space-optimized circuits in both logical error rate and discard rate. While the logical error rates for these CSS states are higher than those for proxy magic states, the method avoids the massive qubit overhead of distillation (e.g., reducing factory size from thousands of qubits to hundreds).
Resource Efficiency: The scheme requires at most $12 D_T$ resource states to execute a quantum algorithm with $T$ -depth $D_T$ (9 for each Clifford layer and 3 for each $T$ layer).

Significance and Claims
The paper claims to provide a practical pathway for universal fault-tolerant quantum computation using high-rate codes, which are typically difficult to utilize for computation. By combining SWEL codes with injection-based logic and concatenated cultivation, the authors demonstrate that:

High-rate codes can support fully addressable and parallel universal logic.
The overhead for preparing resource states can be drastically reduced compared to distillation-based approaches.
The proposed architecture is viable for near-term hardware, with logical circuits in the "megaquop" and "gigaquop" regimes potentially executable at physical error rates accessible to current technology.

The authors note that their results represent an initial benchmarking of resource state quality and that future work is needed to develop end-to-end cost estimates for complete algorithms, including compilation and scheduling optimizations. They emphasize that while the current benchmarks use lookup table decoders, algorithmic decoders will be necessary for scaling to larger concatenation levels.

Technical Summary: "Injection is all you need: parallel universal logic in high-rate concatenated self-dual codes"

More like this