Entangling logical qubits without physical operations

Abstract: Fault-tolerant logical entangling gates are essential for scalable quantum computing, but are limited by the error rates and overheads of physical two-qubit gates and measurements. To address this limitation, we introduce phantom codes-quantum error-correcting codes that realize entangling gates between all logical qubits in a code block purely through relabelling of physical qubits during compilation, yielding perfect fidelity with no spatial or temporal overhead. We present a systematic study of such codes. First, we identify phantom codes using complementary numerical and analytical approaches. We exhaustively enumerate all $2.71 \times 10^{10}$ inequivalent CSS codes up to $n=14$ and identify additional instances up to $n=21$ via SAT-based methods. We then construct higher-distance phantom-code families using quantum Reed-Muller codes and the binarization of qudit codes. Across all identified codes, we characterize other supported fault-tolerant logical Clifford and non-Clifford operations. Second, through end-to-end noisy simulations with state preparation, full QEC cycles, and realistic physical error rates, we demonstrate scalable advantages of phantom codes over the surface code across multiple tasks. We observe a one-to-two order-of-magnitude reduction in logical infidelity at comparable qubit overhead for GHZ-state preparation and Trotterized many-body simulation tasks, given a modest preselection acceptance rate. Our work establishes phantom codes as a viable architectural route to fault-tolerant quantum computation with scalable benefits for workloads with dense local entangling structure, and introduces general tools for systematically exploring the broader landscape of quantum error-correcting codes.

• The paper demonstrates phantom codes that implement all-to-all logical CNOT operations through qubit relabelling with zero physical overhead, significantly reducing error rates.
• The paper employs exhaustive enumeration, SAT algorithms, quantum Reed–Muller constructions, and binarization-concatenation to discover and construct a vast set of new phantom codes.
• The paper benchmarks phantom codes against surface codes, revealing up to 1300× improvement in logical fidelity and showcasing practical advantages for fault-tolerant quantum architectures.

Entangling Logical Qubits Without Physical Operations: Analysis of Phantom Codes

Overview and Motivation

This work introduces and systematically investigates "phantom codes," a class of quantum error-correcting codes (QECCs) that allow the realization of all-to-all logical entangling gates (specifically, in-block logical $\overline{\mathrm{CNOT}}$s) through physical qubit relabelling during compilation, with zero spatial or temporal gate overhead and perfect fidelity. Unlike traditional codes in which logical entangling gates require physical two-qubit operations—leading to significant logical error rates and circuit depth—phantom codes achieve logical entanglement entirely by relabelling qubits in software, eliminating the hardware layer for such gates.

The critical motivation stems from the recognition that logical two-qubit gates constitute a non-trivial portion of the overall error budget in current fault-tolerant quantum computing systems. The overheads and failure rates associated with such gates are viewed as limiting factors for scaling up QEC-enabled quantum processors. This study reverses the conventional order of code design: rather than beginning with code structure and contorting to support logical gate sets, it places desired logical operations (entangling gates) as the central design constraint, challenging the lower bound on resource requirements for fault-tolerant entanglement.

Figure 1: Logical entanglement in phantom codes is implemented by qubit relabelling; no physical permutation or operation is performed.

Formal Definition and Structural Properties

A family of CSS (Calderbank-Shor-Steane) codes is defined as "phantom" if, for a chosen logical basis, the logical $\overline{\mathrm{CNOT}}_{ab}$ between every ordered pair of logical qubits $(a,b)$ can be implemented by a permutation of physical qubits. This requirement is much stricter than global or partial automorphism symmetry, and notably stricter than permutation-invariance in codes. Only two such codes were previously known: the $[[12,2,4]]$ Carbon code and $[[2^D, D, 2]]$ hypercube codes.

Key structural traits of phantom codes include:

• Logical $\overline{\mathrm{CNOT}}$ circuits across $2^a$ codeblocks can be performed in constant physical depth, up to a residual permutation (Theorem: Arbitrary $\overline{\mathrm{CNOT}}$ circuits act at depth $4(2^a - 1)$, see proof and Figure 2).
• Phantomness is independent of logical basis in CSS codes.
• All logical $X$ and $Z$ equivalents exhibit uniform weight distribution, leading to a tight Hamming-type bound on code parameters.

  Figure 2: In circuits with interblock and non-Clifford ("magic") gates, all in-block logical $\overline{\mathrm{CNOT}}$s compile away as permutations, drastically reducing circuit size.

Comprehensive Code Discovery and Construction

Four complementary approaches were pursued:

1. Exhaustive Enumeration: The entire space ($2.7\times 10^{10}$ inequivalent instances) of $n\leq 14$ CSS codes was enumerated, leading to over $10^5$ previously unknown phantom codes (see numerical breakdown and code parameter table).
2. SAT-based Code Discovery: Boolean satisfiability methods were used to find codes up to $n=21$ and to establish lower bounds on physical qubit overheads for fixed code parameters.
3. Quantum Reed-Muller (qRM) Constructions: Infinite families of phantom codes for arbitrary $k$ and higher distances (up to $d\leq \sqrt{n}$) were created, generalizing hypercube codes using qRM techniques and polynomial formalisms.
4. Binarization-Concatenation: By binarizing high-distance $GF(4)$ qudit codes and concatenating them with $[[4,2,2]]$ phantom inner codes, new families exceeding the $d\leq \sqrt{n}$ limitation were constructed.

   Figure 3: Construction pipeline for phantom codes using binarized quadratic-residue qudit codes and concatenation with $[[4,2,2]]$.

Logical Gate Sets Beyond Permutation $\overline{\mathrm{CNOT}}$

While phantom codes are defined by their permutation-implemented $\overline{\mathrm{CNOT}}$s, their built-in structure additionally supports:

• Logical Clifford operations via automorphism-induced local Clifford operations and permutations.
• Fold-type gates (such as logical $\overline{S}_i \overline{S}_j$ and $\overline{\mathrm{CZ}}_{ij}$) constructed via non-uniform single- or two-qubit diagonal rotations.
• Teleportation- and injection-based logical non-Clifford operations, including magic states and addressable Hadamards for codes lacking transversal counterparts (Figures 11, 13, 15). All these logical gates are subject to constraints imposed by the no-transversality theorem for codes with a permutation Clifford structure; only automorphism-preserving operations commute with all permutation-implemented gates.

Numerical Benchmarks and Practical Performance

The $[[64,4,8]]$ phantom qRM code was benchmarked against state-of-the-art surface code implementations for key workloads. For these simulations, state preparation, QEC, and decoding pipelines compatible with non-LDPC, high-weight-stabilizer codes were developed.

Key findings include:

• Single-codeblock circuits with only permutation $\overline{\mathrm{CNOT}}$s: Logical failure remained almost constant regardless of logical circuit depth in phantom codes, while surface code error grows linearly with depth. This yielded up to ${\sim}1300\times$ advantage in logical infidelity compared to surface code at $d=6$ (Figure 5a).
• GHZ state preparation across multiple codeblocks: Even as the ratio of in-block to interblock entangling gates decreased, phantom codes maintained an advantage of $56\times$ reduction in logical infidelity at matched spatial footprint and modest preselection rates ($\sim24\%$) (Figure 5b).
• Trotterized many-body simulation: For global circuits involving both phantom and transversal gates, phantom codes achieved up to $94\times$ reduction in logical infidelity compared to $d=6$ surface code using comparable resources. The advantage persisted with increasing system size and under projected error rates (Figure 5).

  Figure 4: (a) Logical error rates versus circuit depth for in-block CNOT circuits; (b) GHZ state preparation performance as logical system size increases.

  

  Figure 5: Logical fidelity for Trotterized evolution of a Hamiltonian with many-body interactions, comparing $[[64,4,8]]$ phantom and surface codes with $d=5-8$.

Theoretical and Practical Implications

The practical implication is the decoupling of logical two-qubit entangling costs from hardware in workloads dominated by local entanglement (e.g., fermionic simulation, GHZ state creation, correlated phase states). This makes phantom codes optimal for layouts where in-block logical operations dominate, notably in trapped-ion and neutral-atom architectures with high connectivity.

Theoretically, phantom codes occupy an extreme corner in the code design landscape: minimal logical entangling cost at the expense of non-LDPC structure (high-weight stabilizers, $k = O(\log n)$ scaling for encodable qubits). This puts them in sharp contrast with high-rate qLDPC codes, which achieve efficiency in memory overhead but not in computational overhead for arbitrary logical circuits. The study's methods—exhaustive code cataloguing, SAT code search, and automated logical operation extraction—provide general tools for mapping the adaptable frontier between computation- and memory-optimized code families.

The non-LDPC nature of all discovered phantom codes raises open questions regarding the compatibility of bounded-weight, geometric locality, and automorphism-rich logical gate sets—potentially suggesting fundamental no-go results. Furthermore, the consistent realization that transversal magic gates cannot preserve code distance in these constructions points to deep structural constraints.

Outlook and Open Directions

Several new research directions are suggested:

• Asymptotic limits: Whether higher-rate, low-overhead phantom codes (especially LDPC or those with geometric locality) exist, or whether fundamental trade-offs make the coexistence of universal, automorphism-induced gates and high rates impossible.
• Code landscape mapping: Systematic exploration, leveraging the developed databases and SAT tools, to interpolate between the phantom and qLDPC extremes, optimizing various objective functions (e.g., cost of logical magic).
• Compiler design: Building automorphism-aware compilers to harness free permutations and optimize scheduling and packing of logical gates.
• Application-specific codes: Identifying workloads (measurement-based computation, communication, variational circuits) that can maximize the phantom advantage.
• Experimental validation: Small-angle analog rotations (via STAR protocol) and other non-Clifford workload benchmarks present immediate near-term opportunities for demonstrating the practical viability of the phantom code paradigm.

Conclusion

By centering logical gates as the axis of code design, introducing and systematically uncovering the structure of phantom codes, and rigorously benchmarking their operational advantages, this work provides both practical and theoretical justification for reevaluating which QECC architectures are suitable for particular quantum workloads. The findings suggest that, especially in architectures and workloads with dense local entanglement, phantom codes can outperform traditional LDPC codes, upending the hegemony of surface code-based approaches for such contexts. The systematic tools and conceptual frameworks introduced further pave the way for the rational exploration of the vast, as yet unmapped, space of logical-gate-optimized quantum codes.

---

Bibliography

• Full details, technical proofs, and comprehensive data can be found in the original arXiv manuscript: "Entangling logical qubits without physical operations" (2601.20927).
• See also references therein for code benchmarking and architectural discussions (e.g., [gottesman2024surviving], [bluvstein2024logical], [paetznick2024demonstration], [hangleiter2025fault]).