[[4,2,2]] Quantum Error-Detecting Code

• [[4,2,2]] quantum error-detecting code is a stabilizer code that encodes two logical qubits in four physical qubits using two weight-4 stabilizers, yielding a distance d=2.
• Its design detects any single-qubit Pauli error, making it a practical tool in experimental platforms like superconducting and trapped-ion systems.
• The code supports repeated error detection, concatenated constructions, and entanglement protocols, though it involves trade-offs such as post-selection overhead and ancilla-induced faults.

Searching arXiv for recent and foundational papers on the [[4,2,2]] quantum error-detecting code and closely related implementations. arxiv_search(query="[[4,2,2]] quantum error-detecting code", max_results=10, sort_by="relevance") Searching arXiv for the exact topic phrase. The [[4,2,2]] quantum error-detecting code is a stabilizer code that encodes two logical qubits into four physical qubits with distance $d=2$. It is the smallest non-trivial qubit error-detecting code, and its code space is the simultaneous $+1$ eigenspace of two weight-4 stabilizers, typically $X_1X_2X_3X_4$ and $Z_1Z_2Z_3Z_4$. As a consequence, any single-qubit Pauli error anticommutes with at least one stabilizer and is therefore detected, although not corrected. Owing to its low qubit overhead, weight-2 logical operators, and simple parity-check structure, the code has been used in superconducting and trapped-ion experiments, post-selected algorithmic demonstrations, adaptive error-detection protocols without post-selection, entanglement distillation, and concatenated many-hypercube constructions (Pokharel et al., 2022).

1. Algebraic definition and logical structure

A standard presentation of the code uses four physical qubits with stabilizer generators

$S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$

The code subspace is therefore four-dimensional and supports two logical qubits. In one widely used computational-basis representation, the logical basis is

$$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$

In the $X$ basis, one similarly has states such as $$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$ (Vigneau et al., 17 Mar 2025).

An alternative but equivalent code-space description uses Bell states. In that formulation,

$$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$

with $\{|\beta_j\rangle\}$ the four Bell states. This representation is especially useful in entanglement-sharing constructions because it exposes a tensor-product structure across qubit pairs while preserving the same stabilizer group generated by $+1$0 and $+1$1 (Choi et al., 2012).

Different works adopt different convenient representatives for the logical Pauli operators under different physical-qubit labelings. In the star-topology superconducting realization, one choice is

$+1$2

(Vigneau et al., 17 Mar 2025). In the trapped-ion “Iceberg code” instantiation, a convenient choice is

$+1$3

(Self et al., 2022). In the [[4,2,2]]-encoded VQE study, the logical operators are given as

$+1$4

(Gowrishankar et al., 2024). These choices all commute with the stabilizers and realize the usual logical Pauli algebra within the code subspace.

The distance-$+1$5 property means that every single-qubit Pauli error is detectable. In the syndrome convention used in the VQE study, a single $+1$6 error produces $+1$7, a single $+1$8 produces $+1$9, and a single $X_1X_2X_3X_4$0 produces $X_1X_2X_3X_4$1; runs with nonzero syndrome are discarded rather than corrected (Gowrishankar et al., 2024).

2. Encoding, syndrome extraction, and repeated detection cycles

The logical all-zero state is the four-qubit GHZ state

$X_1X_2X_3X_4$2

Several works use ancilla-assisted preparations of this state. In the many-hypercube construction, a minimal fault-tolerant level-1 encoder uses one ancilla prepared in $X_1X_2X_3X_4$3, four CNOTs from the ancilla onto the data qubits, an $X_1X_2X_3X_4$4-basis ancilla measurement that projects into the $X_1X_2X_3X_4$5 eigenspace of $X_1X_2X_3X_4$6, and then a CNOT chain with an $X_1X_2X_3X_4$7-basis measurement to ensure $X_1X_2X_3X_4$8; the circuit is described as 1-fault tolerant because a single fault cannot produce two undetected data errors (Goto, 29 Nov 2025). In the trapped-ion implementation, a flagged initialization circuit similarly prepares $X_1X_2X_3X_4$9 using one ancilla and an ordering of CNOTs chosen so that an exhaustive Pauli-fault check shows no single fault can produce an undetected logical error (Self et al., 2022).

Syndrome extraction likewise admits several hardware-specific forms. In the trapped-ion Iceberg implementation, mid-circuit readout of $Z_1Z_2Z_3Z_4$0 and $Z_1Z_2Z_3Z_4$1 uses two ancillas in an interleaved flagged pattern: $Z_1Z_2Z_3Z_4$2 is measured by preparing an ancilla in $Z_1Z_2Z_3Z_4$3, applying CNOTs in an ordering “A B A,” and measuring in $Z_1Z_2Z_3Z_4$4; $Z_1Z_2Z_3Z_4$5 is measured by preparing an ancilla in $Z_1Z_2Z_3Z_4$6, applying CNOTs in an ordering “B A B,” and measuring in $Z_1Z_2Z_3Z_4$7. The ordering is chosen so that a single fault on one ancilla flags the other, and any flip in $Z_1Z_2Z_3Z_4$8 or $Z_1Z_2Z_3Z_4$9 leads to discarding the trial (Self et al., 2022).

The star-topology superconducting realization implements one stabilizer measurement by rotating into the appropriate basis, swapping the ancilla into a central resonator, applying four resonator-data controlled-phase-like interactions, swapping back, undoing the basis change, and measuring the ancilla. A full cycle measures both stabilizers, and the two ancilla sequences are interleaved so that while one ancilla is being read out, the other can already start its first MOVE. The reported gate counts per full cycle are 12 single-qubit $S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$0, 2 MOVE, 8 controlled-phase interactions between the resonator and data qubits, and 2 ancilla measurements (Vigneau et al., 17 Mar 2025).

In repeated error-detection protocols, the input state $S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$1 is prepared so that it overlaps one codeword $S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$2, with probabilistic encoding giving 50% success in the star-topology experiment. After $S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$3 rounds of stabilizer measurement, the run is postselected on all syndrome outcomes being $S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$4 and on the final data-qubit outcome lying in the logical subspace. The accepted-run probability is defined as

$S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$5

where $S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$6 is the per-cycle stabilizer-pass probability and $S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$7 is the logical-subspace acceptance on final readout (Vigneau et al., 17 Mar 2025).

3. Fault-tolerant circuit design and architecture-aware implementations

The [[4,2,2]] code is especially attractive on architectures with high connectivity because its stabilizers have weight 4 while its logical operators can be chosen to have weight 2. In the trapped-ion “Iceberg code” construction, the [[4,2,2]] instance is the case $S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$8 of a family encoding $S_X = X_1X_2X_3X_4,\qquad S_Z = Z_1Z_2Z_3Z_4.$9 logical qubits into $$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$0 physical qubits. A central architectural feature is that each logical two-qubit operator $$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$1 has physical support on only two qubits, enabling a universal logical gate set

$$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$2

On a trapped-ion device with all-to-all connectivity, each logical rotation compiles non-fault-tolerantly into exactly one Mølmer–Sørensen gate plus up to four single-qubit Cliffords. The paper emphasizes that both unencoded and encoded two-qubit logical rotations use a single MS gate, but in the encoded circuit only Pauli errors diagonal in $$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$3 are undetectable, which suppresses the effective two-qubit error rate (Self et al., 2022).

The superconducting star-topology device realizes a different hardware mapping. A single high-$$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$4 superconducting resonator sits at the center of a six-leaf star and is coupled, via tunable couplers, to six transmons: four data qubits and two ancilla qubits. Because the resonator couples to all six transmons, any data qubit can interact with any ancilla by way of the central bus, and no SWAP-tree routing is required. Weight-4 stabilizer extraction is therefore implemented with only two ancilla-resonator MOVE operations per ancilla plus four controlled-phase-like interactions per stabilizer (Vigneau et al., 17 Mar 2025).

A distinct architectural direction appears in adaptive open-system simulation. There, the code is used in a post-selection-free protocol in which each detected error triggers an immediate reset of the code block into $$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$5. If the target dissipative model already requires stochastic resets at rate $$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$6, the detected-error resets can be absorbed into that channel by calibrating the detection probability $$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$7 and injecting additional resets at rate

$$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$8

This converts error detection into part of the intended dissipative dynamics and removes the exponential cost usually associated with post-selection (Chertkov et al., 29 Sep 2025).

4. Experimental performance across platforms

The code has been benchmarked in several experimentally distinct regimes.

Setting	Reported result	Source
Star-topology superconducting QPU	Logical state fidelities above 96% for every cardinal logical state; logical error-per-cycle values from 0.25(2)% to 0.91(3)%; logical lifetimes above the best physical element	(Vigneau et al., 17 Mar 2025)
Logical Bell state in star-topology device	Initial logical fidelity $$\begin{aligned} |00\rangle_L &= \frac{|0000\rangle + |1111\rangle}{\sqrt2},\ |01\rangle_L &= \frac{|0011\rangle + |1100\rangle}{\sqrt2},\ |10\rangle_L &= \frac{|0101\rangle + |1010\rangle}{\sqrt2},\ |11\rangle_L &= \frac{|0110\rangle + |1001\rangle}{\sqrt2}. \end{aligned}$$9 and logical purity $X$0; Bell-state fidelity decays with $X$1 and $X$2 per cycle up to $X$3; entanglement survives with $X$4	(Vigneau et al., 17 Mar 2025)
Trapped-ion expressive circuits and Quantum Volume	On 8 logical qubits, encoded survival remains $X$5 at 256 layers vs. $X$6 unencoded with global logical gates; logical Quantum Volume of $X$7 with heavy-output frequency $X$8 for $X$9 and final discard rate $$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$0	(Self et al., 2022)
Two-qubit Grover search on IBM superconducting hardware	Success probability $$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$1 unencoded, $$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$2 encoded, and $$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$3 with encoded plus measurement-error mitigation on Jakarta	(Pokharel et al., 2022)
[[4,2,2]]-encoded VQE for molecular hydrogen	Encoded + PSAP gives $$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$4 mHa at $$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$5 with success probability $$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$6; the estimate falls within the chemical accuracy threshold of $$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$7 mHa of the exact energy	(Gowrishankar et al., 2024)
Adaptive open-system simulation on Quantinuum H2	Logical simulation achieves break-even with physical simulation for $$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$8	(Chertkov et al., 29 Sep 2025)

These results show that the code has been used in several distinct roles: as a repeated-detection logical memory, as a protection layer for expressive circuits, as a post-selected wrapper for small algorithms, and as a component of adaptive simulations that do not discard shots. The reported metrics differ across platforms, but a common pattern is that single-fault detection improves the retained logical ensemble while leaving residual undetected logical faults governed by the code’s distance-$$|\pm\pm\rangle_L = (|\pm\pm\pm\pm\rangle + |\mp\mp\mp\mp\rangle)/\sqrt2$$9 structure.

5. Role in concatenation, entanglement protocols, and networked settings

In the many-hypercube program, the [[4,2,2]] code appears as the $$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$0 building block. There it is explicitly described as a [[4,2,2]] CSS code with stabilizers $$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$1 and $$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$2, and with level-by-level concatenation yielding

$$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$3

The level-1 encoder uses $$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$4 data qubits plus $$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$5 ancilla, so $$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$6 qubits. The new simultaneous-detection encoder reduces the level-2 overhead from $$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$7 to $$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$8, and the level-3 overhead from $$|C_j\rangle \equiv |\beta_j\rangle_{12}\otimes|\beta_j\rangle_{34},\qquad j=0,1,2,3,$$9 to $\{|\beta_j\rangle\}$0; including repeats on detection failures, this becomes $\{|\beta_j\rangle\}$1 fewer qubits in practice. Under a circuit-level depolarizing model, the authors report for $\{|\beta_j\rangle\}$2 the fit

$\{|\beta_j\rangle\}$3

with $\{|\beta_j\rangle\}$4 and $\{|\beta_j\rangle\}$5 at $\{|\beta_j\rangle\}$6 (Goto, 29 Nov 2025).

The code also supports entanglement-centric tasks. In entanglement sharing, it yields a $\{|\beta_j\rangle\}$7 threshold structure: any subset of three or more of the four physical qubits can recover the two logical qubits perfectly, while any subset of size one or two cannot recover the encoded quantum state. In the entanglement-sharing variant, this means that any three players recover full entanglement with the dealer, while any one or two share no entanglement. The construction is permutation invariant, and the bound $\{|\beta_j\rangle\}$8 is saturated with one-qubit shares and two ebits of dealer-players entanglement (Choi et al., 2012).

In entanglement distillation and re-distillation, four noisy Bell pairs are processed into two higher-fidelity Bell pairs using measurements of the [[4,2,2]] stabilizers on each side. The protocol can either decode immediately or store the resulting four-qubit logical Bell state in memory. The same work derives closed-form expressions for the pass probability, output fidelity, and yield, with

$\{|\beta_j\rangle\}$9

Under local dephasing at rate $+1$00, a single Bell pair decays as

$+1$01

whereas the logical Bell pair decays as

$+1$02

The reported advantage of re-distillation over BBPSSW depends primarily on classical communication delay, with threshold values of $+1$03 normalized to $+1$04 on the order of $+1$05 in the benchmark scenarios studied (Zheng et al., 8 Sep 2025).

6. Limitations, trade-offs, and recurrent misconceptions

The central limitation of the [[4,2,2]] code is that it is an error-detecting code, not an error-correcting code. A no-error syndrome does not imply logical correctness. The code detects any single-qubit Pauli error, but weight-2 errors can be undetected, and normalizer elements outside the stabilizer act as logical faults. In the VQE discussion, two bit-flips such as $+1$06 are explicitly noted to be undetected and may map one logical basis state to another (Gowrishankar et al., 2024). In the entanglement-distillation setting, multi-qubit errors that commute with both stabilizers are described as the protocol’s residual error floor (Zheng et al., 8 Sep 2025).

A second trade-off is post-selection overhead. In repeated-detection experiments the accepted-run probability decays approximately as

$+1$07

The star-topology experiment reports representative values $+1$08 and $+1$09, which makes acceptance exponentially sensitive to the number of cycles (Vigneau et al., 17 Mar 2025). In trapped-ion logical Quantum Volume, the reported heavy-output frequency improvement for $+1$10 comes with a final discard rate $+1$11 (Self et al., 2022). A common misconception is therefore that the code is only useful when heavy post-selection is acceptable. The adaptive-circuit work shows that this is not universally true: detected errors can be converted into intended random resets, avoiding post-selection entirely in that setting (Chertkov et al., 29 Sep 2025).

A third limitation concerns ancilla-induced fault channels. In the variational quantum machine learning study, the [[4,2,2]] code improves training accuracy only when the ancilla error rate remains below a threshold,

$+1$12

Above those values, ancilla errors propagated through the logical-rotation and syndrome-extraction circuits outweigh the benefits of discarding detected faults, and the maximum achievable accuracy saturates below unity (Adermann et al., 9 Apr 2025). This suggests that, for NISQ applications, the usefulness of the [[4,2,2]] code depends not only on the distance-$+1$13 detection property itself but also on whether the chosen hardware and compilation strategy keep ancilla-mediated error propagation sufficiently small.

Taken together, these limitations explain the code’s characteristic niche. The [[4,2,2]] code is not a substitute for full fault-tolerant error correction, but it is a compact and experimentally practical primitive for detecting single-qubit faults, studying logical-state behavior, benchmarking architecture-aware stabilizer extraction, and bootstrapping higher-level constructions such as concatenated high-rate codes and LOCC-based entanglement protocols (Goto, 29 Nov 2025).