Entangling logical qubits without physical operations

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

Source-linked AI summary

Entangling logical qubits without physical operations

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

arXiv:2601.20927v1Jan 28, 2026quant-ph

TL;DR

Fault-tolerant quantum computing needs logical entangling operations that avoid the overhead and errors of conventional physical gates. This paper systematically discovers and characterizes phantom codes, whose compiled qubit relabellings implement logical entanglement, and evaluates them in noisy simulations. Across GHZ preparation and Trotterized many-body simulation, phantom codes reduce logical infidelity by roughly one to two orders of magnitude at comparable physical-qubit counts, with a 24% preselection acceptance rate.

Problem
Fault-tolerant architectures must jointly optimize compact quantum storage and efficient logical computation because addressable logical operations can dominate overheads and error budgets.
Method
The paper combines numerical enumeration, analytical constructions, and end-to-end noisy simulations to study phantom-code structure, supported logical gates, and application performance.
Results
GHZ preparation and Trotterized many-body simulation show approximately 56× and 94× reductions in logical infidelity, respectively, at a 24% acceptance rate and comparable physical resources.
Takeaways & Limitations
Phantom codes provide a zero-overhead code-design axis that is competitive for workloads with dense local entangling structure and motivates jointly optimizing storage and computation.
Takeaways & Limitations
On CSS phantom codes, a theorem rules out many strictly transversal logical gates, including H, S, CZ, and magic gates, except for a limited H⊗2SWAP case on some k = 2 codes.

Abstract

from arXiv · show

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.

I. INTRODUCTION

Phantom codes make logical entangling gates disappear from compiled physical circuits by absorbing qubit permutations into relabelling, eliminating gate overhead and infidelity. The paper investigates their structure, expands the known code landscape, and evaluates their practical advantages under realistic noise.

Motivation: Quantum error correction must reduce both storage overhead and the computational costs of addressable logical operations.High-rate qLDPC codes optimize compact memories, but logical operations can dominate space–time overheads and error budgets.
Core idea: Phantom codes implement logical entangling gates through physical-qubit permutations absorbed during compilation, achieving zero overhead and perfect fidelity.The permutations are relabellings rather than hardware operations, so they generate no new physical entanglement.
Scope: The study expands phantom codes from two previously known examples to over a hundred thousand new instances and multiple error-correcting families.It combines numerical searches, analytical constructions, and systematic code-discovery methods, while investigating performance under realistic noise.
Definition: A CSS phantom code supports CNOT_ab for every ordered pair of logical qubits through qubit permutations, using an appropriate logical basis.The smallest example is the J4, 2, 2K code, where selected qubit permutations implement CNOT12 and CNOT21.
Key distinction: Unlike Pauli-frame tracking, phantom-code permutations can be interleaved with non-Clifford gates while eliminating all in-block CNOTs from the compiled circuit.This yields zero-cost, all-to-all entangling connectivity within each codeblock without operator spread.
Key properties: Phantom codes efficiently execute arbitrary CNOT circuits across multiple codeblocks by combining zero-depth in-block CNOTs with transversal interblock CNOTs.For 2a codeblocks, the physical depth is at most 4(2a −1), or 2(2a −1) for unidirectional CNOT circuits with preserved ordering.
Key properties: The phantom property is independent of the logical basis, simplifying analysis and accelerating numerical searches.The Hamming bound further constrains the possible (n, k, d) parameters of CSS phantom codes.

B. Summary of results

The paper combines exhaustive enumeration, SAT-based discovery, and analytic constructions to expand the phantom-code landscape, then benchmarks representative codes under realistic noise. These methods identify broad code families, additional logical operations, and substantial reductions in logical infidelity for GHZ preparation and Trotterized simulation.

Identification and construction: The study uses exhaustive enumeration, SAT-based search, qRM constructions, and binarization–concatenation to identify and construct phantom codes.The numerical searches reach n ≤ 21, while the analytic constructions provide scalable families and higher-distance codes.
Logical operations: The work characterizes additional Clifford and non-Clifford logical operations across the identified phantom codes.These include local-Clifford and permutation gates, fold-type gates, and magic gates from diagonal single-qubit rotations.
Benchmarks: 56× lower logical infidelity is observed for GHZ preparation across 4–64 logical qubits at a 24% preselection acceptance rate.The comparison uses surface-code baselines with comparable physical-qubit counts.
Benchmarks: 94× lower logical infidelity is observed for Trotterized many-body simulation with 8-body terms across 8–64 logical qubits at the same 24% acceptance rate.The phantom-code and baseline simulations use nearly identical physical resources.
Implementation tools: The work also develops fault-tolerant state-preparation strategies and decoders that track spatiotemporal error correlations for non-LDPC codes.These tools are presented as directly applicable beyond phantom codes.

C. Implications

The implications center on co-designing QEC codes for storage and computation rather than optimizing memory overhead alone. Phantom codes and the accompanying exploration tools support tailored trade-offs and can outperform LDPC codes on selected dense-entanglement tasks.

Application scope: Dense local entangling circuits are the target setting in which phantom codes reduce logical error rates and overhead.The paper specifically connects this potential to applications such as fermionic simulation and correlated-phase preparation on hardware with long-range connectivity.
Code design: Practical fault tolerance requires jointly optimizing efficient storage and efficient logical computation.The paper presents phantom codes as the zero-overhead extreme of this code-design space, despite their apparent tension with high-rate qLDPC structure.
Design tools: The compiled database, SAT searches, and logical-operation pipeline enable systematic exploration of trade-offs among logical overhead, code distance, stabilizer weight, and gate sets.Relaxing the zero-cost constraint can target hardware connectivities and objectives such as reducing logical magic cost.
Application-specific performance: With appropriate decoding and state-preparation protocols, non-LDPC codes can outperform LDPC codes on tailored tasks despite generic LDPC structural advantages.This conclusion is framed as a motivation to revisit code suitability for specific applications.
Code landscape: Table I organizes representative codes by parameters and supported automorphism, fold-diagonal Clifford, and magic-gate sets.The table includes constructions from exhaustive enumeration, SAT discovery, qRM codes, and binarized-qudit concatenation.

A. Exhaustive code enumeration

The paper builds a complete CSS-code catalogue through optimized enumeration, identifies phantom codes with SAT constraints, and extends discovery to larger blocks and scalable qRM constructions. These methods expose both the size of the phantom-code landscape and its structural limitations.

Catalogue construction: The enumeration groups stabilizer codes by equivalence under qubit permutations and global H⊗n transformations, retaining representatives of each class.The underlying stabilizer-group and equivalence-class computations scale superexponentially with n.
Catalogue construction: CSS-specific reductions restrict stabilizer-rank orderings and replace pairwise Tanner-graph isomorphism checks with canonical labelling.This reduces equivalence testing from O(I^2) pairwise checks to O(I) canonical-labelling operations.
Phantom-code identification: 1.39 × 10^5 CSS phantom codes are identified up to n = 14 using Boolean constraint satisfaction.The SAT formulation assigns permutation matrices to logical CNOTs while enforcing codespace preservation and logical-action constraints.
SAT-based discovery: SAT-based code discovery reaches n = 21 and uses unsatisfiability certificates to determine minimal block lengths for specified k and d.The gate-set constraint causes small or larger deviations from general CSS minimal lengths depending on k.
qRM constructions: Analytic qRM constructions extend phantom codes to larger k, with distance up to d ≤ √n.They arise by fixing selected logical qubits through promoted X- or Z-type stabilizers, and reducing k by one can double d at fixed n up to this bound.
qRM constructions: The smallest error-correcting phantom qRM code is J16, 3, 4K, obtained by promoting three same-type logical operators of J16, 6, 4K to stabilizers.The resulting reduction in logical-qubit count enables arbitrary CNOTs through qubit relabelling.
qRM constructions: qRM phantom codes support preselection-based state preparation, the full logical Clifford group through fold-SiSj gates and teleported Hadamards, and a d = 2 transversal magic-gate scheme.The magic-gate scheme temporarily projects into a hypercube-code space before applying the transversal non-Clifford gate.

D. Binarization and concatenation scheme

The binarization-and-concatenation scheme converts high-distance GF(4) qudit codes into phantom qubit codes. Binarization alone is insufficient; concatenation with a J4, 2, 2K phantom layer supplies the structure needed for phantomness while retaining distance and selected logical gates.

Distance scaling: The qRM family’s distance bound d ≤ √n motivates the binarization-and-concatenation construction for higher-distance phantom codes.The construction is presented as an analytic strategy for surpassing the qRM bound.
Construction: Binarization alone does not produce a phantom code because the J4, 2, 2K layer supplies required substructure.Both stages of the binarize-and-concatenate scheme are essential.
Inherited properties: The resulting codes inherit nontrivial logical Hadamard and CZ gates from self-duality and Hermiticity of the starting qudit codes.Concatenation also introduces many low-weight stabilizers, although completing the stabilizer group requires some generators of weight at least the code distance.
Other constructions: Simple concatenation preserves phantomness and multiplies the outer and inner distances, while HGP constructions increase both k and d but can have lower rates than qRM codes.The described concatenated parameters are Jn_in_out, k, d_in d_outK.
Construction: The scheme starts from a quadratic-residue Jn, k, dK4 code, binarizes it to J2n, 2k, dK2, then concatenates with J4, 2, 2K to obtain a phantom code.The binarized intermediate code is not itself phantom.
Other constructions: Punctured hypercube codes have parameters J2^D−1, D, 2K and saturate the Hamming bound for CSS phantom codes.Puncturing can reduce the gate set; J15, 4, 2K admits CCZ but not CCCZ.

IV. LOGICAL GATES BEYOND PHANTOM

Phantom codes support logical operations beyond permutation CNOTs through automorphism Cliffords, non-uniform diagonal rotations, and fold-diagonal constructions. These mechanisms can generate broad logical gate sets, including the full Clifford group in the J20, 2, 6K phantom code.

Structural constraint: A no-go theorem excludes strictly transversal logical gates that do not commute with permutation logical gates, including H, S, CZ, and magic gates for phantom codes.The restriction applies to strictly transversal gates acting across any number of codeblocks under the theorem’s conditions.
Automorphism Cliffords: Permutation symmetries of extended stabilizer matrices yield automorphism Cliffords, including logical H⊗2 SWAP for the J4, 2, 2K phantom code.Swapping columns 1–4 with 5–8 preserves the stabilizer matrix and corresponds to physical H⊗4 combined with logical H⊗2 SWAP.
Diagonal magic gates: Non-uniform physical Z rotations can implement logical diagonal gates at a chosen level of the diagonal Clifford hierarchy.The method assigns distinct integer powers of a gate to physical qubits while preserving computational-basis states up to state-dependent phases.
Fold-diagonal gates: Fold gates arise by embedding a code into a larger code and restricting patterned diagonal interactions to depth-one circuits.In favourable cases, these gates preserve the X-sector code distance.
Combined logical operations: Fold-SiSj gates combined with automorphism operations implementing H⊗k generate the full logical Clifford group in the J20, 2, 6K phantom code.

V. NUMERICAL BENCHMARKING

The benchmarking framework evaluates phantom and surface codes under realistic circuit-level noise, including state preparation, QEC, decoding, and repeated logical operations. In the single-codeblock repeated-CNOT regime, phantom codes avoid physical CNOT operations, while their state-preparation overhead creates the central comparison trade-off.

Phantom-code operation: The non-LDPC phantom code requires Steane-style QEC, fault-tolerant state-preparation factories, preselection, and spatiotemporal correlated decoders.Bare-ancilla syndrome extraction and initialization are not viable for its high-weight stabilizers.
Benchmark framework: End-to-end benchmarks compare the J64, 4, 8K phantom code with rotated surface codes at near-term and projected physical error rates.The study includes state preparation, syndrome extraction, decoding, and realistic circuit-level noise.
Single-codeblock benchmark: The state-preparation benchmark compares four logical qubits in one phantom codeblock with four surface-code blocks across repeated in-block CNOT circuits.Results average over |0⟩⊗4 and |+⟩⊗4 to remove basis dependence.
State preparation: ∼55× lower logical failure rate is achieved than the d = 6 surface code at comparable spatial footprint during state preparation.The phantom code uses 64 data qubits and 64 × 3 ancilla qubits; it also achieves a ∼3× advantage over d = 8 despite roughly twice the physical-qubit count.
Repeated CNOT circuits: ∼1300× (∼120×) improvement over d = 6 (d = 8) is reached on the deepest depth-10 repeated-CNOT circuit at near-term error rates.Surface-code failure rates grow linearly with added in-block CNOTs, while the phantom-code rate remains unchanged because its CNOTs require no physical operations.

C. Multiple-codeblock GHZ state preparation

The multiple-codeblock GHZ benchmark tests how phantom-code benefits change as entangling operations shift from free in-block permutations to costly interblock CNOTs. At K = 64, the phantom and surface-code implementations use nearly matched physical footprints while retaining a substantial phantom-code advantage under the broader simulation framework.

Benchmark design: GHZ preparation spans K = 4–64 logical qubits while progressively reducing the fraction of in-block permutation CNOTs.At K = 4, all three entangling CNOTs are in-block; larger systems require interblock entangling operations.
Multiple-codeblock overhead: Interblock CNOTs require active Steane QEC, adding two ancillary codeblocks per data codeblock, while GHZ preparation also requires mixed-basis logical states.The noisy simulation includes logical-state preparation, teleportation between codeblocks, and transversal measurement with preselection.
Resource matching: At K = 64, the phantom implementation uses 4608 qubits versus 4544 qubits for a d = 6 surface-code implementation.The phantom estimate includes two ancillary codeblocks for Steane QEC and one state-preparation factory per two data codeblocks.
Many-body simulation: The benchmark evaluates Trotterized eight-body Ising dynamics with transverse-field terms over K = 8–64 logical qubits and eight Trotter steps.At K = 64, the largest circuit contains more than 2400 logical gates and has two-qubit logical-gate depth 96.
Results: ∼94× (∼10×) lower logical infidelity is observed than d = 6 (d = 8) surface codes with sliding-window MLE decoding at near-term error rates.The advantage persists at projected future error rates, with relaxed preselection, and as system size increases.

VI. DISCUSSION AND OUTLOOK

The discussion frames phantom codes as a computation-oriented complement to storage-optimized QEC codes, combining zero-overhead logical entanglement with substantial structural constraints. Their practical advantages are therefore concentrated in workloads with dense local entangling structure, while code-discovery and compiler tools support further exploration.

Architectural significance: Phantom codes jointly optimize storage and computation by realizing logical entanglement without physical overhead or infidelity.The paper positions them as advantageous for workloads with dense local entangling structure.
Practical constraints: All discovered phantom codes are non-LDPC, requiring Steane-style QEC, preselected logical-state factories, and specialized decoders.These requirements are practical consequences of the structural condition defining phantomness.
Encoding-rate limitation: The identified codes encode k = O(log n) logical qubits, limiting the fraction of phantom CNOTs in large-scale algorithms.The discussion therefore locates scalable advantages in dense local patches connected through transversal CNOTs.
Open structural questions: The absence of LDPC phantom codes motivates new constructions or formal no-go theorems concerning permutation CNOTs and bounded-weight or geometrically local stabilizers.
Research tools: A complete CSS-code database through n = 14, SAT-based searches, and automated logical-operation extraction broaden systematic code discovery.These tools can target low-overhead codes adapted to specific hardware connectivities.
Compiler direction: Automorphism-aware compilers could treat permutations as free, pack CNOT-dense subroutines into phantom blocks, and schedule interblock gates to minimize noise.The proposal extends the paper’s architectural perspective toward software and decoding for workloads with dense logical entangling gates.

G. Other code constructions

The paper formalizes permutation-based logical Clifford operations and phantomness using symplectic and stabilizer-code representations. It derives structural constraints, including basis-independent phantomness for CSS codes and uniform logical-Pauli weight distributions.

Permutation logical Clifford conditions: A stabilizer code supports a specified permutation logical Clifford gate set when permutations preserve stabilizers and implement the desired logical transformations in some logical basis.The conditions enforce correct logical action and preservation of commutation relations and the codespace.
Phantomness: A code is phantom if some logical basis permits every individually addressable CNOTab to be implemented by physical-qubit permutations.For CSS codes, this criterion can be checked in an arbitrarily chosen CSS logical basis.
CSS permutation actions: Qubit permutations implement only CNOT circuits, modulo logical Pauli gates, when logical operators are expressed in a CSS basis.This restricts permutation-realizable logical actions to the bias-preserving Clifford subgroup.
Logical-basis dependence: Phantomness is independent of the CSS logical basis, although the specific permutation-implemented gate set can depend on that basis.Changing logical bases corresponds to a logical Clifford transformation, while phantomness itself is preserved.
Weight structure and bounds: All nontrivial X-type logical operators, and likewise all Z-type logical operators, have identical physical-Pauli equivalence-class sizes at each fixed weight.This uniformity yields a Hamming bound constraining the parameters of CSS phantom codes.

6. Efficient addressable CNOT gates and arbitrary CNOT circuits between CSS phantom codeblocks

CSS phantom codes make in-block CNOT gates compilation-only operations and support efficient arbitrary CNOT circuits across multiple codeblocks. The resulting physical depth is bounded independently of the logical circuit’s full connectivity, with lower bounds for unidirectional circuits.

In-block CNOT gates: In-block CNOT circuits on CSS phantom codes are implemented by physical-qubit permutations that can be commuted through the circuit and omitted from hardware execution.This gives zero physical cost for the in-block logical CNOT component.
Two-codeblock circuits: Arbitrary CNOT circuits between two CSS phantom codeblocks require physical depth at most four, or at most two for unidirectional circuits preserving logical-qubit ordering.The construction combines transversal interblock CNOTs with compilation-only in-block permutations.
Multiple-codeblock circuits: Any CNOT circuit across 2^a CSS phantom codeblocks has physical depth at most 4(2^a −1), reduced to 2(2^a −1) for unidirectional circuits.Residual logical-qubit permutations can be compiled away at zero cost.
Residual permutations: When residual permutations must be executed physically, arbitrary permutations across codeblocks require depth at most 8k + 8, independent of the number of codeblocks.The bound follows from four-depth SWAP layers arranged across the codeblocks.
Logical basis changes: Phantom-gate-set-preserving logical basis changes are generated by H⊗2, CZ, and CNOT for k = 2, or H⊗k and CNOT for k ≥3.These gates preserve the ability to realize a complete set of permutation-implemented logical CNOTs after basis change.

c. Limitations on strictly transversal logical gate sets on stabilizer codes

Supporting a logical gate through qubit permutations imposes strong constraints on strictly transversal gates. For CSS phantom codes, this excludes most transversal Clifford and magic operations, leaving only limited exceptions and requiring alternative implementations for other gates.

Permutation-transversal incompatibility: Theorem 3 rules out strictly transversal logical gates that do not commute with a logical gate implemented by qubit permutation.The result applies across any number of codeblocks when the logical actions fail to commute.
Consequences for phantom codes: CSS phantom codes therefore cannot implement transversal H, S, in-block or interblock CZ, or magic gates on the affected logical qubits.These restrictions follow from their complete sets of individually addressable permutation CNOT gates.
Consequences for phantom codes: The H⊗2SWAP logical action is the stated exception and is transversally achievable by H⊗2 on some k = 2 codes.The exception does not restore the broader class of excluded transversal gates.
Alternative gate mechanisms: Other logical gates on phantom codes must use non-uniform qubit operations, qubit permutations, or combinations with single-qubit operations rather than strict transversality.The paper identifies these mechanisms as the available strategies beyond permutation CNOTs.
Computational methods: SAT methods encode F2 constraints as Boolean clauses, enabling permutation-gate checks, phantom-code discovery, and distance-constrained searches.The implementation used kissat and PySAT, with a 14-day limit per SAT instance.
Enumeration results: 2.71 × 10^10 inequivalent CSS codes with n ≤14 were exhaustively enumerated, including 132,305 phantom codes with distance d ≥2.Canonical-form deduplication made equivalence comparisons negligible relative to other enumeration costs.
Enumeration results: The number of inequivalent CSS codes grows super-exponentially with n and peaks sharply as a function of k, making larger-scale enumeration computationally challenging.The peak location k* increases with n, while stronger demanded gate sets yield rapidly fewer codes.

2. SAT problem formulation for discovery of stabilizer phantom codes

The paper formulates phantom-code discovery as SAT over stabilizer, logical, permutation, and distance constraints, then specializes the formulation to CSS codes. Catalogue-free SAT searches and analytical constructions extend discovery beyond exhaustive enumeration, including higher-k quantum Reed–Muller and hypercube families.

2. SAT problem formulation for discovery of stabilizer phantom codes: SAT instances search for stabilizer codes whose free standard-form matrices, logical basis change, and permutation matrices satisfy commutation and phantomness constraints.Positive instances return codes with the requested parameters.
2. SAT problem formulation for discovery of stabilizer phantom codes: Exact distance d is enforced by excluding undetectable nonstabilizer errors below d and requiring an undetectable nonstabilizer error of weight d.The lower- and upper-bound constraints are combined before Boolean encoding.
3. SAT problem formulation for discovery of CSS phantom codes: For CSS codes, fixing B = C = 0 and using half-symplectic representations removes variables and simplifies commutation and phantomness constraints.The formulation separately constrains X- and Z-sector distances, allowing dx and dz to be specified independently.
3. SAT problem formulation for discovery of CSS phantom codes: The SAT approach certifies minimal block lengths for k = 2–3 CSS phantom codes and finds examples with exceptional rate, distance, or logical-gate properties.Without gate-set constraints, the same formulation generates or rules out codes with specified parameters.
Appendix E: Phantom quantum Reed–Muller codes: Numerical methods are tractable only for k ≤4, motivating an infinite CSS phantom-code family from quantum Reed–Muller codes with parameters J2^m, m−l+1, min(2^(m−l), 2^l)K.Selected logical qubits are fixed to |0⟩ or |+⟩, promoting their logical operators to stabilizers.
4. SAT problem formulation for discovery of stabilizer and CSS codes without gate set constraints: For n > 14, catalogue-free discovery treats Hx and Hz as free variables and asks SAT to construct codes satisfying permutation-gate and distance requirements.This avoids the prohibitive enumeration of all larger CSS-code catalogues.
1. Review of Reed–Muller codes and polynomial formalism: Quantum Reed–Muller constructions use polynomial representations of binary functions, while affine variable transformations correspond to physical-bit permutations.The polynomial formalism evaluates functions over all binary inputs, producing length-2^m vectors.
2. Quantum Reed–Muller code construction: Hypercube codes are phantom, and punctured hypercube families retain lower-level magic gates while losing the highest-level gate of the original family.A J14, 3, (dx = 3, dz = 4)K phantom code also arises by concatenating a punctured construction with a phase-flip repetition code.

3. Addressable diagonal logical gates via folding

Phantom qRM codes support addressable diagonal logical gates through fold-type circuits built from physical permutations and diagonal interactions. These constructions extend the gate set but can reduce circuit-level distance and impose rotation-basis limitations.

Addressable diagonal gates: Fold-type circuits implement SS and CZ gates between selected logical qubits of phantom qRM codes using coordinate involutions and diagonal physical operations.The constructions use paired coordinate mappings, with physical S or CZ operations applied according to the involution.
Addressable diagonal gates: For the m = 2l phantom qRM family, τSS and τCZ implement SS and CZ on specified pairs of X-type logical operators.The remaining logical operators are preserved up to Z-type stabilizers or act trivially as required by the construction.
Partial fold circuits: Partial fold circuits restrict the involution to a subcube, enabling SS on selected logicals while mapping each X-type operator into itself times a paired Z-type contribution.The J16, 4, 2K example addresses the x3x4 subcube and implements SS on x1 and x2.
Limitations: Fold-type gates are not generally distance-preserving: on the J64, 4, 8K code, τSS has (dx, dz) = (7, 4) and τCZ has (dx, dz) = (6, 4).The circuit-level distance remains d = 4, above three, but is reduced relative to the code’s original protection.
Beyond diagonal gates: The qRM constructions can realize the full logical Clifford group, although m > 2 codes lack a transversal logical Hadamard and require folding plus targeted injection.The same family also supports distance-limited non-Clifford mechanisms, including CCZ constructions through code decoupling and transversal T operations.
Small-angle rotations: STAR implements small-angle rotations probabilistically, requiring two circuits on average for one logical Z rotation and using S gates because the native ancillary action is RY.The rotation protocol applies corrections with success probability one-half at each stage, producing a geometric sequence of fix-up rotations.

2. Concatenation with the J4, 2, 2K code

Binarization-and-concatenation converts suitable GF(4) CSS codes into qubit phantom codes by encoding each qudit through the J4, 2, 2K2 code. The construction preserves phantomness under a sufficient permutation condition while doubling distance and producing concrete code families.

Construction: Binarization-and-concatenation encodes each GF(4) qudit into two qubits and then concatenates with the J4, 2, 2K2 code.The resulting qubit code maps GF(4)-qudit operators into four-qubit blocks with structured X- and Z-type operators.
Parameters: A GF(4) code with parameters Jn, 1, dK4 produces a qubit code with parameters J4n, 2, ≥2dK2.The distance bound follows because nontrivial single-qudit Pauli weights double under binarization and concatenation.
Concrete examples: The J6, 2, 2K2 and J10, 2, 3K2 codes concatenate into phantom J12, 2, 4K2 and J20, 2, 6K2 codes.These instances were also independently found by the SAT-based code-discovery effort.
Phantomness condition: The sufficient phantomness condition requires a coordinate permutation preserving both stabilizer spaces and mapping the GF(4) logical representative to its conjugate up to X stabilizers.This realizes the GL(2, F2) transformations needed for individually addressable CNOTs on the encoded qubits.
Code families: GF(4) quadratic-residue codes provide a family satisfying the sufficient condition, with J3, 1, 2K4 and J5, 1, 3K4 as the smallest examples.The resulting B&C qubit codes are Hermitian self-dual and have extremal distances at small block lengths.
Scope boundary: The B&C construction offers no advantage for p = 8k − 1 when a binary quadratic-residue code has the same parameters.In that case, the same phantom construction can be obtained through ordinary K = 1 concatenation.

b. Logical gates

The paper develops additional logical gates and code families related to phantom codes, including transversal Hadamard, S, and fold-based operations, plus hypergraph-product and glued-code constructions. These results expand the available constructions while also identifying related codes that are not themselves phantom.

Additional logical gates: Transversal Hadamard implements logical HH up to SWAP12, while transversal S implements logical CZ up to Pauli corrections in B&C codes.
Additional logical gates: For phantom B&C codes from self-dual GF(4) QR codes of length p = 8k + 3, transversal Hadamard and coordinate permutation implement HH up to SWAP12.
Additional logical gates: Fold gates provide logical diagonal operations by mapping physical single- and multi-qubit diagonal gates through an embedded-code construction.
Additional code families: Hypergraph products of suitable classical codes yield CSS phantom codes with parameters Jn1n2 + m1m2, k, min(d1, d2)K.
Additional code families: The simplex–repetition hypergraph-product family includes J7, 2, 2K and J49, 3, 4K as its smallest members.
Additional code families: Gluing m copies of the J4, 2, 2K code produces CSS phantom families with parameters J4m, 2, 2mK and J4m −1, 2, 2m −1K.
Related constructions: Connecting a CSS code to its Hadamard-dual produces a new code construction, while doubling a non-CSS phantom code yields a CSS code that is not phantom.

b. Two-sub-lattice CSS codes by doubling a non-CSS code

This section describes how non-CSS codes can be doubled into CSS codes and how permutation-based logical Clifford operations are identified through symmetries of an extended stabilizer matrix. The analysis also establishes CSS logical-basis independence for automorphism logical gates.

Code doubling: Doubling an Jn, k, dK stabilizer code produces a CSS code with parameters J2n, 2k, d′K where d ≤ d′ ≤ 2d.
Code doubling: A permutation implementing CNOTij on the original non-CSS code induces paired CNOT gates on the doubled CSS code.
Automorphism logical Clifford gates: Automorphism logical Clifford gates are found by identifying column permutations that preserve the extended stabilizer structure and correspond to H, S, and SWAP circuits.
Logical-basis dependence: The logical action of a physical permutation generally depends on the chosen logical basis for stabilizer codes.
Logical-basis dependence: For CSS phantom codes, any automorphism logical gate available in one CSS logical basis is available in every CSS logical basis.
Logical diagonal gates: Phase-polynomial methods represent diagonal Clifford-hierarchy gates through binary monomials and support analysis of transversal and fold-diagonal logical operations.

Appendix I: Numerical benchmarking of logical performance

The benchmarking study evaluates phantom and surface codes under circuit-level noise using realistic error rates, state preparation, QEC cycles, and correlated decoding. Across state preparation, repeated in-block CNOTs, GHZ preparation, and Trotterized dynamics, phantom codes achieve lower logical failure or infidelity, while state-preparation imperfections and decoding trade-offs remain relevant.

Noise model: The simulations use a circuit-level noise model calibrated to neutral-atom experiments, with p = 3 × 10−3 representing current-generation hardware and lower values representing projected hardware.Gate, measurement, and reset errors are applied at their respective stages in the simulated circuits.
Decoding: Correlated decoding accounts for error propagation through logical circuits, while surface-code decoding must handle hyperedges introduced by interblock logical gates.The correlated framework decomposes decoding into subproblems solvable with minimum-weight perfect matching.
State preparation: The distance-8 phantom-code state-preparation protocol was designed to eliminate low-order malignant faults, but numerical search did not fully satisfy this condition.For |0000⟩ preparation there were no order-two and fewer than 100 order-three malignant faults; |++++⟩ preparation had one order-two and approximately 200 order-three faults.
State preparation: Despite residual malignant faults, simulations observed p4 scaling in logical failure rate over p = 5 × 10−4 to p = 3 × 10−3.The result follows from the small number of order-two and order-three malignant faults in the selected protocols.
Decoding: The correlated list decoder is >100× faster but approximately half as accurate per window than maximum-likelihood decoding because it uses less cross-type and cross-block correlation information.Maximum-likelihood decoding jointly accesses bit-flip and phase-flip syndromes from control and target codeblocks.
Benchmark results: Phantom codes reduce logical failure or infidelity across increasingly structured workloads, including state preparation, depth-10 in-block CNOT circuits, K = 64 GHZ preparation, and eight-step Trotterized dynamics.Reported improvements include ∼12× over d = 6 for state preparation, up to ∼430× for depth-10 CNOT circuits, ∼26× for K = 64 GHZ preparation, and ∼17× over d = 6 for Trotterized dynamics.