The [[4,2,2]] Quantum Stabilizer Code

• The [[4,2,2]] code is a minimal quantum stabilizer code that encodes two logical qubits with a distance of two, detecting any single-qubit error.
• It employs two stabilizer generators (all-X and all-Z) to enable transversal Clifford operations and the use of dynamically corrected gates.
• It underpins adaptive syndrome extraction, fault-tolerant circuits, and concatenated architectures in scalable quantum error correction.

The [[4,2,2]] code is a minimal, nontrivial quantum stabilizer code that encodes two logical qubits into four physical qubits with code distance two. It is distinguished by its capacity to detect—though not correct—any single-qubit error, enabling it to function as an essential component for error detection, syndrome extraction, and various fault-tolerant protocols in quantum computation. Its structure, implementations, and operational role make it a building block for advanced quantum error correction schemes and practical demonstrations of fault tolerance on contemporary quantum hardware.

1. Structure and Properties of the [[4,2,2]] Code

The [[4,2,2]] code employs two stabilizer generators, one composed of all X operators and the other of all Z operators across four physical qubits:

$$S_X = X_1 X_2 X_3 X_4,\qquad S_Z = Z_1 Z_2 Z_3 Z_4.$$

The code space is thus the +1 common eigenspace of these stabilizers. Canonical logical operators are defined as

$$\overline{X}_1 = X\ I\ I\ X,\quad \overline{X}_2 = I\ I\ X\ X, \ \overline{Z}_1 = I\ I\ Z\ Z,\quad \overline{Z}_2 = Z\ I\ I\ Z.$$

The logical basis states (codewords) are:

$$\overline{|00\rangle} = \tfrac{1}{\sqrt{2}}(|0000\rangle + |1111\rangle),\ \overline{|01\rangle} = \tfrac{1}{\sqrt{2}}(|0011\rangle + |1100\rangle),\ \overline{|10\rangle} = \tfrac{1}{\sqrt{2}}(|0101\rangle + |1010\rangle),\ \overline{|11\rangle} = \tfrac{1}{\sqrt{2}}(|0110\rangle + |1001\rangle).$$

As a distance-two code, it detects but cannot correct arbitrary single-qubit errors. The code admits transversal realization of several Clifford operations and supports natural syndrome extraction for both Pauli X and Z errors. The [[4,2,2]] code also appears in various permutationally invariant forms (e.g., as the optimal single-deletion-correcting code in the ((4,2,2)) format) (Aydin et al., 2023).

2. Dynamically Corrected Gates and Noise Protection

The [[4,2,2]] code has served as a testbed for high-fidelity encoded operations using dynamically corrected gates (DCGs). In such implementations, qubits are arranged on a bipartite lattice with always-on Ising couplings (De et al., 2012). Shaped, self-refocusing pulse sequences are engineered to simultaneously implement quantum logic and dynamically decouple unwanted couplings and suppress low-frequency phase noise:

$$H_S = \frac{1}{2} \sum_{\langle ij \rangle} J_{ij} \sigma^z_i \sigma^z_j.$$

Decoupling sequences (such as Eulerian path constructions) suppress both Ising and noise terms up to the second order in the Magnus expansion. Single- and two-qubit gates (including entangling ZZ rotations and CNOTs) are synthesized by altering local decoupling pulses while maintaining global cancellation elsewhere. Errors in such circuits scale as high powers of the pulse duration ($\sim \tau_p^6$), ensuring robust operation under dominant low-frequency noise processes. These techniques allow parallel implementation across the code—vital for scalable QEC and efficient syndrome extraction in LDPC and surface codes.

3. Role in Error Detection and Fault-Tolerant Circuits

The [[4,2,2]] code’s error-detecting capacity enables post-selection-based protocols to enhance circuit fidelity on noisy superconducting and trapped-ion quantum devices. After preparing a codeword, runs are accepted only if measurement outcomes correspond to the code space (e.g., four-qubit measurement yields even parity):

$$\text{Parity check}: x_1\oplus x_2\oplus x_3\oplus x_4 = 0.$$

Experiments on IBM 5Q and IonQ hardware have shown that encoding quantum circuits in the [[4,2,2]] code reduces statistical distance to the ideal distribution in benchmarking experiments compared with bare physical gates—even though encoded circuits require more operations (Vuillot, 2017, Pokharel et al., 2022, Singh et al., 6 Dec 2024). Fault-tolerant logical gate sets, such as logical Hadamard, SWAP or CNOT, are often implemented transversally or with simple code automorphisms (Sayginel et al., 26 Sep 2024). These enable the logical code space to be mapped by only single-qubit or SWAP physical gates, preserving error locality and suppressing correlated errors.

Table: Parity-Check-Based Error Detection and Thresholds

Implementation	Detection Mechanism	Post-selection Retention	Typical Error Reduction
IBM 5Q	Parity + flag qubits	70–90%	Up to order-of-magnitude
IonQ (Aria-1)	Parity only	~95%	~90% average

In all practical demonstrations, error runs are identified by the violation of parity or stabilizer constraints and are discarded, resulting in substantial error suppression for short- and intermediate-length circuits.

4. Concatenation, Syndrome Extraction, and Scalable Codes

The [[4,2,2]] code is a fundamental element in concatenation architectures and homological code constructions. It is used as the “inner” block in concatenated codes—each logical qubit of an outer code (e.g., a hypergraph product code or augmented surface code) is implemented as a block-encoded [[4,2,2]] logical qubit (Berthusen et al., 20 Feb 2025, Delfosse et al., 2020). This enables:

• Efficient pre-filtering: inexpensive detection rounds precede more expensive outer syndrome extractions.
• Adaptive syndrome extraction: only outer stabilizers acting on error-flagged regions are measured, reducing CNOT count and circuit depth.
• Enhanced distance and logical error lifetime: the product distance $d = d_{\text{outer}} \cdot 2$ boosts low-noise regime performance.

In memory and benchmark experiments, this adaptive, concatenated approach yields an order-of-magnitude reduction in logical error rates at low noise, and when mapped to local architectures, requires fewer gate operations and physical qubits per logical bit than non-concatenated codes.

5. Applications in Quantum Algorithms and Quantum Networking

The [[4,2,2]] code underlies several practical quantum protocols:

• Quantum algorithmic break-even: In Grover search, encoding with the code and using dynamical decoupling and measurement error mitigation yields success rates exceeding the classical threshold; the code acts as an error-detection filter (Pokharel et al., 2022).
• VQE and chemical accuracy: Encoding the variational ansatz yields millihartree-level energy precision using error detection and post-selection, even with increased qubit and gate overhead (Gowrishankar et al., 5 May 2024).
• Deutsch–Jozsa algorithm: Fault-tolerant, ancilla-free circuits encoded with the code provide $\sim$90% noise reduction in experimental runs (Singh et al., 6 Dec 2024).
• Entanglement distillation and quantum memories: The code is employed for error-detection-based distillation, enhancing output fidelity, yield, and permitting logical entanglement re-distillation in quantum networks as a function of classical communication delay (Zheng et al., 8 Sep 2025).
• Homological product and many-hypercube codes: By recursive self-concatenation or pairing with homological surface codes, the code forms higher-distance codes for scalable logical architectures (Rines et al., 16 Sep 2025).

6. Code Automorphisms and Logical Clifford Gates

Logical Clifford operations can be efficiently realized via automorphism group analysis of the code’s symplectic matrix representations (Sayginel et al., 26 Sep 2024). The automorphism group, computed (e.g., via MAGMA), identifies column permutations and SWAPs that act as single-qubit Hadamard or SWAP gates transversally on the physical qubits. For the [[4,2,2]] code, examples include:

• Logical $H \otimes H$ from physical Hadamards on four qubits.
• Logical CNOT derived from SWAP-transversal operations.
• Full Clifford group coverage (potentially requiring embedded codes with additional qubits).

This framework ensures low-depth, fault-tolerant implementation of a universal set of logical gates, crucial for error-protected quantum computation.

7. Extensions: Permutational Invariance and Generalizations

Recent works have identified optimal permutationally invariant codes—including the ((4,2,2)) code—as special cases of families correcting single deletion or arbitrary Pauli errors (Aydin et al., 2023). In this construction, logical codewords are symmetric combinations of Dicke states:

$$\ket{\boldsymbol{c}_0} = \sqrt{\tfrac{1}{3}}\,|0000\rangle + \sqrt{\tfrac{1}{6}}\sum_{\text{Hamming wt}=3}|1\cdots 0\rangle\ \ket{\boldsymbol{c}_1} = \sqrt{\tfrac{1}{6}}\sum_{\text{Hamming wt}=1}|1 0 0 0\rangle - \sqrt{\tfrac{1}{3}}\,|1111\rangle$$

Permutation invariance grants both enhanced error correction for deletions and independence from error location. The family includes codes with improved length-to-distance trade-offs over prior constructions.

Summary

The [[4,2,2]] code provides a compact, efficient, and experimentally validated platform for error detection and fault-tolerant circuits. Its applications span high-fidelity gate implementations via dynamically corrected gates, adaptive syndrome extraction, quantum algorithm enhancement through post-selection, entanglement distillation, and scalable concatenated code architectures. Its permutational symmetry, transversal gate support, and automorphism-based logical gate constructions underpin both its theoretical and practical importance in quantum error correction and fault-tolerant quantum computation.

Key papers: (De et al., 2012, Vuillot, 2017, Roffe et al., 2017, Harper et al., 2018, Delfosse et al., 2020, Cane et al., 2021, Pokharel et al., 2022, Aydin et al., 2023, Gowrishankar et al., 5 May 2024, Sayginel et al., 26 Sep 2024, Singh et al., 6 Dec 2024, Berthusen et al., 20 Feb 2025, Zheng et al., 8 Sep 2025, Rines et al., 16 Sep 2025, Chertkov et al., 29 Sep 2025).