Fault-Tolerant Quantum Encoders

• Fault-Tolerant Encoders are quantum circuits that map initial states into quantum error-correcting codes while limiting the spread of physical errors.
• They employ techniques like block partitioning and transversal operations to confine errors within local regions, enhancing overall threshold performance.
• Architectures range from single-qudit schemes to concatenated gadgets and recursive polar encoders, balancing resource overhead with robust error suppression.

A fault-tolerant encoder is a quantum circuit designed to map initial quantum states or classical information into the code space of a quantum error-correcting code in such a way that physical faults during encoding do not induce uncorrectable logical errors, even under realistic noise models. Fault-tolerant encoders fundamentally constrain error propagation, aim for transversal or locality-preserving gate structures, and are integral to reliable quantum memory and communication. Recent developments span LDPC codes, single-qudit codes, concatenated/gadget-based encoders, recursive code families, and experiments on symmetric and high-rate codes.

1. Block Partitioning and Entanglement-Based Fault-Tolerant LDPC Encoders

The transversal fault-tolerant encoding procedure for CSS quantum LDPC codes begins by partitioning the $n$ qubits (data and ancilla) into $g$ contiguous blocks $B_1,\ldots,B_g$ such that $\sum_{j=1}^g n_j = n$, where each block $B_j$ contains qubit indices specific to code structure. For each stabilizer row, a $g$-qubit GHZ-type state $$|\Phi_g\rangle = (|0...0\rangle + |1...1\rangle)/\sqrt{2}$$ is preshared among blocks, with each block holding a single GHZ qubit $e_j$ assumed to be error-free.

The encoder replaces global CNOT operations (which would otherwise propagate errors across blocks) with local CNOTs inside each block. Specifically, CNOT gates that zero the X- and Z-parts of each stabilizer row are replaced so that only intra-block data and ancilla qubits interact with their block’s entangled GHZ qubit—no operation ever connects qubits from different blocks. The protocol, using local Hadamard or phase gates as necessary, guarantees that errors on one block cannot spread to other blocks.

This structure applies to both entanglement-unassisted variants (dual-containing codes, GHZ states only for fault-tolerance) and entanglement-assisted codes (additional Bell pairs for code support, GHZ qubits for encoder integrity), with total overhead linear in the number of blocks $g$ and stabilizer rows $\rho$ (Sharma et al., 12 May 2024).

2. Error Propagation, Threshold, and Code Distance Analysis

Error propagation in fault-tolerant encoders is quantitatively analyzed by comparing the probability $P_{NF}$ of non-fault-tolerant spreading versus $P_F$ in the transversal protocol—both derived in terms of depolarizing probability $p$ and the weight of the CNOT fan-ins:

• Non-fault-tolerant encoders allow a fault in a control qubit to spread to all targets of a high-weight CNOT, yielding

$$P_{NF,i} \le 1 - \left[1 - \frac{2p}{3} + \sum_{c\ \text{even} \le w_i} \binom{w_i}{c} \left(\frac{2p}{3}\right)^c\left(1-\frac{2p}{3}\right)^{w_i-c} \right].$$

• The transversal encoder, with each fan-out split across blocks into small weights $w_{i,j}$, achieves

$$P_{F,i} \le 1 - \prod_{j=1}^g \left[1 - \frac{2p}{3} + \sum_{c\ \text{even} \le w_{i,j}} \binom{w_{i,j}}{c} \left(\frac{2p}{3}\right)^c\left(1-\frac{2p}{3}\right)^{w_{i,j}-c} \right],$$

so that $P_{F} \ll P_{NF}$ whenever $w_{i,j} \ll w_i$.

The minimum code distance $d_q$ is not increased—$d_q \ge \min\{d_1,d_2\}$—but threshold behavior improves because error clusters are confined to their originating block (Sharma et al., 12 May 2024).

3. Fault-Tolerant Encoder Architectures Across Code Families

3.1. Single-Qudit Fault-Tolerant Encoding

For molecular-spin systems, a stabilizer code is implemented on a single $d$-level qudit, exploiting the natural error hierarchy $(\|E_0\| \gg \|E_1\| \gg \cdots)$ imposed by pure dephasing. Codewords $|0_L\rangle$, $|1_L\rangle$ are embedded as orthogonal subspaces spanning error blocks, and all logical gates $G_L$ and syndrome extractions are realized in one shot (block-diagonal for each error type), so no error can propagate into uncorrectable logical faults. Numerical results indicate nearly exponential suppression of logical errors in the dimension $d$, and thresholds competitive with multi-qubit codes ($T_2 \gtrsim 2\,\mu$s for $d=4$, $\bar{P}_L \sim 10^{-12}$ for $d=12$) (Mezzadri et al., 2023).

3.2. Concatenated Gadget-Protocol Encoders

Concatenated codes (e.g., generalized Shor codes) use a multitree butterfly structure with layers of local two-qubit operations and interleaving error-check trees. Each logical compression or non-Clifford gate is protected with low-overhead flag gadgets that catch correlated errors. Bayesian “probability-passing” decoders implement tensor-network-based syndrome updates after each layer, permitting operation up to state-preparation thresholds $e_c \approx 0.089$ (erasure) and $r_c \approx 0.015$ (unheralded noise) (Sommers et al., 31 May 2025). Resource overhead is minimal, and direct hardware experiments confirm the threshold in ion-trap systems.

3.3. Recursive Polar and Reed–Muller Encoders

Measurement-based recursive encoders for quantum polar codes $Q_1$ employ transversal two-qubit parity measurements at each recursion step. Immediate syndrome checking prevents error propagation beyond code distance, and only polynomial post-selection is necessary. These encoders outperform Shor’s code at the same block length for logical error rate ($p_L(10^{-3}) \sim 10^{-6}$ for $N=64$). Reed–Muller codes are recursively encoded with $O(\log n)$ depth and cut-optimal CNOT count, saturating the entropic lower bound for any bipartition, supporting transversal gates of the Clifford hierarchy and direct entanglement extraction (Goswami et al., 2022, Jayakumar et al., 23 May 2024).

3.4. Symplectic Double and High-Rate Codes

Symplectic double codes such as [[30,6,5]] admit logical $|+⟩^{\otimes 6}$ or $|0⟩^{\otimes 6}$ encoding via optimized Gaussian elimination and overlap methods, followed by low-overhead flag-based verification for crucial Z/X errors, achieving logical CNOT error scaling as $p^3$ and requiring substantially fewer resources than naive multi-copy encoders (Kanomata et al., 18 Sep 2025).

4. Gate Compatibility, Syndrome Extraction, and Resource Trade-Offs

Fault-tolerant encoders preserve compatibility between logical gates and syndrome extraction. Diagonal gates in the computational basis commute with codeword mappings and do not require overhead, whereas non-diagonal gates are transformed under the encoding/decoding unitaries $U_E,U_E^\dagger$. Post-correction is performed via syndrome table lookup and classical decoding. Overhead trade-offs (qubits, gate count, circuit depth) are highly code dependent, with medium-scale LDPC and high-rate codes delivering linear or logarithmic resource growth instead of exponential (Sohn et al., 13 Oct 2025, Jayakumar et al., 23 May 2024).

Table: Resource and Error Trade-Offs Illustrative in Fault-Tolerant Encoders

Code Family	Qubit Overhead	Gate Count	Logical Error Scaling
QLDPC + GHZ blocks	$O(g n)$	$O(n+\rho g)$	$\sim p^2$, threshold up
Single-qudit codes	1 qudit	$O(d)$ pulses	$\sim \exp(-\alpha d)$
[[15,7,3]] Hamming	15–19 qubits	$O(n)$ + gadgets	$\sim p^2$, flag-reject
Polar/Reed–Muller	$O(n)$	$O(n)$, $\log n$	$A p^w$ ($w\sim d$)
Symplectic double	$O(n)$	$O(n)$, flag-check	$p^{(d+1)/2}$, low overhead

Resource scaling is precise per code specification; thresholds and error rates reflect full circuit-level error modeling.

5. Integration in Communication, Quantum Memory, and Universal Computation

Fault-tolerant encoders are applicable in quantum communication protocols, ensuring that noisy encoding and decoding circuits do not degrade channel capacity below a threshold $p_{\rm th}$. Universal quantum computation schemes incorporate encoder designs with transversal operations, code switching, and magic-state injection, combining hardware-specific constraints (e.g., block locality, mid-circuit measurement, ancilla re-use) (Belzig et al., 2022, Christandl et al., 2020, Christandl et al., 9 Aug 2024, Pogorelov et al., 20 Mar 2024).

For quantum memory, ancilla distillation routines using low-depth codes plus Steane-style gadgets realize practical logical block preparation at tolerable error rates ($p_{\rm erasure} \lesssim 2\%$). For magic-state preparation, multitree and recursive encoder designs permit direct injection and distillation, yielding noise levels compatible with threshold distillation protocols.

6. Limitations, Open Problems, and Future Directions

Despite improved thresholds and resource scaling, limitations persist:

• Preshared multipartite entanglement (GHZ, Bell) is required for some LDPC encoders; their generation and storage with high fidelity is challenging.
• Block partitioning may be inefficient for highly irregular LDPC matrices, reducing effectiveness of the protocol.
• Code distance and optimal logical error rate are not increased by encoder structure—only threshold constants and prefactors improve.
• In hardware with strictly local connectivity, transversal or block-based encoders may require circuit layout optimization.

Continued research addresses scalable entanglement-sharing, LDPC block tuning, integration of measurement-based recursion beyond single-logical codes, and hardware-specific scheduling for universal gate sets across codes with complementary fault-tolerance properties.

• Fault-Tolerant Quantum LDPC Encoders (Sharma et al., 12 May 2024)
• Fault-Tolerant Computing with Single Qudit Encoding (Mezzadri et al., 2023)
• Observation of a Fault Tolerance Threshold with Concatenated Codes (Sommers et al., 31 May 2025)
• Structural encoding with classical codes for computational-basis bit-flip correction in the early fault-tolerant regime (Sohn et al., 13 Oct 2025)
• Fault-tolerant Coding for Entanglement-Assisted Communication (Belzig et al., 2022)
• Fault-tolerant quantum error detection (Linke et al., 2016)
• Fault-Tolerant Preparation of Quantum Polar Codes Encoding One Logical Qubit (Goswami et al., 2022)
• Every Action in Every Code is Fault Tolerant: Fault Tolerance Quantum Computation in Quotient Algebra Partition (Su et al., 2019)
• Fault-Tolerant Quantum Memory using Low-Depth Random Circuit Codes (Nelson et al., 2023)
• Fault-tolerant quantum input/output (Christandl et al., 9 Aug 2024)
• Fault-tolerant correction-ready encoding of the [[7,1,3]] Steane code on a 2D grid (Rodriguez-Blanco et al., 1 Apr 2025)
• Fault-tolerant quantum computation with few qubits (Chao et al., 2017)
• Fault-tolerant Coding for Quantum Communication (Christandl et al., 2020)
• Experimental fault-tolerant code switching (Pogorelov et al., 20 Mar 2024)
• Efficient recursive encoders for quantum Reed-Muller codes towards Fault tolerance (Jayakumar et al., 23 May 2024)
• Fault-tolerant quantum computing with a high-rate symplectic double code (Kanomata et al., 18 Sep 2025)