⚛️ quantum physics

Entangling logical qubits without physical operations

This paper introduces "phantom codes," a class of quantum error-correcting codes that achieve perfect-fidelity logical entangling gates through physical qubit relabelling without spatial or temporal overhead, demonstrating significant scalability advantages over surface codes in noisy simulations for specific workloads.

Original authors: Jin Ming Koh, Anqi Gong, Andrei C. Diaconu, Daniel Bochen Tan, Alexandra A. Geim, Michael J. Gullans, Norman Y. Yao, Mikhail D. Lukin, Shayan Majidy

Published 2026-01-30

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jin Ming Koh, Anqi Gong, Andrei C. Diaconu, Daniel Bochen Tan, Alexandra A. Geim, Michael J. Gullans, Norman Y. Yao, Mikhail D. Lukin, Shayan Majidy

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

The Big Idea: The "Ghost" Connection

Imagine you are trying to build a super-powerful computer (a quantum computer) that can solve problems no normal computer ever could. The biggest problem with these machines is that they are very fragile; the slightest noise or mistake causes the calculation to fail.

To fix this, scientists use Quantum Error Correction (QEC). Think of this like a "team of bodyguards" for your data. Instead of storing one piece of information on one fragile qubit, you spread it out across many qubits. If one bodyguard gets hit by a stray bullet (an error), the others can figure out what happened and fix it without losing the information.

However, there's a catch. To make these computers useful, the bodyguards (qubits) need to talk to each other to perform calculations. Usually, making them talk requires complex, noisy physical operations (like firing lasers or applying magnetic fields). These operations are slow and prone to errors.

This paper introduces a new type of code called a "Phantom Code."

The Analogy: The Seating Chart Trick

Imagine a classroom where students (physical qubits) are sitting in specific seats. The teacher (the computer) wants two specific students to work together on a project (entangle).

The Old Way: The teacher has to physically walk over, grab Student A, move them next to Student B, make them talk, and then move them back. This takes time, energy, and risks bumping into other students (errors).
The Phantom Way: The teacher doesn't move anyone. Instead, the teacher simply changes the name tags on the desks.
- "Okay, the person sitting in Seat 1 is now called 'Student A' for the purpose of this calculation."
- "The person in Seat 3 is now 'Student B'."
- "Now, Student A and Student B are talking."

In reality, no one moved. No physical interaction happened. The "connection" was created purely by relabeling who is who. Because nothing physically moved, there is zero chance of a mistake happening during the connection. It is a "ghost" (phantom) interaction.

What the Researchers Did

The authors (a team from Harvard, ETH Zurich, and others) asked a big question: Are there other ways to organize these "bodyguards" so that we can make them talk just by changing their names, without moving them?

They found that yes, there are many such arrangements. Here is what they discovered:

A Massive Hunt: They used powerful computers to search through billions of possible ways to arrange these qubits. They found over 27 billion different arrangements (codes) for small systems and identified hundreds of thousands that work as "Phantom Codes."
Building Bigger Systems: They didn't just find random examples; they built families of these codes that can scale up to handle larger, more complex calculations.
The "Magic" of Relabeling: They showed that in these codes, you can perform complex logic operations (like the CNOT gate, which is the "AND" gate of quantum computing) simply by swapping the labels of the qubits in the software compilation. The physical hardware never has to do the heavy lifting.

Why This Matters (The Results)

The researchers didn't just find these codes; they tested them against the current "gold standard" (called the Surface Code) using realistic simulations of noise.

The Test: They simulated two difficult tasks: creating a giant entangled state (like a group hug for 64 qubits) and running a complex physics simulation.
The Result: The Phantom Codes performed 10 to 100 times better than the Surface Code.
- In the Surface Code, the "bodyguards" have to physically interact to talk, which introduces errors.
- In the Phantom Code, because the "talking" is just a software label change, the error rate drops dramatically.

The Catch (Limitations)

The paper is very honest about the trade-offs:

High Weight: These codes require the "bodyguards" to be very tightly connected in a complex web (high-weight stabilizers). This makes setting them up initially harder than standard codes.
Not for Everything: These codes shine when you have a lot of local connections (like a dense neighborhood where everyone knows everyone). If your calculation requires qubits that are far apart and rarely interact, the Phantom Code might not be the best choice.

Summary

Think of this paper as discovering a new way to organize a library.

Old Way: To find a book, you have to physically walk to the shelf, pull it out, and carry it to the reading table.
Phantom Way: You keep the books exactly where they are. You just update the computer catalog so that when someone asks for "Book A," the system knows it's actually sitting on Shelf B.

By doing this, the library (the quantum computer) can process requests much faster and with fewer mistakes because no physical movement is required to "connect" the information. The authors have mapped out a whole new landscape of these "catalog-only" libraries and proved they work incredibly well for specific, complex tasks.

Technical Summary: Entangling Logical Qubits Without Physical Operations

Problem Statement

Scalable fault-tolerant quantum computing relies on Quantum Error Correction (QEC). While recent progress has focused on reducing QEC overheads through high-rate Quantum Low-Density Parity-Check (qLDPC) codes, these designs often treat logical gates as a downstream constraint. In practice, logical entangling gates dominate space-time overheads and error budgets, particularly in circuits with dense local entanglement. Conventional approaches to implementing logical entangling gates (such as CNOTs) typically require repeated measurement rounds, dense layers of physical two-qubit gates, or ancillary codeblocks, all of which introduce significant error accumulation and resource costs. The fundamental challenge is to optimize the joint design of storage and computation, specifically addressing the lower bound on the cost of logical entangling gates.

Methodology

The authors introduce and systematically investigate a new class of QEC codes termed phantom codes. These are CSS stabilizer codes where logical entangling gates between any ordered pair of logical qubits within a codeblock can be implemented solely through the permutation (relabeling) of physical qubits.

The methodology involves four complementary approaches to identify and construct these codes:

Exhaustive Enumeration: A systematic search of all $2.71 \times 10^{10}$ inequivalent CSS codes with block length $n \le 14$ . This involved generating stabilizer groups, grouping codes into equivalence classes (under qubit permutations and global Hadamards), and using SAT solvers to verify the existence of permutation-based CNOT implementations.
SAT-Based Discovery: For $n > 14$ , where exhaustive enumeration is computationally prohibitive, the authors formulated the code discovery problem as a Boolean Satisfiability (SAT) problem. By treating stabilizer generator matrices as free variables, they identified phantom codes up to $n = 21$ and established minimal block lengths for specific logical qubit counts ( $k$ ) and distances ( $d$ ).
Analytic Constructions (Quantum Reed–Muller): To access higher $k$ and scalable families, the authors constructed infinite families of phantom codes based on Quantum Reed–Muller (qRM) codes. This involves "gauge-fixing" parent qRM codes by promoting selected logical operators to stabilizers, effectively trading logical qubits for increased code distance.
Binarization and Concatenation: To achieve distances $d > \sqrt{n}$ , the authors developed a scheme converting high-distance self-dual GF(4) qudit codes into qubit codes via binarization, followed by concatenation with the $[[4, 2, 2]]$ phantom code.

The study also characterizes the supported logical gate sets beyond the defining CNOTs, including Clifford gates (via automorphisms and fold-diagonal gates) and non-Clifford "magic" gates. Finally, the authors perform end-to-end noisy simulations comparing a representative phantom code ( $[[64, 4, 8]]$ ) against surface-code baselines.

Key Contributions

Definition and Discovery of Phantom Codes: The paper formally defines phantom codes and expands the known landscape from two existing examples to over 100,000 new instances and multiple error-correcting families.
Zero-Overhead Entanglement: It demonstrates that for these codes, all in-block logical entangling gates can be "compiled away" by absorbing physical qubit permutations into the circuit compilation stage. This yields perfect fidelity for these specific gates with zero spatial or temporal overhead.
Theoretical Bounds and Properties: The authors derive a Hamming bound for CSS phantom codes and prove that the phantom property is independent of the logical basis. They also establish that strictly transversal logical gates non-commuting with permutations (such as transversal Hadamard or magic gates) are precluded, necessitating alternative fault-tolerant strategies.
Practical Implementation Tools: The work develops specific protocols for non-LDPC phantom codes, including fault-tolerant state preparation (using Steane-style error correction and preselection) and spatiotemporal sliding-window decoders that track error correlations.

Results

Code Landscape: The authors identified phantom codes across a wide range of parameters. Notable examples include the $[[64, 4, 8]]$ qRM code and various codes up to $n=21$ found via SAT search.
Logical Gate Sets: Beyond CNOTs, the identified codes support various Clifford gates (e.g., $H^{\otimes k}$ , $CZ$, $S$ ) and diagonal magic gates (e.g., $T$ , $C^kZ$ ) through local Cliffords, permutations, and fold-diagonal interactions.
Benchmarking Performance: End-to-end simulations with realistic physical error rates ( $p=10^{-3}$ $p = 1 0^{- 3}$ and projected $5 \times 10^{-4}$ $5 \times 1 0^{- 4}$ ) show significant advantages for phantom codes in tasks with dense local entanglement:
- GHZ State Preparation: For 4–64 logical qubits, the phantom code achieved a $\sim 56\times$ reduction in logical infidelity compared to surface codes with comparable physical qubit counts (at a $\sim 24\%$ preselection acceptance rate).
- Trotterized Many-Body Simulation: For Hamiltonians with 8-body terms and 8–64 logical qubits, the phantom code showed a $\sim 94\times$ reduction in logical infidelity over surface codes.
- Single-Block CNOT Circuits: In regimes dominated by in-block CNOTs, the phantom code's logical failure rate remained constant as circuit depth increased (since CNOTs cost nothing), whereas surface code failure rates grew linearly.

Significance and Claims

The paper claims that phantom codes offer a viable architectural route to fault-tolerant quantum computation, specifically for workloads characterized by dense local entangling structures (e.g., fermionic simulations, correlated-phase preparation). By placing logical operations at the center of the design, these codes achieve a "zero-overhead extreme" for entanglement, outperforming leading fault-tolerant architectures (like the surface code) on tailored tasks despite being non-LDPC and having lower encoding rates ( $k = O(\log n)$ ).

The authors emphasize that their work provides general tools for systematically exploring the landscape of quantum error-correcting codes, including a complete database of small-footprint CSS codes and automated pipelines for extracting logical operations. They suggest that while phantom codes impose practical constraints (requiring Steane-style QEC and preselection), they demonstrate that non-LDPC codes can outperform LDPC codes on specific applications when co-designed for efficient logical computation. The work motivates a broader exploration of the trade-offs between encoding rate, code distance, and logical gate efficiency.