CliNR: Error Correction for Clifford Circuits

• CliNR is a family of quantum protocols that reduces logical error rates in Clifford circuits through gate teleportation and offline stabilizer verification.
• It enables scalable error suppression with polynomial overhead, significantly lowering qubit and sampling costs compared to full quantum error correction.
• Variants like recursive, distributed, and optimized CliNR offer tailored trade-offs between qubit overhead, computational depth, and logical error suppression in diverse quantum architectures.

The CliNR error correction scheme is a family of quantum protocols designed for reducing the logical error rate of Clifford circuits. It achieves this with substantially lower overhead than full quantum error correction (QEC) and without the exponential sampling costs characteristic of statistical error mitigation. CliNR incorporates offline stabilizer verification of resource states, gate teleportation-based subcircuit injection, and scalable, parallelizable orchestration suitable for both monolithic and distributed quantum computing architectures (Delfosse et al., 9 Jul 2024, Dobbs et al., 11 Dec 2025, Brodutch et al., 27 Nov 2025, Tham et al., 17 Apr 2025).

1. Scheme Architecture and Operational Principles

CliNR targets $n$-qubit Clifford circuits of size $s$. The core idea is to decompose the target circuit $C$ into $t$ subcircuits, each small enough to keep resource and error accumulation manageable: $C = C_1 \circ C_2 \circ \dots \circ C_t$ Each $C_i$ is implemented via gate teleportation, utilizing Bell pairs and “third block” ancillary qubits:

1. Prepare $n$ Bell pairs on $(n+i, 2n+i)$ for $i = 1..n$.
2. Apply $C_i$ to the third logical block ($2n+1,\ldots,3n$).
3. Teleport the data register through the Bell pairs, performing appropriate Pauli corrections as determined by measurement outcomes: $$Q = \prod_{i=1}^n (C_i^\dagger X_{2n+i} C_i)^{o_{n+i}} (C_i^\dagger Z_{2n+i} C_i)^{o_i}$$ This procedure is repeated sequentially for each subcircuit so that the overall computation $C$ is stably realized.

Prior to every gate teleportation, the $2n$-qubit resource state $$(I\otimes C_i)\left(|\Phi^+\rangle^{\otimes n}\right)$$ is subjected to $r$ random stabilizer checks from its stabilizer group. Single faults in the state are detected except with probability $2^{-r}$, and only the preparation is restarted upon detection, not the entire computation. This stabilizer verification is highly scalable due to its offline, modular structure (Delfosse et al., 9 Jul 2024, Brodutch et al., 27 Nov 2025).

2. Logical Error Rate Analysis and Overhead Scaling

The logical error rate after CliNR correction, $p_{\mathrm{log}}$, admits a precise upper bound: $$p_{\mathrm{log}} \le t \cdot \frac{g_p(3n + s_0) 2^{-r} + 2g_p(2n+3) + g_p(5n)}{(1-p)^{m_0}}$$ where $g_p(x) = 1-(1-p)^x$, $s_0 = \lceil s/t\rceil$, and $m_0 = 3n + s_0 + (2n+3)r$.

The regime for vanishing logical error rate is correspondingly enhanced: $nsp^2 \to 0$ By choosing $t = \lfloor\sqrt{s/n}\rfloor$ and $r = \lfloor \log(s/n)\rfloor$, one achieves $p_{\mathrm{log}} \to 0$ precisely when $nsp^2 \to 0$. This is strictly superior to bare implementations, which only require $sp \to 0$. The overheads scale favorably: the qubit number is $3n+1$ (tending to $3n$ for large $n$), and the average gate overhead is approximately $2s$ (Delfosse et al., 9 Jul 2024, Brodutch et al., 27 Nov 2025).

CliNR thus bridges a critical gap: it provides polynomial overhead error reduction far beyond bare implementations, yet without the exponential resource demands of QEC. For $n=25, p_2=10^{-3}$, simulation shows a halving of logical error rate, and for $n=60, p_2=10^{-4}$, a reduction by a factor of approximately 4 (Delfosse et al., 9 Jul 2024).

3. Protocol Variants: Recursive, Distributed, and Optimized CliNR

Recursive CliNR

Recursive CliNR extends the original to deeper circuit decompositions. Instead of one level of subcircuits, subroutines are nested in a tree structure: each injection at level $\ell$ is itself implemented by CliNR at level $\ell+1$. For a circuit of size $s$ and physical error rate $p$, choosing depth $D = \lceil \log_2(sp)\rceil + 1$ yields:

• Qubit overhead: $(2D+1)n + 1 \leq (2\lceil \log(sp)\rceil+3)n + 1$
• Expected total gates: $\leq 24s \lceil (sp)^4 \rceil$
• Logical error scaling: $p_L \leq O(s n^D p^{D+1})$, allowing vanishing $p_L$ provided $np\to 0$ (Brodutch et al., 27 Nov 2025)

Recursive CliNR is advantageous for large $s$ and moderate $p$, outperforming the original in both overhead and logical error suppression within suitable parameter regimes.

Distributed CliNR

The distributed variant adapts the protocol to multi-QPU architectures with slow interconnects (Dobbs et al., 11 Dec 2025). The subcircuits are assigned to separate QPUs arranged in a ring topology; resource state preparation and verification are parallelized across QPUs. The performance is dominated either by parallel preparation depth ($O(\ln t)$) or by the time to produce the required Bell pairs for inter-QPU injection ($n \tau_e$), where $\tau_e$ is the entanglement generation time.

Depth scaling for distributed CliNR is: $$\mathrm{Depth}_\mathrm{dist} \leq \max \left\{ \frac{\delta}{1-q} (\ln t +3), n\,\tau_e \right\} + 4t$$ For $\tau_e \leq 5$, distributed CliNR achieves both lower logical error rates and shallower depth than monolithic or direct implementations for circuits up to $n=85$, $p=10^{-4}$ (Dobbs et al., 11 Dec 2025).

Optimized CliNR

CliNR performance is sensitive to the choice of verification stabilizers. Recent advances employ global and two-step optimization algorithms (e.g., tabu search with Grassmann symmetries and proxies for MC-evaluated logical error rates) to select verification sequences. These approaches shrink the search space by large symmetry factors (e.g., $168\times$ or $20,160\times$ reduction) and, in numerical simulations, improve logical error rate by $25\%$ over random-sequence implementations (with significant savings in MC cost). Experiments on a 36-qubit trapped-ion device using a CZNR variant confirm “breakeven” performance relative to uncorrected runs (Tham et al., 17 Apr 2025).

4. Comparative Perspective and Relation to Other Error Suppression Methods

CliNR is distinct from both QEC and classical error mitigation:

• QEC: Achieving $p_{\mathrm{log}}\to 0$ with codes like the surface code requires $\tilde O(1/p)$–$\tilde O(1/p^2)$ physical qubits per logical, often hundreds or thousands per logical block. CliNR uses only $3n+1$ qubits for $n$ logical qubits, delivering substantial resource savings (Delfosse et al., 9 Jul 2024).
• Coherent Parity Check (CPC): CPC applies few Pauli checks to reduce error but faces either a hard ceiling (constant improvement) or exponential sampling cost. CliNR “teleports” CPC checks into offline ancilla verification, breaking sampling bottlenecks. Only ancillary preparations are retried, and the main circuit proceeds with zero global rejection rate.
• Index coding and classical NR schemes: While a “CliNR” label is erroneously applied to some classical redundancy schemes (Upadhyaya et al., 2019), authentic CliNR is fundamentally a Clifford circuit, quantum protocol.

CliNR thus fills a technological niche for near-term quantum devices, where full QEC is infeasible and statistical mitigation is inadequate.

5. Limitations, Open Problems, and Future Directions

Known limitations of CliNR include:

• Idle noise and coherence: Recursive and distributed variants can increase idle periods for qubits and ancillas. Schemes are best suited to architectures with long qubit coherence times (e.g., trapped ions) (Brodutch et al., 27 Nov 2025).
• Resource-state selection: Further gains are possible from more sophisticated subcircuit grouping, adaptive stabilizer selection, and tree-structure optimization.
• Parallelization vs. resource budget: Recursive CliNR trades depth for ancilla use; parallelizing at each tree depth reduces wall-clock time but increases qubit overhead.
• Integration with QEC: A plausible implication is that CliNR, especially in recursive form, may serve as a pre-filtering stage to suppress logical noise ahead of heavier code-based error correction.

Further research targets integrating CliNR as an auxiliary error-filter, extending optimization heuristics, and adapting the scheme to hybrid Clifford/non-Clifford circuits for quantum superiority experiments (Dobbs et al., 11 Dec 2025).

6. Summary Table of Main CliNR Regimes and Overheads

Protocol Variant	Qubit Overhead	Gate Overhead	Logical Error Scaling
Original CliNR	$3n+1$	$2s+o(s)$	$p_{\mathrm{log}} \to 0$ if $nsp^2\to 0$
Recursive CliNR	$(2D+1)n+1$ ($D\sim\log(sp)$)	$24s\lceil(sp)^4\rceil$	$p_{\mathrm{log}}\to 0$ if $np\to 0$
Distributed CliNR	$(t+1)n$ across $t+1$ QPUs	see main text	Same as monolithic (under entanglement constraints)

This table summarizes overhead and scaling features for key CliNR variants (Delfosse et al., 9 Jul 2024, Brodutch et al., 27 Nov 2025, Dobbs et al., 11 Dec 2025).

7. Empirical Performance and Experimental Status

Numerical simulations consistently demonstrate that CliNR can halve or quarter logical error rates for moderate-scale Clifford circuits under realistic noise ($p_2=10^{-3}$–$10^{-4}$, $n$ up to $100$) while maintaining hardware overhead under practical constraints. The first experimental demonstration (36-qubit IonQ device) shows parity of logical error rates between CZNR and direct implementations (“breakeven”), validating real-world applicability (Tham et al., 17 Apr 2025).

The scheme shows substantial promise for near-term devices, scalable distributed architectures, and as part of composite quantum error mitigation and correction stacks.