Decoding Resources and Backreaction

A decoding map can exist while its implementation misses the evaporation deadline or becomes part of the gravitating system it was meant to diagnose. This page combines a conjectural exponential decoding complexity with an optimistic quantum speed limit, then counts gate time, memory, control precision, collection loss, and energy cost. The calculation is a transparent resource stress test—not a lower bound for every black-hole algorithm—and it flags where the assumed weak-backreaction protocol contradicts itself.

Required background. Quantum Information for Black-Hole Physics supplies circuits, recovery, and error budgets; What the Equivalence Principles Do and Do Not Imply supplies physical clocks, energy, and gravitational disturbance.

Helpful background. Semiclassical Gravity supplies evaporation and backreaction; Quantum Fields in Curved Spacetime supplies radiation collection; and Black-Hole Information supplies the decoder target.

An optimistic gate capacity before evaporation

Consider a four-dimensional Schwarzschild reference model with mass $M$ and entropy

$$S_{\mathrm{BH}}=4\pi G M^2=n\log 2,$$

where $n$ is the entropy measured in bits. Write the remaining usable time as

$$t_{\mathrm{avail}}=\eta_t\gamma G^2M^3.$$

The reference coefficient is $\gamma=5120\pi$; actual species, greybody factors, spin, charge, and the point at which collection begins change it. The factor $\eta_t=0.5$ reserves half the nominal evaporation time for collection and other stages.

Place the idealized computer far from the hole, so its proper time and energy can be compared directly with the asymptotic clock and mass. Model its usable energy above its ground state as $E_{\mathrm{comp}}=fM$. The Margolus–Levitin orthogonalization bound permits at most an optimistic rate $2E_{\mathrm{comp}}/\pi$. The original result and its energy-above-ground assumption are stated in Margolus and Levitin 1998, Eqs. (4)–(6), pp. 190–191. The benchmark counts each gate as an orthogonal transition. That is an added operation model: small-angle quantum gates need not orthogonalize the state, so the theorem does not bound arbitrary gate counts in this way. Within the model, assuming saturation and omitting routing, communication, error correction, cooling, and geometry makes the estimate optimistic.

For a gate count $N_g$, the minimum mass fraction needed to finish is

$$f_{\mathrm{req}} =\frac{\pi N_g} {2\eta_t\gamma\left(S_{\mathrm{BH}}/(4\pi)\right)^2}.$$

All dimensions cancel. The test declares the apparatus nonperturbative when $f_{\mathrm{req}}\gt f_{\mathrm{cap}}=0.10$. Ten percent is an illustrative global backreaction cap, not a universal safe threshold; concentrating even less energy near the horizon can already be destructive.

Gate, memory, and precision hypotheses

The benchmark assumes

$$N_g=2^{\alpha n}, \qquad \alpha=0.02.$$

The small exponent keeps the finite table readable. Harlow and Hayden motivate an exponential obstruction for the radiation-distillation problem under explicit complexity assumptions, but do not prove this formula or its coefficient for every black-hole channel Harlow and Hayden 2013, §§ 2–4. The code therefore varies $\alpha$.

Collection efficiency is set to $\eta_c=0.5$, giving the bookkeeping proxy $n_{\mathrm{mem}}=\lceil n/\eta_c\rceil$. This is not an erasure-recovery theorem. For target channel error $\epsilon=10^{-3}$, a worst-case additive coherent-error budget requires per-gate error no larger than $\epsilon/N_g$, or about $b=\lceil\log_2(N_g/\epsilon)\rceil$ control bits. Fault-tolerant architecture can change this scaling while increasing gates and memory.

Reproduce the budget

Environment. CPython 3.11.9, standard-library-only, using only the Python standard library; no third-party dependency is imported. Arithmetic is IEEE-754 binary64. The algorithm evaluates the closed formulas, scans integer $n$ for the first energy-cap failure, and enforces a $10^{-12}$ relative budget- identity tolerance.

Save the Python fence exactly as decoder_budget.py. The program must write four system-size rows, nine coefficient-sensitivity rows, and the first threshold failure; it must exit nonzero if energy demand ceases to increase, the deadline residual fails to shrink, or the budget identity misses tolerance.

from math import ceil, log, log2, pi

GAMMA = 5120.0 * pi
ETA_TIME = 0.5
ETA_COLLECT = 0.5
ENERGY_CAP = 0.10
TARGET_ERROR = 1e-3
ALPHA = 0.02
SIZES = (256, 512, 1024, 2048)
TOL = 1e-12


def budget(n, alpha=ALPHA, gamma=GAMMA):
    entropy = n * log(2.0)
    gates = 2.0 ** (alpha * n)
    mass_time = gamma * (entropy / (4.0 * pi)) ** 2
    required_fraction = pi * gates / (2.0 * ETA_TIME * mass_time)
    deadline_ratio = required_fraction / ENERGY_CAP
    memory_qubits = ceil(n / ETA_COLLECT)
    precision_bits = ceil(log2(gates / TARGET_ERROR))
    residual = max(0.0, 1.0 - deadline_ratio)
    return (
        n,
        gates,
        memory_qubits,
        precision_bits,
        required_fraction,
        deadline_ratio,
        residual,
    )


def first_failure(alpha, gamma_factor=1.0):
    for n in range(32, 10001):
        if budget(n, alpha, GAMMA * gamma_factor)[4] > ENERGY_CAP:
            return n
    raise SystemExit("threshold lies above scan range")


rows = [budget(n) for n in SIZES]
print("n gates memory precision_bits energy_fraction deadline_ratio residual")
for row in rows:
    n, gates, memory, bits, fraction, ratio, residual = row
    print(
        f"{n:4d} {gates:.6e} {memory:6d} {bits:6d} "
        f"{fraction:.6e} {ratio:.6e} {residual:.6e}"
    )

print("alpha gamma_factor first_n_over_cap")
for alpha in (0.015, 0.020, 0.025):
    for gamma_factor in (0.5, 1.0, 2.0):
        print(
            f"{alpha:.3f} {gamma_factor:.1f} "
            f"{first_failure(alpha, gamma_factor):4d}"
        )

if any(new[4] <= old[4] for old, new in zip(rows, rows[1:])):
    raise SystemExit("system-size monotonicity check failed")
if rows[-1][6] >= rows[0][6]:
    raise SystemExit("deadline-residual refinement check failed")
for row in rows:
    reconstructed = row[5] * ENERGY_CAP
    if abs(reconstructed - row[4]) > TOL * max(1.0, row[4]):
        raise SystemExit("budget identity tolerance failed")

Run the exact saved program with:

python3 --version
python3 -m py_compile decoder_budget.py
python3 decoder_budget.py

System-size refinement

The comparison columns separate assumed circuit complexity, memory, precision, required global energy, deadline ratio, and the remaining deadline residual $\max(0,1-f_{\mathrm{req}}/f_{\mathrm{cap}})$. This residual is a resource margin, not an Einstein-equation residual.

System qubits $n$	Gate complexity	Memory qubits	Precision bits	Required energy fraction	Runtime/deadline ratio	Backreaction residual
256	3.477552e+01	512	16	3.406375e-05	3.406375e-04	9.996594e-01
512	1.209336e+03	1024	21	2.961461e-04	2.961461e-03	9.970385e-01
1024	1.462495e+06	2048	31	8.953508e-02	8.953508e-01	1.046492e-01
2048	2.138891e+12	4096	51	3.273615e+04	3.273615e+05	0.000000e+00

At $n=1024$ the optimistic computer nearly exhausts the ten-percent cap and the available half-lifetime. At $n=2048$ it would require more than $10^4$ times the black-hole mass. The benchmark sizes are not claimed to be semiclassical astrophysical black holes; they expose the crossover of an exact resource formula. An astrophysical entropy lies vastly farther into the exponential regime if the assumed positive $\alpha$ persists.

Coefficient sensitivity and threshold

The first integer $n$ for which $f_{\mathrm{req}}\gt0.10$ is:

Complexity exponent $\alpha$	Lifetime factor $\gamma/\gamma_0$	First failing qubits $n$
0.015	0.5	1365
0.015	1.0	1442
0.015	2.0	1519
0.020	0.5	975
0.020	1.0	1034
0.020	2.0	1092
0.025	0.5	750
0.025	1.0	797
0.025	2.0	844

Doubling the lifetime moves the threshold modestly, whereas changing the complexity exponent moves it substantially. This is the expected competition between a polynomial gate capacity proportional to $S_{\mathrm{BH}}^2$ and an assumed exponential gate count. Harlow’s Appendix E explains the circuit- counting background and its limits Harlow 2016, Appendix E, pp. 102–110 of the Open PDF.

Physical interpretation and failure modes

Algorithmic sensitivity. The gate ansatz is conjectural. Structure, an oracle, a restricted code subspace, approximation, or a different decoder can change $N_g$. Conversely, routing and fault tolerance can make the cost larger.

Causal and collection failure. The available time begins only after enough radiation has arrived. Efficiency below one can erase required correlations, not merely double memory. A decoder that finishes after the evaporation time does not test the original interior experiment.

Backreaction and localization. The global fraction $f$ understates local stress-energy. Apparatus, quantum memory, cooling exhaust, and control fields near the hole can shift its mass, horizon, or emission before decoding ends. Once the required fraction exceeds the cap, the fixed-background calculation has failed rather than predicted a feasible measurement.

Precision accumulation. The additive coherent-error rule is conservative and architecture dependent. Rare faults, calibration drift, radiation loss, and exponentially small target amplitudes can demand more precision than the simple bit count.

Speed-limit interpretation. The Margolus–Levitin bound constrains orthogonalization, not arbitrary elementary circuit gates. The displayed capacity is conditional on identifying counted operations with such transitions, and saturation does not construct an algorithm. Energy cannot automatically be parallelized into a decoder, and gravity further constrains storage density. A different gate implementation needs a fresh dynamical speed bound.

The resource calculation therefore supports a conditional statement: under the named gate hypothesis and access model, the protocol becomes self-inconsistent beyond a coefficient-dependent threshold. It is not a quantum complexity lower bound or proof that information is unrecoverable.

Exercises

In the baseline row, failure first occurs at $n=1034$. Doubling the lifetime coefficient moves it to $n=1092$. Why is the gain only 58 qubits, and what does that say about attempts to rescue an exponential decoder with a polynomially longer deadline?

Solution

The required fraction is proportional to $2^{\alpha n}/(\gamma n^2)$. Doubling $\gamma$ buys only one factor of two, which an exponential restores after roughly $1/\alpha=50$ added qubits, with the changing $n^2$ factor accounting for the remaining shift. Any fixed polynomial extension of the deadline is eventually overtaken by a positive exponential exponent. This conclusion is conditional on the gate ansatz; a subexponential algorithm would require a new budget rather than this extrapolation.

References

• Harlow, Daniel, and Patrick Hayden. 2013. “Quantum Computation versus Firewalls.” Journal of High Energy Physics 06, 085. arXiv:1301.4504.
• Harlow, Daniel. 2016. “Jerusalem Lectures on Black Holes and Quantum Information.” Reviews of Modern Physics 88, 015002. DOI. arXiv:1409.1231.
• Margolus, Norman, and Lev B. Levitin. 1998. “The Maximum Speed of Dynamical Evolution.” Physica D 120, 188–195. DOI.