The Resource Burden of Active Quantum Error Correction: A Scaling Analysis of Qubit, Bandwidth, and Energy Overheads

#1. Introduction

Quantum error correction is what transformed quantum information science from an academic curiosity into a viable engineering discipline [5]. The core idea—encoding logical information in a subspace of a larger Hilbert space such that the most probable errors move the state into an orthogonal, correctable subspace—is now standard material [4], [6]. Yet standard presentations concentrate on the existence of codes and the conditions under which they work. Far less attention is paid to what it costs to keep a code running: every logical operation is accompanied by a stream of syndrome measurements, feedback decisions, and physical gate operations whose aggregate resource demands can dominate the entire machine.

This paper addresses that gap with a deliberately simple question: given a target logical error rate, what must be spent—in qubits, in measurement bandwidth, in energy—to sustain active error correction? We answer it for the surface code, not because the surface code is optimal, but because its overheads are the most transparent and its parameters the most widely quoted, making it the natural baseline against which any alternative (continuous-time schemes [1], entanglement-assisted codes [2], adiabatic error handling [7]) should be measured.

Our contributions are:

1. Closed-form scaling laws for the qubit overhead, syndrome-bit rate, and energy per logical operation of a distance-$d$ surface code, with every constant stated explicitly (Section 3).
2. Fully worked numerical derivations for a family of target logical error rates, showing the cubic-in-$d$ growth of energy and the logarithmic scaling of $d$ itself (Section 4).
3. A comparative discussion placing these numbers against the Landauer limit, the thermal energy scale, the independent lower bound of [9], continuous-time QEC's different resource profile [1], and full-lifecycle accounting [12] (Sections 5 and 6).

We emphasize honesty about assumptions: every numerical result below is either derived with shown arithmetic from stated inputs or explicitly labeled a projection with stated assumptions. No experimental data are reported.

#2. Background and Related Work

The relevant literature spans foundational QEC theory, code-construction surveys, alternative QEC paradigms, and a small but growing body of resource-focused work.

Foundations of QEC. Gottesman [4] introduces the canonical machinery—encoding, syndrome extraction, error operators, and code construction—and shows that general noise on a set of two-state systems decomposes into Pauli operators, so that a code corrects a discrete subset of Pauli errors. This decomposition is precisely what makes the surface-code analysis of Section 3 possible: the effective logical error rate of a distance-$d$ code is controlled by the probability of uncorrectable Pauli error chains of length $\lfloor d/2 \rfloor + 1$. Terhal's survey [6] frames QEC as the design of a code subspace orthogonal to the dominant error subspaces and emphasizes that the most common errors—not all errors—determine performance, which justifies the threshold-scaling ansatz we adopt. Brun's survey [3] traces the lineage from classical error control to quantum codes and highlights the structural differences (no-cloning, continuous error amplitudes) that force active, measurement-based correction rather than passive redundancy; this is the historical root of the resource burden we quantify. Lidar and Brun's comprehensive treatment [5] places QEC in the broader context of protecting fragile superpositions against decoherence, including qudit and non-qubit encodings, and stresses that the discovery of QEC is what made scalable quantum computation conceivable; our accounting quantifies the cost of that conceivability.

Alternative QEC paradigms. The continuous-time QEC framework of [1] treats both noise and correction as processes continuous in time, based on continuous weak measurement and feedback viewed through the subsystem principle. This changes the temporal profile of the resource burden (continuous weak measurement instead of discrete syndrome rounds) but not its existence; we return to the comparison in Section 6. Lai et al. [2] present entanglement-assisted QEC codes, which use pre-shared entanglement between encoder and decoder to construct codes from pairs of classical codes that fail the self-orthogonality condition; entanglement assistance can reduce the qubit overhead per logical qubit but converts part of the burden into a demand for high-fidelity entanglement distribution—a resource substitution rather than a resource elimination. Brun et al. [7] analyze error suppression and correction in adiabatic quantum computation, where circuit-model correction routines do not transfer because high-quality gates are unavailable; their conclusion—that some form of error handling remains necessary—implies that some analogue of the active-correction burden exists in every paradigm, though its form differs. More speculatively, quaternionic extensions of QEC [8] define Pauli analogues and gates in quaternionic Hilbert spaces with inner-product-preserving encodings; such proposals remain far from resource quantification but illustrate the breadth of the code-design space within which overhead accounting must eventually operate.

Resource- and energy-focused work. Closest to our concerns, the QNFO analysis of energy cost per logical-qubit operation in surface-code QEC [9] derives a practical lower bound on energy cost accounting for gate-fidelity decay's impact on code distance and physical error rates; our Section 4 derivation is complementary in that it makes the overhead arithmetic fully explicit at a single operating point rather than bounding it, and we compare our assumed energy inputs against that bound. The hybrid quantum–classical feasibility analysis of coherence-assisted error correction for deep learning [10] approaches protection cost from the classical side, where bit-level fault protection under low-voltage or radiation-prone operation imposes analogous overheads—an instructive mirror showing that the protection-cost problem is not unique to quantum hardware. The QEC–Quantum Darwinism tradeoff result [11] establishes a no-go theorem: QEC and emergent classical objectivity cannot coexist above a critical logical fidelity $F_L \gt 0.874$; this bounds the regime in which active correction can be relaxed by letting the environment redundantly record information, and thereby blocks any passive-redundancy shortcut around the active burden. Finally, the lifecycle analysis of a fault-tolerant quantum computer [12] frames the full-system resource question across the machine's operating life—including construction, commissioning, and decommissioning—of which the per-operation costs derived here are one component.

#3. Methods

#3.1 Model

We consider a rotated surface code of distance $d$ ($d$ odd) encoding one logical qubit. Standard layout facts, used as inputs:

• Data qubits: $d^2$.
• Syndrome (ancilla) qubits: $d^2 - 1$.
• Total physical qubits per logical qubit:

One error-correction cycle of duration $\tau_c$ extracts all $d^2 - 1$ syndrome bits. We assume a logical operation (e.g., a lattice-surgery merge-and-split or a logical gate implemented by code deformation) requires $d$ consecutive cycles, the standard scaling for time-like error protection at distance $d$.

#3.2 Logical error rate ansatz

Below threshold, the logical error rate per logical operation follows the standard phenomenological scaling (consistent with the Pauli-error framing of [4] and the dominant-error-subspace framing of [6]):

where $p$ is the physical (circuit-level) error rate per operation, $p_{\mathrm{th}}$ the threshold, and $A$ a prefactor of order $10^{-1}$. We take $A = 0.1$ as a stated modeling choice; results shift only logarithmically in $d$ when $A$ changes (Section 4.8).

#3.3 Resource quantities

• Qubit overhead: $N_{\mathrm{phys}}(d)$ above.
• Syndrome bandwidth: bits per logical operation

and bits per cycle $d^2 - 1$, i.e., bits per second $R_{\mathrm{cyc}}(d) = (d^2-1)/\tau_c$ with $\tau_c = 1\ \mu\mathrm{s} = 10^{-6}$ s (stated assumption, typical of superconducting platforms).

• Energy per logical operation: with $\varepsilon_q$ the energy dissipated per physical qubit per cycle (stated assumption $\varepsilon_q = 10^{-9}$ J, i.e., 1 nJ, covering control pulses, measurement, and a share of cryogenics and classical processing),

The corresponding idle energy per cycle is $E_{\mathrm{cyc}}(d) = N_{\mathrm{phys}}(d)\,\varepsilon_q$; the ratio $E_L / E_{\mathrm{cyc}} = d$ is the storage-versus-computation split, and we report both.

• Area per logical qubit: with pitch $a = 100\ \mu\mathrm{m} = 10^{-4}$ m (stated assumption),

#3.4 Choosing $d$ for a target

Given a target $p_L \le P$, we require

rounded up to the nearest odd integer. Throughout we take $p = 10^{-3}$ and $p_{\mathrm{th}} = 10^{-2}$ (stated inputs), so $\log_{10}(p/p_{\mathrm{th}}) = \log_{10}(0.1) = -1$ and the condition simplifies to $d \ge -2\log_{10}(P/A) - 1$.

#4. Analysis

Every input number is stated here with its source: $A = 0.1$ (modeling choice, Section 3.2); $p = 10^{-3}$, $p_{\mathrm{th}} = 10^{-2}$ (stated inputs, Section 3.4); $\tau_c = 10^{-6}$ s, $\varepsilon_q = 10^{-9}$ J, $a = 10^{-4}$ m (stated assumptions, Section 3.3); $k_B = 1.380649 \times 10^{-23}$ J/K (CODATA exact SI value); $T = 0.3$ K (dilution-refrigerator base temperature) and $T = 1$ K (thermal comparison stage), both stated assumptions.

#4.1 Code distance for $P = 10^{-12}$

Since $21$ is odd, $d^* = 21$.

#4.2 Qubit overhead at $d = 21$

#4.3 Logical error rate check

#4.4 Syndrome bandwidth at $d = 21$

Per logical operation:

Per cycle:

#4.5 Energy per logical operation at $d = 21$

Idle energy per cycle:

#4.6 Comparison with fundamental energy scales

The Landauer bound at temperature $T$ is $E_{\mathrm{Land}} = k_B T \ln 2$ at $T = 0.3$ K:

Arithmetic: $1.380649 \times 0.3 = 0.4141947$; $0.4141947 \times 0.693147 = 0.2870979$; hence

Ratio:

(Arithmetic: $1.8501 / 2.87098 = 0.64451$, and $10^{-5}/10^{-24} = 10^{19}$, giving $0.64451 \times 10^{19} = 6.4451 \times 10^{18}$, rounded to $6.445 \times 10^{18}$.)

The thermal comparison per cycle at $T = 1$ K:

(Arithmetic: $8.81 / 1.380649 = 6.3817$, and $10^{-7}/10^{-23} = 10^{16}$.)

Comparison against the independent lower bound of [9], $E_{\mathrm{op}} \ge 1.2 \times 10^{-12}$ J per logical operation:

(Arithmetic: $1.8501/1.2 = 1.5418$, $10^{-5}/10^{-12} = 10^{7}$.) Our assumed-energy figure lies about seven orders of magnitude above that published lower bound, consistent with [9] being a lower bound under optimistic gate-fidelity assumptions.

#4.7 Area density at $d = 21$

#4.8 Scaling of energy with target fidelity

Since $d \approx -2\log_{10}(P/A) - 1$ and $E_L \propto d^3$, energy grows as the cube of the logarithm of the inverse target error rate. For $P = 10^{-3}$: $\log_{10}(P/A) = \log_{10}(10^{-2}) = -2$, so $d \ge 3$, $d^* = 3$:

Ratio of energies:

Note $21^3/3^3 = 9261/27 = 343$; the deviation from the pure $d^3$ law arises from the $-1$ term in $N_{\mathrm{phys}}(d) = 2d^2 - 1$.

#4.9 Intermediate points (same arithmetic)

• $P = 10^{-6}$: $\log_{10}(P/A) = -5$, $d \ge 9$, $d^* = 9$. $N_{\mathrm{phys}}(9) = 2 \times 81 - 1 = 161$. $E_L(9) = 161 \times 9 \times 10^{-9} = 1.449 \times 10^{-6}$ J. $B(9) = 9 \times 80 = 720$ bits. $E_{\mathrm{cyc}}(9) = 1.61 \times 10^{-7}$ J.
• $P = 10^{-9}$: $\log_{10}(P/A) = -8$, $d \ge 15$, $d^* = 15$. $N_{\mathrm{phys}}(15) = 2 \times 225 - 1 = 449$. $E_L(15) = 449 \times 15 \times 10^{-9} = 6.735 \times 10^{-6}$ J. $B(15) = 15 \times 224 = 3360$ bits.

#4.10 Sensitivity to the prefactor and the energy assumption

Because $E_L$ is linear in $\varepsilon_q$, scaling $\varepsilon_q$ by a factor $\alpha$ scales all energies by $\alpha$. If co-integrated millikelvin control achieved $\varepsilon_q = 10^{-12}$ J per qubit per cycle (a labeled projection, a speculative $10^3\times$ reduction), the same arithmetic gives $E_L(21) = 881 \times 21 \times 10^{-12} = 1.8501 \times 10^{-8}$ J. The prefactor $A$ enters only logarithmically in $d$: changing $A$ from $0.1$ to $1$ changes the requirement to $d \ge -2\log_{10}(10^{-12}) - 1 = 23$, i.e., $N_{\mathrm{phys}} = 2 \times 529 - 1 = 1057$, a $1.20\times$ increase in qubits ($1057/881 = 1.199$). The qubit and bandwidth results are therefore robust to order-of-magnitude uncertainty in $A$ but linearly exposed to $\varepsilon_q$.

#5. Results

All numbers below are computed in Section 4 from the stated inputs ($A = 0.1$, $p = 10^{-3}$, $p_{\mathrm{th}} = 10^{-2}$, $\tau_c = 10^{-6}$ s, $\varepsilon_q = 10^{-9}$ J, $a = 10^{-4}$ m, $T = 0.3$ K and $1$ K); none are measured or simulated.

Headline results at the $P = 10^{-12}$ operating point:

1. Qubit overhead: $881$ physical qubits per logical qubit.
2. Syndrome bandwidth: $9240$ bits per logical operation; $440$ bits per cycle, i.e., $4.40 \times 10^{8}$ bits s$^{-1}$ per logical qubit at $\tau_c = 1\ \mu$s.
3. Energy per logical operation: $1.8501 \times 10^{-5}$ J, which is $6.445 \times 10^{18}$ times the Landauer limit $2.87098 \times 10^{-24}$ J at 300 mK; the idle energy per cycle is $8.81 \times 10^{-7}$ J, or $6.38 \times 10^{16}$ times $k_B T$ at 1 K.
4. Areal density: $2.2676 \times 10^{5}$ logical qubits per m$^2$ at pitch $100\ \mu$m.
5. Scaling: energy per logical operation grows by a factor $362.8$ when the target error rate improves from $10^{-3}$ to $10^{-12}$—cubic in code distance, i.e., cubic in $\log(1/P)$.
6. Relation to prior bounds: the computed energy lies $1.54 \times 10^{7}$ times above the independent lower bound $1.2 \times 10^{-12}$ J of [9], consistent with that bound being optimistic.

Labeled projection (not computed above). If $\varepsilon_q$ were improved to $10^{-12}$ J per qubit per cycle (a speculative $10^3\times$ reduction requiring co-integrated control at millikelvin), the same arithmetic gives $E_L(21) = 1.8501 \times 10^{-8}$ J. The uncertainty in this projection is dominated entirely by the $\varepsilon_q$ assumption, which spans at least three orders of magnitude across proposed platforms; the qubit and bandwidth results, by contrast, depend only on the code layout and are robust.

#6. Discussion

What the numbers mean. The dominant message is that active QEC converts a hardware problem (physical error rate $p$) into a throughput and energy problem: the classical processing layer must sustain $\sim 4.4 \times 10^{8}$ syndrome bits per second per logical qubit, and the energy bill per logical operation is, under our assumptions, eighteen to nineteen orders of magnitude above the Landauer limit. This is consistent in spirit with the lower-bound analysis of [9], which also finds energy per logical operation to be the binding constraint once gate-fidelity decay forces larger code distances. It also echoes, on the quantum side, the protection-cost structure identified for classical deep-learning hardware in [10]: protection, not computation, dominates.

Comparison with alternative paradigms. Continuous-time QEC [1] replaces discrete syndrome rounds with continuous weak measurement and feedback. The bandwidth burden then becomes a continuous measurement-strength budget rather than a discrete bit rate; whether this is cheaper depends on the back-action cost of weak measurement, which our discrete model does not capture—an explicit open question. Entanglement-assisted codes [2] can reduce the number of physical data qubits per logical qubit but require pre-shared entanglement, substituting a distribution resource for a layout resource; our framework can accommodate this by replacing $N_{\mathrm{phys}}(d)$ with a modified overhead plus an entanglement-consumption term, which we have not modeled. Adiabatic error handling [7] avoids some gate-quality demands but still requires error suppression whose resource cost is not expressible in our cycle-based accounting; our numbers should therefore not be read as universal across computational paradigms. The QEC–Darwinism no-go result [11] warns that one cannot indefinitely offload protection onto environmental redundancy: above logical fidelity $F_L \gt 0.874$, the theorem asserts the two cannot coexist, so active correction cannot simply be "relaxed" at high fidelity. Quaternionic encodings [8] remain too immature for overhead quantification but broaden the design space that future accounting must cover.

Limitations and failure modes. (i) The ansatz $p_L(d) = A(p/p_{\mathrm{th}})^{(d+1)/2}$ with $A = 0.1$ is phenomenological; the true prefactor is code- and noise-model-dependent, and a different $A$ shifts $d^*$ by a constant offset in $\log_{10}$, changing $E_L$ by factors of order $(d'/d)^3$ (quantified in Section 4.10). (ii) The energy model $\varepsilon_q = 10^{-9}$ J per qubit per cycle is a coarse assumption; cryogenic and classical-processing shares may scale sub- or super-linearly in $N_{\mathrm{phys}}$, and a superlinear share would worsen the cubic law. (iii) We assume one logical operation costs $d$ cycles; algorithms with heavy lattice-surgery traffic could pay more. (iv) Correlated errors (cosmic rays, leakage) violate the independent-Pauli picture underlying [4] and can dominate at large $d$. (v) We treat only the surface code; qudit and oscillator encodings [5] may have different overhead exponents. (vi) We count only qubit-level dissipation; decoder compute energy and refrigerator Carnot overhead (removing 1 W at millikelvin costs kilowatts at room temperature) are excluded, so our figures are lower bounds in scope though uncertain in value.

What would falsify our claims. A demonstrated surface-code implementation achieving $p_L \sim 10^{-12}$ with $d$ substantially below 21 at $p = 10^{-3}$—or a per-qubit cycle energy far below $10^{-9}$ J at scale—would falsify the headline numbers. A rigorous proof that the prefactor $A$ is orders of magnitude smaller than $0.1$ for realistic circuit noise would soften the cubic penalty. Conversely, confirmation of the energy lower bound of [9] at a compatible operating point would strengthen the analysis; if the no-go bound of [11] holds, no passive-redundancy shortcut can evade the active burden.

Open questions. How does the optimal tradeoff shift under continuous-time correction [1]? Can entanglement assistance [2] or non-qubit encodings [5], [8] reduce the exponent on $d$? What is the measured (not assumed) per-qubit dissipation budget in a multi-thousand-qubit cryostat, and how does decoder energy scale with syndrome rate? Does the fidelity ceiling implied by [11] interact with the energy scaling to create a fundamental efficiency frontier for fault-tolerant computation, as the lifecycle framing of [12] suggests?

#7. Conclusion

We have presented a fully explicit scaling analysis of the resource burden of active quantum error correction, using the surface code as the worked baseline. With every input stated and every arithmetic step shown, we find that a target logical error rate of $10^{-12}$ at physical error rate $10^{-3}$ demands a distance-21 code: $881$ physical qubits, $9240$ syndrome bits per logical operation ($4.40 \times 10^{8}$ bits s$^{-1}$), and—under a stated $10^{-9}$ J per-qubit-per-cycle assumption—$1.8501 \times 10^{-5}$ J per logical operation, $6.445 \times 10^{18}$ times the Landauer limit at 300 mK. Energy grows as the cube of the code distance, hence as the cube of $\log(1/P)$: each additional three orders of magnitude in logical fidelity costs roughly a factor of $10^3$ in energy. The burden is logarithmically robust to model prefactors but linearly exposed to per-qubit energy, making that parameter the critical measurement target for the field. The central lesson is methodological: resource accounting for active QEC should be presented with the same explicitness as code constructions, and energy per logical operation and syndrome bandwidth should be reported alongside fidelity in any QEC architecture evaluation, because the burden—not the existence—of error correction is what will decide the architecture of fault-tolerant machines.

#References

[1] Continuous-time quantum error correction. arXiv:1311.2485v2. https://arxiv.org/abs/1311.2485v2 [2] Entanglement-Assisted Quantum Error-Correcting Codes. arXiv:1610.04013v1. https://arxiv.org/abs/1610.04013v1 [3] An Introduction to Error-Correcting Codes: From Classical to Quantum. arXiv:quant-ph/0602157v1. https://arxiv.org/abs/quant-ph/0602157v1 [4] Quantum Computing and Error Correction. arXiv:quant-ph/0304016v2. https://arxiv.org/abs/quant-ph/0304016v2 [5] Quantum error correction beyond qubits. arXiv:0811.3734v1. https://arxiv.org/abs/0811.3734v1 [6] Quantum Error Correction. arXiv:1910.03672v1. https://arxiv.org/abs/1910.03672v1 [7] Error suppression and error correction in adiabatic quantum computation I: techniques and challenges. arXiv:1307.5893v3. https://arxiv.org/abs/1307.5893v3 [8] Quantum Error Correction in Quaternionic Hilbert Spaces. arXiv:2504.19833v1. https://arxiv.org/abs/2504.19833v1 [9] DOI 10.5281/zenodo.22283869. QNFO: A Lower Bound on Energy Cost per Logical-Qubit Operation in Surface-Code Quantum Error Correction. [10] DOI 10.5281/zenodo.23116197. QNFO: Coherence-Assisted Error Correction for Deep Learning: A Reconciled Feasibility Analysis of a Hybrid Quantum-Classical Architecture. [11] DOI 10.5281/zenodo.21964674. QNFO: Archimedean Shadows: The QEC-Darwinism Tradeoff in Ultrametric Spaces. [12] DOI 10.5281/zenodo.18000790. QNFO: Lifecycle of a Fault-Tolerant Quantum Computer.