Structural encoding with classical codes for computational-basis bit-flip correction in the early fault-tolerant regime

TL;DR

The paper addresses the challenge of achieving reliable quantum computation on early fault-tolerant hardware under limited overhead. It proposes a framework that encodes quantum computation into the codeword subspace of a systematic classical linear code, applying diagonal operators with zero overhead and handling non-diagonal operators via encoding conjugation, followed by per-shot classical decoding of measurement outcomes. Through simulations of Grover-like and IQP circuits, it demonstrates a trade-off between encoding overhead and error protection, showing that moderate codes often outperform stronger but more costly ones in realistic regimes, and that the benefits scale with circuit depth and size. The work highlights a practical, low-overhead error-mitigation layer that leverages classical coding theory as a quantum-structural tool, offering a complementary approach to QEC in the early fault-tolerant era and guiding code selection based on hardware noise characteristics.

Abstract

Achieving reliable performance on early fault-tolerant quantum hardware will depend on protocols that manage noise without incurring prohibitive overhead. We propose a novel framework that integrates quantum computation with the functionality of classical error correction. In this approach, quantum computation is performed within the codeword subspace defined by a classical error correction code. The correction of various types of errors that manifest as bit flips is carried out based on the final measurement outcomes. The approach leverages the asymmetric structure of many key algorithms, where problem-defining diagonal operators (e.g., oracles) are paired with fixed non-diagonal operators (e.g., diffusion operators). The proposed encoding maps computational basis states to classical codewords. This approach commutes with diagonal operators, obviating their overhead and confining the main computational cost to simpler non-diagonal components. Noisy simulations corroborate this analysis, demonstrating that the proposed scheme serves as a viable protocol-level layer for enhancing performance in the early fault-tolerant regime.

Figures (6)

• Figure 1: A conceptual circuit diagram for Grover's search algorithm using the proposed scheme. The system employs $k$ computational and $n-k$ ancilla qubits. The core feature is the asymmetric implementation: the diagonal oracle is applied directly with zero overhead, while the non-diagonal diffusion is implemented by conjugation with $U_E$ and $U_E^\dagger$. Final measurement outcomes are classically decoded to correct computational errors.
• Figure 2: Performance of the proposed scheme using the systematic $[13,7,3]$ code under varying two-qubit gate error rates for a 7-qubit Grover's search algorithm. Results are aggregated over 10 random seeds with 4,000 shots per seed (40,000 shots per configuration). The proposed scheme (blue) consistently boosts the mean conditional success probability ($P_{s|acc}^{\mathrm{mit}}$) compared to the unmitigated baseline ($P_{s|acc}^{\mathrm{base}}$), with absolute gains ranging from +1.7 to +6.2 percentage points. Error bars represent one standard deviation over the 10 random seeds.
• Figure 3: Impact of code strength and overhead for a 7-qubit problem ($k=7$) at a two-qubit gate error rate of $0.04\%$. The figure compares the conditional success probability ($P_{s|acc}^{\mathrm{mit}}$) of the lower-overhead $[13,7,3]$ ($d=3$) code with the stronger $[15,7,5]$ ($d=5$) code. Results are aggregated over 10 random seeds (40,000 total shots), and error bars represent one standard deviation. The superior performance of the $d=3$ code indicates that the gate overhead from the more complex encoding outweighs the benefit of a larger code distance in this regime.
• Figure 4: Impact of the parity-bit budget ($n-k$) on mitigation performance for a 7-qubit Grover's search algorithm ($d=3$) at a two-qubit gate error rate of 0.04%. Results are aggregated over 10 random seeds with 4,000 shots per seed (40,000 shots per configuration). The figure reports the conditional ($P_{s|acc}^{\mathrm{mit}}$) and unconditional ($P_{s}^{\mathrm{mit}}$) success probabilities, with the Acceptance (%) shown on the right $y$-axis. Error bars represent one standard deviation over the 10 random seeds. The $[17,7,3]$ code attains the highest unconditional performance ($54.9\%$), while $[15,7,3]$ offers the best practical trade-off between performance and circuit overhead.
• Figure 5: Fidelity gain ($\Delta f = f_{\mathrm{mit}} - f_{\mathrm{unmit}}$) of the proposed scheme on IQP sampling circuits versus circuit depth (layers) at a two-qubit gate error rate of $0.04\%$. Results are aggregated over 5 random seeds with 200,000 shots per seed (1,000,000 shots per configuration), and error bars represent one standard deviation over the seeds. A 7-qubit computational space $[13,7,3]$ is compared with an 11-qubit space $[17,11,3]$. The $[17,11,3]$ code yields larger and more stable gains. This improved scalability arises because the scheme adds a fixed two-qubit gate overhead (+7 for $[13,7,3]$ and +9 for $[17,11,3]$), the relative impact of which diminishes on average as circuit depth increases.