Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2610.06606

Staying Sober: A Shot-Free Predictor of Logical Error Rates for Concatenated Quantum Error Correcting Codes

Sayam Sethi, Aditi Awasthi, Maxwell Poster, Joshua Viszlai, Jonathan Mark Baker

quant-phSubmitted Oct 5, 2026• Announced Oct 6, 2026• 0 citations
arXivHTMLPDF

Abstract

Estimating the logical error rate (LER) of a quantum error-correcting (QEC) code by Monte Carlo sampling takes $O(p^{-\lceil d/2 \rceil}/\varepsilon^2)$ samples at physical error rate $p$, code distance $d$ and relative error $\varepsilon$, which becomes intractable at large distances and low error rates, and especially for concatenated codes, whose distance grows as $d^{\ell}$ with the number of levels $\ell$. The fail fast method reduces this cost by sampling the failures of each weight separately, but it only works for unconcatenated codes, and does not model the soft information that the levels of a concatenated code pass to each other. We propose a predictor that takes the stabilizers, the minimum-weight logical operators and, for odd $d$, the logical operators of weight $d + 1$ of a code, and computes, without sampling, the leading monomial $c\,p^{o}$ of the LER when expressed as a polynomial in $p$, at every level of concatenation, in time polynomial in the code parameters and linear in $\ell$ for fixed budgets. We prove that our prediction is exact for any unconcatenated stabilizer code, for every logical observable and arbitrary per-qubit error rates, whenever no budget is exhausted. Furthermore, for concatenated codes, we construct a recursive approach that computes the leading monomial exactly in exponential time, and our predictor approximates this approach. Our predictions match exact enumeration at level 1 on every code we evaluate, and up to three levels for the iceberg code. Using our predictor, we evaluate and compare $37$ code configurations under four noise biases in $48$ core-hours, where Monte Carlo sampling would need more than $10^{12}$ shots at $p = 10^{-3}$ for $113$ of these $148$ cases.

AI Summary

Estimating very small logical error rates (LERs) by direct Monte Carlo becomes impractical as code distance and concatenation depth increase. This paper targets the low-noise leading term $c p^o$ for maximum-likelihood decoding of stabilizer codes and soft tree decoding of concatenated codes, rather than the full finite-$p$ LER. For an unconcatenated distance-$d$ code, it identifies leading-weight failures using weight-$d$ logical operators, weight-$(d+1)$ logical operators when $d$ is odd, and low-weight stabilizers. Möbius inversion over logical-operator intersections avoids double counting. The resulting coefficient is exact, subject to the stated leading-order tie convention, for observables flipped by a minimum-weight logical operator, with $o=\lceil d/2\rceil$ and arbitrary positive per-qubit Pauli biases. An exact but exponential recursion propagates distributions of likelihood-order gaps and coefficient ratios through concatenation. A budgeted dynamic program approximates this recursion; for fixed budgets its runtime is polynomial in distance and supplied logical-operator count, and linear in concatenation depth. Small-code enumeration agrees within $0.1\%$ at level 1 and $p=3.2\times10^{-4}$, and within $0.2\%$ for iceberg concatenation through level 3. Comparing 37 configurations under four biases takes 48 core-hours. The main setting assumes independent Pauli errors and perfect syndrome measurements. Higher-level approximations discard correlations and truncate configurations without an accuracy guarantee. Tree decoding is ML only for single-logical-qubit blocks. Complete logical-operator enumeration can be costly or unavailable; exhausted budgets can trigger sampling. The asymptotic predictions have no general finite-$p$ validity bound.

Little sign of AI-generated textOverclaimsStrong assumptionsPossible error

Central claim may not hold: The abstract promises exactness for every logical observable, whereas the unconcatenated theorem only covers observables flipped by a minimum-weight logical operator. The predictor uses sampling when certain budgets are exceeded, and some evaluated inputs are sampled, so its sampling-free description needs explicit qualification. The leading-term tie rule can disagree with actual maximum-likelihood decoding and produce an incorrect leading logical-error coefficient for an individual observable, even under the unconcatenated theorem's assumptions.

Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.

Comments
25 pages, 10 figures

Related papers

Exploring Asymmetric QEC Code Concatenation

Sayam Sethi, Maxwell Poster, Aditi Awasthi +3 more

Concatenated quantum error-correcting codes have recently gained popularity because they improve the effective distance of a joint code without requiring the discovery of new codes with desirable parameters. A common building block for such studies is the $[[4,1,2]]$ Iceberg code, the smallest error-detecting code and therefore the one with the lowest resource overhead. However, it has an asymmetric number of $X$ and $Z$ checks, and concatenating it produces skewed logical error rates (LERs) between the $X$ and $Z$ observables. This asymmetry can be mitigated by Clifford-deforming the individual blocks of the concatenation, but the space of possible Hadamard deformations grows doubly exponentially with the number of concatenation levels. We formalize this deformation space and investigate it by proposing six concrete deformation strategies, which we compare under a code capacity (with and without bias) noise model using a concatenated maximum-likelihood soft-information decoder. Among the strategies we study, one one of them achieves near-identical $X$ and $Z$ LERs in a logical-memory experiment while simultaneously reducing the total LER (the sum of the $X$ and $Z$ error rates).

quant-pharXiv:2609.25251•Sep 23, 2026•1 citation

Fail fast: techniques to probe rare events in quantum error correction

Michael E. Beverland, Malcolm Carroll, Andrew W. Cross +1 more

The ultimate goal of quantum error correction is to create logical qubits with very low error rates (e.g. 1e-12) and assemble them into large-scale quantum computers capable of performing many (e.g. billions) of logical gates on many (e.g. thousands) of logical qubits. However, it is necessarily difficult to directly assess the performance of such high-quality logical qubits using standard Monte Carlo sampling because logical failure events become very rare. Building on existing approaches to this problem, we develop three complementary techniques to characterize the rare-event regime for general quantum low-density parity-check (qLDPC) codes under circuit noise. (I) We propose a well-motivated, low-parameter ansatz for the failure spectrum (the fraction of fault sets of each size that fail) that empirically fits all the QEC systems we studied and predicts logical error rates at all physical error rates. (II) We find min-weight logical operators of syndrome measurement circuits and exactly compute the number of min-weight failing configurations. (III) We generalize the splitting method to qLDPC codes using multi-seeded Metropolis sampling to improve convergence for systems with many inequivalent logical operators. We apply these tools to distance-6, -12, and -18 bivariate bicycle codes under circuit noise, observing strong low-error-rate performance with the recently proposed Relay decoder but also considerable scope for further improvement.

quant-pharXiv:2511.15177•Nov 20, 2025•32 citations

ReloQate: Transient Drift Detection and In-Situ Recalibration in Surface Code Quantum Error Correction

Maxwell Poster, Jason Chadwick, Jonathan Mark Baker

Quantum error correction (QEC) promises to exponentially suppress qubit noise, but typically assumes spatially-uniform and temporally-constant noise rates. However, real quantum hardware exhibits variation in noise levels over time, which will be amplified by QEC if not addressed. To mitigate this drift in error rates, we leverage transient information readily available in surface code quantum error correction to predict logical error rates (LER) in real time. We infer a prediction model by sampling physical error rates from real hardware, and mapping detector fire rate (DFR), or parity of stabilizer measurements across QEC rounds, to LER. This allows for on-the-fly LER predictions without the typical characterization overhead required to determine LER. This method can easily be extended to other stabilizer codes. Importantly, we observe that this prediction should be accurate yet conservative (i.e. give an upper estimate) to enable appropriately fast responses to real-time physical error changes. That is, responses should be executed marginally ahead of time to allow for their execution to complete, and minimize time spent (ideally none) above intolerable error rates. More importantly, we pair this predictor with a scheme which remaps drifted logical qubits to fresh tiles in a patch-based architecture while their original tiles are recalibrated. Our results demonstrate DFR-based prediction to be an effective LER predictor, and remapping as a spatially efficient and timely mitigation response for small code distances, both of which are significant steps in furthering practical QEC.

quant-pharXiv:2603.00837•Mar 3, 2026•1 citation

Learning to Concatenate Quantum Codes

Nico Meyer, Christopher Mutschler, Dominik Seuß +2 more

Concatenating quantum error correction codes scales error correction capability by driving logical error rates down double-exponentially across levels. However, the noise structure shifts under concatenation, making it hard to choose an optimal code sequence. We automate this choice by estimating the effective noise channel after each level and selecting the next code accordingly. In particular, we use learning-based methods to tailor small, non-additive encoders when the noise exhibits sufficient structure, then switch to standard codes once the noise is nearly uniform. In simulations, this level-wise adaptation achieves a target logical error rate with far fewer qubits than concatenating stabilizer codes alone--reducing qubit counts by up to two orders of magnitude for strongly structured noise. Therefore, this hybrid, learning-based strategy offers a promising tool for early fault-tolerant quantum computing.

quant-pharXiv:2604.14931•Apr 17, 2026•2 citations

Error Attribution as a Resource-Allocation Principle for Quantum Error Correction: Sensitivity-Guided Noise Reduction and Its Analytic Limits

Rowan Brad Quni-Gudzinas

Logical error rate is the standard benchmark for quantum error correction (QEC), but it is an aggregate quantity: it says nothing about which circuit components actually drive logical failure. Recent work introduced an error attribution scheme that computes per-component sensitivities $\partial P_L/\partial p_i$ of the logical error rate jointly from the same Monte Carlo samples used to estimate $P_L$, and showed that halving noise on the 5%–7% most sensitive components reduces logical error rates by roughly 15%–25%, about twice the improvement from randomly chosen components [1],[3]. This paper develops the quantitative structure underlying that result. We formalize the sensitivity map, derive the first-order intervention gain for targeted versus random noise-reduction budgets, and show analytically that the targeted-to-random advantage is $\rho = r/(fr + 1 - f)$, where $f$ is the hotspot fraction and $r$ the sensitivity contrast; for $f = 0.06$ and $r = 2.136$ this ratio is exactly $2$, matching the reported factor. We further show that the reported 15%–25% reductions exceed the first-order prediction of about 6% by an amplification factor of approximately $3.15$, which we attribute to nonlinear, multiplicative error propagation absent from independent-error models. We derive Monte Carlo sample-complexity requirements for the sensitivity estimator, situate attribution among channel-optimized, reinforcement-learning, and robustness-optimized QEC strategies, and identify failure modes: coherent noise, estimator variance at low $P_L$, sensitivity redistribution, and non-stationary drift. ## 1. Introduction Quantum error correction protects quantum information by encoding logical qubits redundantly and decoding measured syndromes, and its performance is almost universally reported as a single number: the logical error rate $P_L$, the probability that a logical operator flips during a memory experiment or computation cycle. This aggregate benchmark is necessary but i Full text and updates: papers.qnfo.org/papers/error-attribution-as-a-resource-allocation-principle-for-quantum-error-correctio/

•Oct 5, 2026•0 citations

Comparative Analysis of Logical Error Rate Scaling in the Three-Qubit Bit-Flip Code and the Distance-3 Surface Code Under Depolarizing Noise: A Simulation Study Using Qiskit Aer and a Validated Stabilizer-Formalism Engine

B U Shanjeev

Quantum error correction (QEC) is a prerequisite for fault-tolerant quantum computation, yet the overhead cost—the number of physical qubits required to encode and protect a single logical qubit—varies substantially across QEC code families. This paper presents a systematic simulation-based comparison of two paradigmatic QEC codes: the three-qubit bit-flip repetition code and the distance-3 surface code. The bit-flip code is simulated by literal Qiskit Aer circuit execution (encoding, injected depolarizing noise, and dynamic classical feed-forward correction). The distance-3 surface code is instead simulated with a custom, vectorized stabilizer-formalism engine, because its 17-qubit noisy circuit would be far more expensive to run shot-by-shot in Aer at the scale needed here. This engine implements the same Aaronson-Gottesman algorithm underlying Aer's stabilizer backend and is cross-validated against genuine Aer circuit execution at a representative operating point; no surface-code result in this paper comes from literal Aer execution. We apply an independent single-qubit depolarizing channel at physical error rates p ∈ [0.001, 0.30] and measure the resulting logical error rate P_L for each code across 200,000 independent trials per data point (95% Wilson confidence intervals reported throughout). We identify the pseudo-threshold p*—the physical error rate at which a code's logical error rate equals the uncorrected physical error rate, and compare simulated crossover points against closed-form analytical predictions. Our results reveal a more nuanced picture than the naive threshold-theorem intuition suggests. The three-qubit bit-flip code cannot correct phase-type errors under any circumstance: under a full quantum-state-protection criterion its logical error rate exceeds the physical error rate for every physically meaningful p, with the two curves crossing only at p ≈ 0.75 deep in the maximally-mixed regime and of no practical relevance. Under the narrower, but operationally standard, "bit-observable" criterion (protection of a definite computational-basis value only), the code is unconditionally beneficial (P_L < p) across the entire tested range, because the 2/3 fraction of depolarizing weight that manifests as a detectable bit-flip is compressed further by majority-vote correction. These two results are not contradictory: they evaluate different protection goals—preservation of a classical bit value versus preservation of an arbitrary quantum state—and every comparison in this paper that mixes the two is labeled accordingly. Under this study's idealized, single-round setup, the distance-3 surface code achieves a simulated finite-size pseudo-threshold of p*_SC ≈ 0.083 (8.3%)—a result specific to noiseless syndrome extraction, a single correction round, and an exact minimum weight decoder, and not a hardware representative or asymptotic threshold. That figure is roughly three orders of magnitude higher than an order-of-magnitude literature extrapolation of ≈ 5.6 × 10⁻⁵ (substituting the asymptotic literature threshold p_th ≈ 0.75% into a power law fit for a different, many-round, measurement noisy regime, not a dedicated prediction for our exact setup); the gap is attributable to precisely those idealizations. The surface code requires 17 physical qubits per logical qubit in our implementation (9 data + 8 ancilla) versus 3 for the bit-flip code, a ≈ 5.7× overhead, quantitatively illustrating the overhead-versus-protection tradeoff fundamental to near-term fault-tolerant architectures. All simulation code is available at https://github.com/shanjeev-b-u/qec-code-comparison-depolarizing-noise

•Jul 26, 2026•0 citations
Estimating the logical error rate (LER) of a quantum error-correcting (QEC) code by Monte Carlo sampling takes O(p−⌈d/2⌉/ε2)O(p^{-\lceil d/2 \rceil}/\varepsilon^2)O(p−⌈d/2⌉/ε2) samples at physical error rate ppp, code distance ddd and relative error ε\varepsilonε, which becomes intractable at large distances and low error rates, and especially for concatenated codes, whose distance grows as dℓd^{\ell}dℓ with the number of levels ℓ\ellℓ. The fail fast method reduces this cost by sampling the failures of each weight separately, but it only works for unconcatenated codes, and does not model the soft information that the levels of a concatenated code pass to each other. We propose a predictor that takes the stabilizers, the minimum-weight logical operators and, for odd ddd, the logical operators of weight d+1d + 1d+1 of a code, and computes, without sampling, the leading monomial c poc\,p^{o}cpo of the LER when expressed as a polynomial in ppp, at every level of concatenation, in time polynomial in the code parameters and linear in ℓ\ellℓ for fixed budgets. We prove that our prediction is exact for any unconcatenated stabilizer code, for every logical observable and arbitrary per-qubit error rates, whenever no budget is exhausted. Furthermore, for concatenated codes, we construct a recursive approach that computes the leading monomial exactly in exponential time, and our predictor approximates this approach. Our predictions match exact enumeration at level 1 on every code we evaluate, and up to three levels for the iceberg code. Using our predictor, we evaluate and compare 373737 code configurations under four noise biases in 484848 core-hours, where Monte Carlo sampling would need more than 101210^{12}1012 shots at p=10−3p = 10^{-3}p=10−3 for 113113113 of these 148148148 cases.
Estimating very small logical error rates (LERs) by direct Monte Carlo becomes impractical as code distance and concatenation depth increase. This paper targets the low-noise leading term cpoc p^ocpo for maximum-likelihood decoding of stabilizer codes and soft tree decoding of concatenated codes, rather than the full finite-ppp LER.
For an unconcatenated distance-ddd code, it identifies leading-weight failures using weight-ddd logical operators, weight-(d+1)(d+1)(d+1) logical operators when ddd is odd, and low-weight stabilizers. Möbius inversion over logical-operator intersections avoids double counting. The resulting coefficient is exact, subject to the stated leading-order tie convention, for observables flipped by a minimum-weight logical operator, with o=⌈d/2⌉o=\lceil d/2\rceilo=⌈d/2⌉ and arbitrary positive per-qubit Pauli biases. An exact but exponential recursion propagates distributions of likelihood-order gaps and coefficient ratios through concatenation. A budgeted dynamic program approximates this recursion; for fixed budgets its runtime is polynomial in distance and supplied logical-operator count, and linear in concatenation depth.
Small-code enumeration agrees within 0.1%0.1\%0.1% at level 1 and p=3.2×10−4p=3.2\times10^{-4}p=3.2×10−4, and within 0.2%0.2\%0.2% for iceberg concatenation through level 3. Comparing 37 configurations under four biases takes 48 core-hours.
The main setting assumes independent Pauli errors and perfect syndrome measurements. Higher-level approximations discard correlations and truncate configurations without an accuracy guarantee. Tree decoding is ML only for single-logical-qubit blocks. Complete logical-operator enumeration can be costly or unavailable; exhausted budgets can trigger sampling. The asymptotic predictions have no general finite-ppp validity bound.
Concatenated quantum error-correcting codes have recently gained popularity because they improve the effective distance of a joint code without requiring the discovery of new codes with desirable parameters. A common building block for such studies is the [[4,1,2]][[4,1,2]][[4,1,2]] Iceberg code, the smallest error-detecting code and therefore the one with the lowest resource overhead. However, it has an asymmetric number of XXX and ZZZ checks, and concatenating it produces skewed logical error rates (LERs) between the XXX and ZZZ observables. This asymmetry can be mitigated by Clifford-deforming the individual blocks of the concatenation, but the space of possible Hadamard deformations grows doubly exponentially with the number of concatenation levels. We formalize this deformation space and investigate it by proposing six concrete deformation strategies, which we compare under a code capacity (with and without bias) noise model using a concatenated maximum-likelihood soft-information decoder. Among the strategies we study, one one of them achieves near-identical XXX and ZZZ LERs in a logical-memory experiment while simultaneously reducing the total LER (the sum of the XXX and ZZZ error rates).
The ultimate goal of quantum error correction is to create logical qubits with very low error rates (e.g. 1e-12) and assemble them into large-scale quantum computers capable of performing many (e.g. billions) of logical gates on many (e.g. thousands) of logical qubits. However, it is necessarily difficult to directly assess the performance of such high-quality logical qubits using standard Monte Carlo sampling because logical failure events become very rare. Building on existing approaches to this problem, we develop three complementary techniques to characterize the rare-event regime for general quantum low-density parity-check (qLDPC) codes under circuit noise. (I) We propose a well-motivated, low-parameter ansatz for the failure spectrum (the fraction of fault sets of each size that fail) that empirically fits all the QEC systems we studied and predicts logical error rates at all physical error rates. (II) We find min-weight logical operators of syndrome measurement circuits and exactly compute the number of min-weight failing configurations. (III) We generalize the splitting method to qLDPC codes using multi-seeded Metropolis sampling to improve convergence for systems with many inequivalent logical operators. We apply these tools to distance-6, -12, and -18 bivariate bicycle codes under circuit noise, observing strong low-error-rate performance with the recently proposed Relay decoder but also considerable scope for further improvement.
Quantum error correction (QEC) promises to exponentially suppress qubit noise, but typically assumes spatially-uniform and temporally-constant noise rates. However, real quantum hardware exhibits variation in noise levels over time, which will be amplified by QEC if not addressed. To mitigate this drift in error rates, we leverage transient information readily available in surface code quantum error correction to predict logical error rates (LER) in real time. We infer a prediction model by sampling physical error rates from real hardware, and mapping detector fire rate (DFR), or parity of stabilizer measurements across QEC rounds, to LER. This allows for on-the-fly LER predictions without the typical characterization overhead required to determine LER. This method can easily be extended to other stabilizer codes. Importantly, we observe that this prediction should be accurate yet conservative (i.e. give an upper estimate) to enable appropriately fast responses to real-time physical error changes. That is, responses should be executed marginally ahead of time to allow for their execution to complete, and minimize time spent (ideally none) above intolerable error rates. More importantly, we pair this predictor with a scheme which remaps drifted logical qubits to fresh tiles in a patch-based architecture while their original tiles are recalibrated. Our results demonstrate DFR-based prediction to be an effective LER predictor, and remapping as a spatially efficient and timely mitigation response for small code distances, both of which are significant steps in furthering practical QEC.
Concatenating quantum error correction codes scales error correction capability by driving logical error rates down double-exponentially across levels. However, the noise structure shifts under concatenation, making it hard to choose an optimal code sequence. We automate this choice by estimating the effective noise channel after each level and selecting the next code accordingly. In particular, we use learning-based methods to tailor small, non-additive encoders when the noise exhibits sufficient structure, then switch to standard codes once the noise is nearly uniform. In simulations, this level-wise adaptation achieves a target logical error rate with far fewer qubits than concatenating stabilizer codes alone--reducing qubit counts by up to two orders of magnitude for strongly structured noise. Therefore, this hybrid, learning-based strategy offers a promising tool for early fault-tolerant quantum computing.
Logical error rate is the standard benchmark for quantum error correction (QEC), but it is an aggregate quantity: it says nothing about which circuit components actually drive logical failure. Recent work introduced an error attribution scheme that computes per-component sensitivities ∂PL/∂pi\partial P_L/\partial p_i∂PL​/∂pi​ of the logical error rate jointly from the same Monte Carlo samples used to estimate PLP_LPL​, and showed that halving noise on the 5%–7% most sensitive components reduces logical error rates by roughly 15%–25%, about twice the improvement from randomly chosen components [1],[3]. This paper develops the quantitative structure underlying that result. We formalize the sensitivity map, derive the first-order intervention gain for targeted versus random noise-reduction budgets, and show analytically that the targeted-to-random advantage is ρ=r/(fr+1−f)\rho = r/(fr + 1 - f)ρ=r/(fr+1−f), where fff is the hotspot fraction and rrr the sensitivity contrast; for f=0.06f = 0.06f=0.06 and r=2.136r = 2.136r=2.136 this ratio is exactly 222, matching the reported factor. We further show that the reported 15%–25% reductions exceed the first-order prediction of about 6% by an amplification factor of approximately 3.153.153.15, which we attribute to nonlinear, multiplicative error propagation absent from independent-error models. We derive Monte Carlo sample-complexity requirements for the sensitivity estimator, situate attribution among channel-optimized, reinforcement-learning, and robustness-optimized QEC strategies, and identify failure modes: coherent noise, estimator variance at low PLP_LPL​, sensitivity redistribution, and non-stationary drift. ## 1. Introduction Quantum error correction protects quantum information by encoding logical qubits redundantly and decoding measured syndromes, and its performance is almost universally reported as a single number: the logical error rate PLP_LPL​, the probability that a logical operator flips during a memory experiment or computation cycle. This aggregate benchmark is necessary but i Full text and updates: papers.qnfo.org/papers/error-attribution-as-a-resource-allocation-principle-for-quantum-error-correctio/
Quantum error correction (QEC) is a prerequisite for fault-tolerant quantum computation, yet the overhead cost—the number of physical qubits required to encode and protect a single logical qubit—varies substantially across QEC code families. This paper presents a systematic simulation-based comparison of two paradigmatic QEC codes: the three-qubit bit-flip repetition code and the distance-3 surface code. The bit-flip code is simulated by literal Qiskit Aer circuit execution (encoding, injected depolarizing noise, and dynamic classical feed-forward correction). The distance-3 surface code is instead simulated with a custom, vectorized stabilizer-formalism engine, because its 17-qubit noisy circuit would be far more expensive to run shot-by-shot in Aer at the scale needed here. This engine implements the same Aaronson-Gottesman algorithm underlying Aer's stabilizer backend and is cross-validated against genuine Aer circuit execution at a representative operating point; no surface-code result in this paper comes from literal Aer execution. We apply an independent single-qubit depolarizing channel at physical error rates p ∈ [0.001, 0.30] and measure the resulting logical error rate P_L for each code across 200,000 independent trials per data point (95% Wilson confidence intervals reported throughout). We identify the pseudo-threshold p*—the physical error rate at which a code's logical error rate equals the uncorrected physical error rate, and compare simulated crossover points against closed-form analytical predictions. Our results reveal a more nuanced picture than the naive threshold-theorem intuition suggests. The three-qubit bit-flip code cannot correct phase-type errors under any circumstance: under a full quantum-state-protection criterion its logical error rate exceeds the physical error rate for every physically meaningful p, with the two curves crossing only at p ≈ 0.75 deep in the maximally-mixed regime and of no practical relevance. Under the narrower, but operationally standard, "bit-observable" criterion (protection of a definite computational-basis value only), the code is unconditionally beneficial (P_L < p) across the entire tested range, because the 2/3 fraction of depolarizing weight that manifests as a detectable bit-flip is compressed further by majority-vote correction. These two results are not contradictory: they evaluate different protection goals—preservation of a classical bit value versus preservation of an arbitrary quantum state—and every comparison in this paper that mixes the two is labeled accordingly. Under this study's idealized, single-round setup, the distance-3 surface code achieves a simulated finite-size pseudo-threshold of p*_SC ≈ 0.083 (8.3%)—a result specific to noiseless syndrome extraction, a single correction round, and an exact minimum weight decoder, and not a hardware representative or asymptotic threshold. That figure is roughly three orders of magnitude higher than an order-of-magnitude literature extrapolation of ≈ 5.6 × 10⁻⁵ (substituting the asymptotic literature threshold p_th ≈ 0.75% into a power law fit for a different, many-round, measurement noisy regime, not a dedicated prediction for our exact setup); the gap is attributable to precisely those idealizations. The surface code requires 17 physical qubits per logical qubit in our implementation (9 data + 8 ancilla) versus 3 for the bit-flip code, a ≈ 5.7× overhead, quantitatively illustrating the overhead-versus-protection tradeoff fundamental to near-term fault-tolerant architectures. All simulation code is available at https://github.com/shanjeev-b-u/qec-code-comparison-depolarizing-noise