⚛️ quantum physics

Low Overhead Universal Quantum Computation with Triorthogonal Codes

This paper proposes two low-overhead methods for universal fault-tolerant quantum computation using triorthogonal codes that circumvent the Eastin-Knill theorem by leveraging transversal CZ gates and logical state teleportation between paired codes, thereby significantly reducing resource costs compared to existing protocols.

Original author: Dawei Jiao, Mahdi Bayanifar, Alexei Ashikhmin, Olav Tirkkonen

Published 2026-11-03

📖 5 min read🧠 Deep dive

CC BY 4.0

Original author: Dawei Jiao, Mahdi Bayanifar, Alexei Ashikhmin, Olav Tirkkonen

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 author. For technical accuracy, refer to the original paper. Read full disclaimer

Building a computer that harnesses the strange laws of quantum mechanics requires solving a problem that has plagued scientists for decades: how to keep delicate information safe while still being able to use it. In the quantum world, information is stored in fragile states that can be easily ruined by the slightest disturbance. To protect this data, researchers use error-correcting codes, which spread a single piece of information across many physical particles so that if one fails, the whole message survives. However, a fundamental rule of physics, known as the Eastin-Knill theorem, creates a catch-22. It states that no single type of error-correcting code can perform every possible calculation while keeping errors contained. Some codes are excellent at stopping errors but can only perform a limited set of operations, while others can do more complex math but are prone to letting errors spread out of control. To build a truly useful quantum computer, scientists must find a way to switch between these different types of codes, using the strengths of each without triggering a cascade of failures.

A team of researchers at Aalto University and Nokia Bell Labs has developed a new method to solve this switching problem, specifically for a class of codes called triorthogonal codes. These codes are special because they can perform certain complex mathematical operations directly on the encoded data without needing to break the protection layer. The researchers discovered a way to pair these powerful codes with simpler, symmetric codes that are excellent at performing standard operations. By creating a bridge between the two, they allow the computer to teleport information from the complex code to the simple one, do the necessary work, and then teleport it back. This process is entirely "transversal," meaning the operations happen in parallel across the physical particles, which keeps errors from spreading. The team proved that this switching mechanism works for a wide variety of code structures, including those that can perform even more complex operations than previously thought possible.

The core of the discovery lies in how the researchers matched these different codes. For a specific family of codes known as punctured quantum Reed-Muller codes, they created a systematic map to find the perfect partner. Imagine a library where every book has a specific companion volume that fits perfectly on the same shelf; the researchers found the rule that tells you exactly which companion goes with which book. They showed that for any given complex code in this family, there is a simpler, symmetric code it can talk to using a specific type of connection called a one-way CNOT gate. This connection allows the computer to move data between the two codes safely. For other types of triorthogonal codes that do not fit this specific family, the team developed a different, systematic method to construct a compatible partner code from scratch. This ensures that the switching strategy works for all kinds of these advanced codes, not just a select few.

To make this practical, the researchers integrated their switching method with a standard error-correction routine known as Steane error correction. Usually, moving data between codes requires extra steps and additional hardware, which adds cost and complexity. By merging the switching process with the routine checks that catch errors, they eliminated the need for extra resources. The data is moved and checked at the same time, making the entire process more efficient. They tested this framework using two specific examples: a code with 15 physical particles and another with 31. In both cases, they successfully demonstrated that the logical information could be moved back and forth between the complex code and a simpler partner code without losing fidelity.

The true value of this work was demonstrated by using it to build a quantum Fourier transform, a fundamental calculation used in many important algorithms. The researchers compared the total number of connections required to run this calculation using their new switching method against older methods that rely on less powerful codes. They found that by using the larger, 31-particle code, which supports more advanced operations, the total number of connections needed was significantly lower. In some scenarios, the new method reduced the required connections by a factor of three to ten compared to the older approach. This reduction is crucial because in quantum computing, the number of connections is a major bottleneck; fewer connections mean fewer opportunities for errors to occur and less physical hardware needed to build the machine.

The findings suggest that the path to a powerful quantum computer does not require sticking to a single type of code. Instead, a heterogeneous approach, where different codes are used for different tasks and linked together efficiently, offers a clear advantage. The researchers have shown that by carefully pairing complex codes with simpler ones, it is possible to perform universal calculations while keeping errors under control and reducing the overall resource cost. This work provides a concrete blueprint for how future quantum computers might be built, moving beyond the limitations of single-code architectures to a more flexible and efficient system. The results indicate that as quantum systems scale up, utilizing these higher-level operations through code switching could substantially lower the barrier to building machines capable of solving real-world problems.

Technical Summary: Transversal Code Switching in Triorthogonal Code Families

Problem Statement

Universal fault-tolerant quantum computation requires a gate set capable of implementing arbitrary unitary operations. However, the Eastin-Knill theorem establishes that no single quantum error-correcting code (QECC) can support a universal set of transversal gates. Standard approaches to circumvent this limitation rely on magic state distillation for non-Clifford gates (e.g., the $T$ -gate), a process that is resource-intensive, often requiring orders of magnitude more qubits and gates than logical operations.

Alternatively, triorthogonal codes support transversal non-Clifford gates (such as $T$ and controlled-controlled- $Z$ ) at higher levels of the Clifford hierarchy but lack transversal implementations for all Clifford gates. Conversely, symmetric Calderbank–Shor–Steane (CSS) codes support transversal Clifford gates but not high-level non-Clifford gates. The challenge is to unify these capabilities without incurring the massive overhead of magic state distillation or complex subsystem gauge-fixing procedures.

Methodology

The authors propose a transversal code switching framework that enables logical state transfer between a triorthogonal code ( $Q_T$ ) and a compatible symmetric CSS code ( $Q_{Sym}$ ) using only transversal operations. The methodology is divided into two primary strategies based on the structure of the triorthogonal code:

1. Punctured Quantum Reed–Muller (PQRM) Codes

For triorthogonal codes that fall within the PQRM family, the authors establish a systematic code map to identify compatible symmetric CSS partners.

Transversality Conditions: They derive conditions for one-way transversal CNOT gates between a triorthogonal code $Q_T$ and a symmetric code $Q_{Sym}$ (potentially with different physical qubit counts). This involves constructing an extended symmetric code to satisfy the necessary quotient space isomorphisms ( $C_1/C_2^\perp \cong C_3/C_4^\perp$ ) and dual space inclusions ( $C_2^\perp \subseteq C_4^\perp$ ).
Code Map: For a given PQRM code $Q_m^r$ , they identify a set of paired symmetric codes $Q_s^{2s+1}$ where $r \leq s \leq (m-1)/2$ . This allows switching between codes supporting different levels of the Clifford hierarchy (e.g., switching from a 4D color code to a 2D Steane code).
Implementation: The switching is realized via transversal state teleportation. Logical states are teleported from $Q_T$ to $Q_{Sym}$ using transversal CNOT gates, and vice versa using transversal CZ gates (since the reverse CNOT is not transversal).

2. General Triorthogonal Codes

For triorthogonal codes outside the PQRM family, the authors provide a systematic construction method to generate a compatible symmetric CSS code.

Construction: Given a triorthogonal code $Q_T = \text{CSS}(C_1, C_2)$ , they construct a symmetric code $Q_{Sym} = \text{CSS}(C, C)$ where $C_1 \subset C \subset C_2$ .
Proof of Transversality: They demonstrate that such a pair satisfies the conditions for a transversal CNOT gate from $Q_T$ to $Q_{Sym}$ and a transversal CZ gate in the reverse direction, ensuring the logical spaces are isomorphic.

Integration with Error Correction

A key methodological contribution is the integration of the code switching protocol directly into the Steane error correction procedure.

Instead of performing code switching and error correction as separate, sequential steps, the authors embed the teleportation circuits into the syndrome extraction process.
This approach utilizes the ancilla blocks required for Steane error correction as the target blocks for code switching, thereby reducing the ancilla overhead and the total number of CNOT gates required.

Key Contributions

Generalized Transversal Code Switching: The paper extends previous one-way transversal CNOT techniques (previously limited to color codes) to the broader family of triorthogonal codes, including those supporting gates at higher levels of the Clifford hierarchy.
Systematic Code Mapping:
- For PQRM codes, a map is introduced to identify compatible symmetric partners for any given code, enabling switching between codes of different physical sizes and Clifford hierarchy levels.
- For non-PQRM triorthogonal codes, a constructive algorithm is provided to synthesize compatible symmetric CSS partners.
Overhead Reduction: By merging the switching protocol with Steane error correction, the framework reduces the resource overhead (ancilla qubits and gate count) typically associated with state teleportation.
Benchmarking: The framework is benchmarked using logical $n$ -qubit Quantum Fourier Transform (QFT) circuits, comparing the resource costs of using the $[[15, 1, 3]]$ code (supporting transversal $T$ ) versus the $[[31, 1, 3]]$ code (supporting transversal $\sqrt{T}$ ).

Results

The authors benchmark the framework by compiling logical QFT circuits using the $[[15, 1, 3]]$ and $[[31, 1, 3]]$ triorthogonal codes paired with the $[[7, 1, 3]]$ Steane code.

Gate Count Reduction: The results indicate that exploiting higher-level Clifford hierarchy gates (specifically $\sqrt{T}$ via the $[[31, 1, 3]]$ code) significantly reduces the total CNOT count compared to using only third-level gates (via the $[[15, 1, 3]]$ code).
Scaling: For large $n$ , the $[[31, 1, 3]]$ approach reduces the CNOT overhead by approximately half compared to the $[[15, 1, 3]]$ approach. For smaller $n$ , the reduction factor is even more pronounced (3 to 10 times).
Resource Trade-offs: While the $[[31, 1, 3]]$ code requires more physical qubits per logical qubit, the reduction in the number of non-Clifford gate decompositions (which are the primary source of CNOT overhead in QFT) leads to a net decrease in total resource cost.

Significance

The paper claims that these findings highlight the potential of heterogeneous code architectures for reducing the resource costs of fault-tolerant quantum computation. By enabling the direct use of transversal gates at higher levels of the Clifford hierarchy through code switching, the framework offers a pathway to more efficient universal quantum computation without relying solely on expensive magic state distillation. The integration with Steane error correction further demonstrates the practical viability of these protocols for reducing ancilla overhead in large-scale systems.