Entangling logical qubits without physical operations

TL;DR

Phantom codes redefine fault-tolerant quantum computation by enabling entangling operations between all logical qubits purely through relabelling physical qubits during compilation, eliminating in-block entangling overhead and enabling perfect fidelity when compiled away. The authors develop four complementary code-discovery channels—exhaustive CSS-code enumeration, SAT-based searches, qRM-based analytic families, and binarization-concatenation—producing a broad landscape of phantom codes, including high-distance qRM and GF(4) binarized constructions. End-to-end noisy simulations demonstrate substantial practical benefits over surface-code baselines for tasks with dense local entanglement, such as GHZ-state preparation and Trotterized many-body dynamics, with reductions in logical infidelity up to orders of magnitude at comparable physical resources. The work also provides a toolkit of decoding strategies, gate constructions, and software resources to systematically explore lossless, zero-overhead entangling within code blocks, proposing a compelling architectural route for scalable quantum computation on hardware with long-range connectivity.

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.

Figures (18)

• Figure 1: Illustration of logical entanglement via relabelling.(a) In phantom codes, logical entangling gates are realized by physical qubit permutations that are absorbed at the compilation stage as a relabelling, without performing any physical qubit permutation. (b) The $\llbracket4,2,2\rrbracket$ code is the smallest phantom code. It has logical operators $\overline{X}_1 = XXII$, $\overline{X}_2 = XIXI$, $\overline{Z}_1 = ZIZI$, $\overline{Z}_2 = ZZII$. Permuting qubits 1 and 3 (1 and 2) implements $\overline{\mathrm{CNOT}}_{12}$ ($\overline{\mathrm{CNOT}}_{21}$, not shown).
• Figure 2: Phantom codes in circuits with interblock and magic gates. The benefit of phantom codes is most evident when $\overline{\mathrm{CNOT}}$s appear alongside interblock and magic gates. Qubit permutations can be pulled through these operation without introducing operator spread, yielding substantial reductions in physical circuit size. In this example, the physical permutation required to implement the 20 in-block $\overline{\mathrm{CNOT}}$s (highlighted in orange) vanish from the final compiled circuit.
• Figure 3: The smallest error-correcting phantom qRM code. Logical $\overline{\mathrm{CNOT}}$ gates for the $\llbracket16,3,4\rrbracket$ phantom qRM code. The code is obtained by promoting three same-type logical operators ($X$ or $Z$) of the parent $\llbracket16,6,4\rrbracket$ code to stabilizers. The resulting reduction in the number of logical qubits enables arbitrary $\overline{\mathrm{CNOT}}$ gates via qubit relabelling; examples of $\overline{\mathrm{CNOT}}_{12}$ and $\overline{\mathrm{CNOT}}_{32}$ are shown.
• Figure 4: Schematic construction of phantom codes from quadratic-residue qudit codes. Phantom codes can be constructed by starting from a quadratic-residue $\llbracket n,k,d\rrbracket_4$ code over $\mathrm{GF}(4)$ and binarizing it to obtain a qubit code with parameters $\llbracket2n, 2k, d\rrbracket_2$. This intermediate code is not itself phantom, but it serves as the outer code in a concatenation with the $\llbracket4,2,2\rrbracket$ qubit code, and the resulting concatenated code is phantom. A detailed derivation is given in \ref{['app:binarize_concatenate']}.
• Figure 5: Benchmarking phantom and surface codes in $\bm{\overline{\mathrm{CNOT}}}$ circuits and logical GHZ state preparation.(a) Repeated in-block $\overline{\mathrm{CNOT}}$ circuits on four logical qubits hosted on a single $\llbracket64,4,8\rrbracket$ phantom codeblock or four surface codeblocks ($d = 5$--$8$). The numerics include fault-tolerant state preparation and failure rates are averaged over $\ket*{\overline{0}}^{\otimes 4}$ and $\ket*{\overline{+}}^{\otimes 4}$ initial states. (b) Logical GHZ state preparation across multiple codeblocks, probing performance as the fraction of in-block permutation $\overline{\mathrm{CNOT}}$s decreases. Dark and pale purple denote strict and relaxed preselection, respectively. Error bars are 98% confidence intervals.

Theorems & Definitions (85)

• Definition 1: CSS phantom codes
• Theorem 1: Efficient arbitrary $\overline{\mathrm{CNOT}}$ circuits across CSS phantom codeblocks
• Remark 1
• Theorem 2: Hamming bound for CSS phantom codes
• Theorem 3: No strictly transversal logical gates non-commuting with permutation logical gates
• Proposition 1: Permutation logical Clifford gate set on a stabilizer code
• Proposition 2: Phantomness of a stabilizer code
• Proposition 3: Qubit permutations can achieve only $\overline{\mathrm{CNOT}}$ circuits with CSS logical basis
• proof
• Remark 2