Three-Qubit Repetition Code

• The three-qubit repetition code is a quantum error correction module that encodes a logical qubit into three entangled physical qubits to correct single-qubit bit-flip or phase-flip errors.
• It employs stabilizer measurements and conditional feedback to detect and correct errors, achieving quadratic suppression of logical errors compared to individual physical qubits.
• The code serves as a foundational primitive in scalable, fault-tolerant architectures, enabling concatenated schemes, lattice surgery, and robust quantum communications.

The three-qubit repetition code is the archetype of quantum error correction (QEC) for protecting a single logical qubit against single-qubit errors. It is the minimal stabilizer code for either bit-flip (X) or phase-flip (Z) errors, forming the foundational module for more complex fault-tolerant architectures. Repetition codes are defined by encoding a single-qubit state into a three-qubit entangled state, with error detection and correction performed through stabilizer measurements and conditional feedback. Both forms—bit-flip and phase-flip—are experimentally realized in diverse quantum platforms, from superconducting circuits to cavity QED, and serve as functional primitives for concatenated and surface-code-based schemes. Performance studies rigorously quantify the logical error-rate suppression, break-even thresholds, and resource overheads.

1. Code Structure and Formal Definitions

The three-qubit repetition code comes in two variants: bit-flip and phase-flip. Each maps a single-qubit state into a three-qubit entangled state, yielding error correction for the respective dominant noise channel.

Bit-flip code (protects against X errors):

$$E_{\text{bit}}:\; \alpha|0\rangle + \beta|1\rangle \;\longmapsto\; \alpha|000\rangle + \beta|111\rangle$$

Phase-flip code (protects against Z errors):

Define the Hadamard basis $|\pm\rangle = (|0\rangle \pm |1\rangle)/\sqrt{2}$:

$$E_{\text{phase}}:\; \alpha|+\rangle + \beta|-\rangle \;\longmapsto\; \alpha|+++\rangle + \beta|---\rangle$$

The codespace is stabilized by two generators. For bit-flip:

$S_1 = Z_1Z_2,\qquad S_2 = Z_2Z_3$

For phase-flip (Hadamard-conjugated):

$S'_1 = X_1X_2,\qquad S'_2 = X_2X_3$

Logical operators act transversally: $X_L = X_1X_2X_3$, $Z_L = Z_1$ (or the product $Z_1Z_2Z_3$) for bit-flip, and analogous expressions for phase-flip (Reed et al., 2011, Morea et al., 2022, Huang, 2022).

2. Encoding, Syndrome Extraction, and Decoding Circuits

The encoding procedure universally relies on two CNOT gates:

• Given input $|\psi\rangle=\alpha|0\rangle+\beta|1\rangle$ on qubit 1, prepare qubits 2 and 3 in $|0\rangle$.
• Apply CNOT(1→2) and CNOT(1→3) to obtain $\alpha|000\rangle+\beta|111\rangle$.

Syndrome extraction (error detection) is accomplished by measuring stabilizers:

• For bit-flip: measure $Z_1Z_2$ and $Z_2Z_3$.
• For phase-flip: measure $X_1X_2$ and $X_2X_3$ after conjugating by Hadamard gates.

Decoding reverses the encoding (two CNOTs), with error correction typically performed by a three-qubit conditional gate, e.g., Toffoli (CCNot), which applies the required bit or phase flip based on the syndrome (Reed et al., 2011, Baek et al., 2018, Morea et al., 2022).

Table: Syndrome Table for Bit-Flip Code

Syndromes (s₁, s₂)	Error Location	Recovery Gate
(0,0)	None	I
(1,0)	Qubit 1	X₁
(1,1)	Qubit 2	X₂
(0,1)	Qubit 3	X₃

3. Logical Error Probability and Thresholds

The three-qubit code is capable of correcting any single X or Z error (depending on code variant). Residual logical errors arise only from two or more errors in the block.

For noise with error probability $p$ per qubit, the logical error probability becomes:

$P_{\text{logical}} = 3p^2(1-p) + p^3 = 3p^2 - 2p^3$

This quadratic scaling suppresses first-order ($O(p)$) errors, resulting in enhanced robustness (validated experimentally, e.g., $$f(p) = (0.76\pm0.005) - (1.46\pm0.03)p^2 + (0.72\pm0.03)p^3$$ for phase-flip correction (Reed et al., 2011)). For pure dephasing environments, the phase-flip code achieves logical fidelity exceeding that of a single idle qubit only when $T_1 > 2T_2^*$, with gate-error thresholds on the order $p_2 \lesssim 0.02$ (Rozgonyi et al., 2023).

4. Physical Implementations and Device Constraints

The three-qubit repetition code has been realized on several quantum platforms:

Superconducting circuits: Reed et al. (Reed et al., 2011) implement both code variants; syndrome extraction is coherent and Toffoli gates are engineered via third excited state avoided crossings (63 ns gate time). Fidelity to the classical truth table was $85\pm1\%$, process fidelity $78\pm1\%$.

Cavity QED: Ottaviani and Vitali (Ottaviani et al., 2010) encode information in circular Rydberg atoms via Jaynes–Cummings Hamiltonian in high-Q microwave cavities. Error modelled as phase noise; corrected fidelity reached 0.92 for realistic noise.

Transmon arrays (nearest-neighbor): Walking-ancilla architectures dynamically SWAP the ancilla state down a linear chain, supporting full syndrome extraction with efficient performance, at logical fidelities ≈0.9–0.95 (Kazmina et al., 25 Jun 2025).

Quantum repeater architectures: NV-center implementations employ electron-nuclear CNOTs and entanglement-mediated logic gates; encoded Bell pairs enhance QKD rates at scale (>200 km) (Jing et al., 2021, Bernardes et al., 2011).

Table: Typical Implementation Metrics

Platform	Code Realized	Logical Fidelity	Gate Depth
Superconducting	Bit-/Phase-flip	76–85%	63 ns Toffoli
Cavity QED	Phase-flip (Rydberg)	92%	~1.2 ms
Linear Transmon Chain	Bit-flip (walking)	90–95%	Doubled

5. Concatenation, Resource Overhead, and Channel Polarization

Concatenation of three-qubit codes is essential for general single-qubit error correction—e.g., the nine-qubit Shor code is the concatenation of bit- and phase-flip codes, able to correct arbitrary single-qubit errors (Reed et al., 2011).

The concatenated protocol is modular, with resource demands scaling as $Q_\ell = 3^\ell$ physical qubits and $N_{\text{tot}}$ gate operations. For non-ideal gates ($r=\text{gate accuracy}$): four-level concatenation yields fidelities up to 0.947 for amplitude-damping channel fidelity 0.9, with 81 qubits and 366 gates, outperforming five-qubit codes at comparable overhead (Huang, 2022).

Each repetition code “polarizes” the effective noise channel (amplifying a designated Pauli error), simplifying optimal code selection at each level of concatenation, and maximizing the logical fidelity (Huang, 2022).

6. Advanced Applications: Lattice Surgery, Quantum Channels, and Communication Protocols

Lattice surgery: The repetition code serves as a primitive in logical gate implementations, e.g., splitting a surface-code patch into two independent distance-3 repetition codes for fault-tolerant logical entanglement (Besedin et al., 8 Jan 2025). The protocols use rounds of X- and Z-stabilizer cycles and syndrome-based Pauli frame updating.

Quantum communication: Embedding each qubit of a protocol (e.g., superdense coding, teleportation) into a three-qubit repetition code blocks single-qubit error-induced entanglement loss (“sudden death”). Analytical mutual information and teleportation fidelity formulae show improved performance under moderate to high noise (Morea et al., 2022). In QKD repeaters, the encoded protocol achieves final fidelity 0.95 at 1280 km transmission, with per-memory rates of 24 Hz (Bernardes et al., 2011).

Break-even thresholds: Rigorous analysis shows that the phase-flip code can extend quantum memory lifetimes beyond that of a physical qubit in dephasing-limited systems, with optimal QEC cycle number $N_{\text{opt}}$ and gate-error thresholds identified (Rozgonyi et al., 2023).

7. Performance Limits, Connectivity, and Practical Considerations

The performance advantage of the three-qubit code critically depends on gate fidelity, circuit depth, qubit connectivity, and environmental noise:

• Logical error rate quadratic in physical error rate: only beneficial if gate errors and idle decoherence are sufficiently low—pseudo-threshold appears at $p \lesssim 10^{-4}$ in simulations (Baek et al., 2018).
• Circuit layout: nearest-neighbor constraints (SWAP overhead) reduce gain; all-to-all topology maximizes benefit (Baek et al., 2018, Kazmina et al., 25 Jun 2025).
• Practical feasibility: current technology permits logical-state tomography, post-selection protocols, and dynamical ancilla assignment with performance comparable to static ancilla schemes (Kazmina et al., 25 Jun 2025).
• Resource overhead for concatenated protocols is lower than for more complex codes at equivalent fidelity, supporting modular scaling in future architectures (Huang, 2022).

In summary, the three-qubit repetition code provides a robust, experimentally verified module for error suppression in both quantum memory and communication tasks, with clear theoretical thresholds and practical implementations across hardware platforms. Concatenation and advanced syndrome extraction enable scalable, modular quantum error correction, with resource-efficient performance and well-characterized limits.