Manuscript En02-E@2 · En02-E-v2.tex · c2769986
En02-E From Schwarzschild Radiation to Finite Recovery Channels Selected packet states, controlled truncation, and nonvacuum-calibrated memory benchmarks
Constructs the finite selected-packet state of a stationary Schwarzschild free scalar and a flagged occupation cutoff, then calibrates one declared Clifford recovery benchmark by the nonvacuum probability. The finite-packet restriction identifies a unique normal zero-mean gauge-invariant Gaussian state from the full packet covariance, with quasifreeness as an input. Number covariance alone does not determine a non-Gaussian state. The thermal normal-mode law and the occupation generating function are proved for that finite state. The flagged cutoff is deterministic and completely positive and trace preserving, and for this state the trace-distance error equals the discarded probability. Reference-compatible bounds, covariance continuity, and occupation-dependent scattering errors are proved separately. The ancillary interface controls an encoded channel only when the approximating state is independent of the message. The benchmark transfers only a(K), one minus the reciprocal determinant of I plus K. The unrestricted error is three quarters times one minus a, and the even-family atomic optimum is three quarters minus a over four. That parameter is not En02-D's transmission probability, and the decoder does not access the full covariance. The stationary boundary covariance is an analytical input taken from the supplied Em03-A model. Bulk Unruh existence and the Hadamard property remain an external theorem. Em03-A's packet mean is not this density operator. En02-D's energy-sector isometry does not select this state. Em02-D's inverse-cubic coefficient is not this covariance. Em02-E's relational lapse is not this state. The implementation appendix is not reported as executed and is package evidence, not a certificate. This is not a collapse theorem, not backreaction, not a Page curve, not an island, not a microscopic Hawking information-release mechanism, and not quantum-gravitational evaporation. En02-E's calibrated benchmark is not the series Route B. It does not close O.1, discharge the XVI-N insertion, or admit the XIV-XV characteristic coefficient. XVI-P is registered and is not a premise. H2, I3, and J2 remain unresolved. XV-B is not opened. No quantum coefficient is admitted. No compilation is asserted.
Front matter
abstractAbstractFront matter · lines 134–164
Open as its own pageWe construct a controlled finite representation of selected radiation modes in a specified stationary Schwarzschild free-field model. A finite orthonormal packet family has a normal, zero-mean, gauge-invariant Gaussian state determined by its full packet covariance. We retain complex off-diagonal correlations, derive its thermal normal-mode representation and occupation generating function, and construct a deterministic flagged total-occupation cutoff. For this state, the cutoff trace-distance error is exactly the discarded probability.
We prove covariance-to-state continuity, reference-compatible cutoff bounds for general inputs, bandwidth-dependent energy estimates, and occupation-dependent scattering-channel bounds that retain complex amplitudes. A common ancillary interface supplies a precise condition under which a state approximation controls an encoded channel. Separately, a declared Clifford message channel is calibrated by the selected state's nonvacuum probability. Its unrestricted and atomic-delivery memory-limited recovery errors are evaluated exactly. This benchmark transfers one field statistic; its decoder does not access the selected field state's full correlations.
The implementation appendix specifies phase-sensitive covariance regressions, complete decoder extensions, basis dictionaries, event-wise resource ledgers, radial boundary bounds, and failure-preserving SDP residual checks. It is not reported as executed. The analytical results concern selected stationary radiation states and explicitly declared finite channels, not collapse, backreaction, complete evaporation, or a microscopic Hawking information-release mechanism.
Scope, dependencies, and evidence
sectionScope, dependencies, and evidenceScope, dependencies, and evidence · lines 170–254
Open as its own pageThe construction separates the following objects:
\begin{gathered} \text{specified field state} \longrightarrow \text{selected packet state} \longrightarrow \text{finite flagged representation},\\ \text{declared encoding interface} \longrightarrow \text{message channel} \longrightarrow \text{complete recovery protocol}. \end{gathered} A field state does not determine the second line. Connections between the lines are proved only for explicitly stated interfaces. \paragraph{Route A.} We construct and approximate the full selected radiation state, including multiparticle occupation and packet correlations. \paragraph{Route B.} We transfer its vacuum/nonvacuum probability to an independently specified logical benchmark. This is a nonvacuum-calibrated recovery model, not a derived microscopic evaporation channel. The stationary field formulation is the one specified in the supplied Em03-A manuscript \cite{Em03A}, with the external Unruh-state construction retained \cite{DMP}. The operational benchmark is a specialization of the supplied En02-D model \cite{En02D}; its needed claims are proved here. \begin{center} \renewcommand{\arraystretch}{1.13} \begin{tabular}{@{}p{0.26\textwidth}p{0.27\textwidth}p{0.38\textwidth}@{}} \toprule Ingredient & Dependency & Status in this paper\\ \midrule Stationary boundary covariance & Em03-A; standard Hawking model & Explicitly stated analytical input\\ Bulk state identification & Dappiaggi--Moretti--Pinamonti & External construction and Hadamard theorem\\ Radial scattering & Specified Schwarzschild ODE & Flux-normalized construction; approximation bounds\\ Selected density operator & Quasifree field restriction & Proved finite-mode representation\\ Occupation cutoff & This paper & Deterministic CPTP map and explicit errors\\ Message encoding and core & Operational specification & Additional model inputs\\ Recovery performance & Specified channel and interface & Analytical optima; numerical checks unexecuted\\ \bottomrule \end{tabular} \end{center} \paragraph{Evidence status.} No Python, solver, or pdfLaTeX execution is asserted. The numerical appendix is an implementation specification, not a results section. Analytical examples are explicitly identified. An executed incorporation study requires actual archived runs and inspection of their numerical and compilation records. We use \(c=\hbar=k_B=1\), \(G>0\), and base-two entropy. For states and channels, \[ d_{\mathrm{tr}}(\rho,\sigma)=\frac12\left\lVert \rho-\sigma\right\rVert_1,\qquad d_\diamond(\Phi,\Psi)=\frac12\left\lVert \Phi-\Psi\right\rVert_\diamond.Channel comparisons include arbitrary references. Matrix denotes operator norm and denotes Frobenius norm.
Specified stationary radiation model
sectionSpecified stationary radiation modelSpecified stationary radiation model · En02-E@2#eq:radial · lines 256–291
Open as its own pageFix , , and one real angular harmonic of degree . The exterior metric and tortoise coordinate are
The Killing field is normalized at infinity. For the massless minimally coupled scalar, the radial equation is
Surface gravity and inverse horizon temperature are
The state is the quasifree product prescription with the affine vacuum on the complete past horizon and the Killing-frequency vacuum on past null infinity. On the exterior half-horizon,
The bulk-to-boundary construction and the Hadamard property on the stated Schwarzschild domain are external inputs DMP. They are not a finite-core construction.
sectionNormalization and outgoing covarianceSpecified stationary radiation model › Normalization and outgoing covariance · En02-E@2#eq:outcov · lines 292–356
Open as its own pageThe current convention is
The affine vacuum current covariance pulls back to
These are the stationary boundary identities imported from Em03-A. The positive- and negative-frequency current coefficients are and , respectively; Fourier transformation contributes . Hence
In particular, a normalized packet covariance has no extra factor.
Let be the unitary, flux-normalized two-channel scattering matrix of (eq:radial). Write its horizon-to-infinity transmission amplitude as , and put . For , . The outgoing annihilator is
The incoming channels are independent and have zero means. Their number covariances give
Quasifreeness is part of the input. Number covariance alone would not determine a general non-Gaussian state.
The associated time–frequency mode-window convention is
It is distinct from a normalized packet occupation and from a specified detector instrument.
Hawking's fixed-background calculation motivates this model Hawking. A collapse scaling-limit analysis FredenhagenHaag, renormalized backreaction HollandsWald, and a dynamical mass-loss model are separate programmes.
The complete finite packet state
sectionThe complete finite packet stateThe complete finite packet state · En02-E@2#eq:K · lines 358–385
Open as its own pageFix and an orthonormal family . Define
Bounded covariance on extends the smooth-test formulas to these packets.
We distinguish
Thus . We use as the ordinary one-particle operator matrix. Put
theoremTheorem: Finite-packet restrictionThe complete finite packet state · En02-E@2#thm:gaussian, En02-E@2#eq:thermalmodes, En02-E@2#eq:density · proof attached · lines 386–443
Open as its own pageThe selected packet algebra has a unique normal, zero-mean, gauge-invariant Gaussian state on . Its number covariance is and its anomalous covariance vanishes.
If and , then
where . Equivalently,
where is bosonic second quantization. The state commutes with , but need not factor in the declared packet basis.
Proof. The restricted quasifree characteristic function is
The transpose in (eq:K) follows directly by expanding the second moment.
For ,
A geometric oscillator density with parameter has the required Gaussian characteristic function and mean . Its trace is one, including the vacuum case . The product and passive rotation therefore yield the restricted characteristic function. Uniqueness of finite-mode Weyl characteristic functions identifies the state.
In the eigenbasis, has eigenvalues , and trace . This proves (eq:density). Passive transformations preserve total number.
sectionThe complete finite packet stateThe complete finite packet state · lines 443–447
Open as its own pageThese formulas are finite-mode Gaussian normal-mode methods Weedbrook,Caruso, with conventions fixed by the proof.
corollaryCorollary: Statistics and generating-function domainThe complete finite packet state · En02-E@2#cor:stats, En02-E@2#eq:pgf · proof attached · lines 448–479
Open as its own pageThe vacuum probability, total-number moments, and entropy are
where , .
If , then the absolutely convergent probability-generating function is
Here may be complex and . If , for every . Positivity of rational denominators alone is not a convergence criterion for negative .
Proof. For each nonvacuum normal mode the geometric series converges absolutely precisely when . Multiplying finitely many such series gives (eq:pgf). Their elementary moments and entropy give the remaining formulas.
theoremTheorem: Gaussian continuityThe complete finite packet state › Covariance-to-state continuity · En02-E@2#thm:continuity · proof attached · lines 483–527
Open as its own pageFor positive semidefinite ,
If , , then also
Proof. Let be a standard circular complex Gaussian vector. The coherent-state mixtures with amplitudes and have the characteristic functions of and ; degenerate Gaussian measures cover singular matrices. Since
convexity and Cauchy–Schwarz give the Frobenius bound.
Set . Operator monotonicity of the square root gives
and the reverse inequality follows by interchanging . Thus .
For strictly positive matrices, solves , and
The integral's Frobenius norm is bounded by .
sectionCovariance-to-state continuityThe complete finite packet state › Covariance-to-state continuity · lines 527–536
Open as its own pageReplacing by therefore requires an error budget:
Disjoint frequency supports make diagonal. Temporal translations of overlapping packets generally do not.
sectionExact selection versus continuum approximationThe complete finite packet state › Exact selection versus continuum approximation · En02-E@2#eq:subspace · lines 537–554
Open as its own pageLet , with projector . Theorem thm:gaussian is an exact restriction, not a state approximation to all outgoing modes.
For a normalized target , set . With multiplication by , expansion into selected and unselected parts gives
This controls the named occupation observable, not a global continuum-state distance.
Deterministic flagged Fock approximation
sectionDeterministic flagged Fock approximationDeterministic flagged Fock approximation · lines 556–571
Open as its own pageFor integer , let
The finite physical representation is
theoremTheorem: Flagged cutoff and exact Gaussian errorDeterministic flagged Fock approximation · En02-E@2#thm:cutoff · proof attached · lines 572–602
Open as its own pageThe map
is deterministic and CPTP. Put
In the common space ,
The retained block is unnormalized; the failure flag carries its actual probability.
Proof. The low-block Kraus map is followed by inclusion. For a high-block orthonormal basis , add Kraus maps . Their effects sum strongly to .
The number of occupation vectors with total at most is . Since , no low–high coherence remains. The difference of the two states is a positive high block of trace minus an orthogonal flag block of the same trace.
sectionTails and discarded momentsDeterministic flagged Fock approximation › Tails and discarded moments · lines 604–615
Open as its own pageWrite , reserving for the cutoff tail. Then
propositionProposition: Tail estimatesDeterministic flagged Fock approximation › Tails and discarded moments · En02-E@2#prop:tails · proof attached · lines 616–649
Open as its own pageFor every ,
For ,
The discarded mean occupation
satisfies
on the same positive -domain. All these tails vanish for .
Proof. Use Markov's inequality, then . For the first moment, use on the tail and . The derivative bound follows from the differentiated convergent generating series.
sectionPhase-sensitive finite-state formulasDeterministic flagged Fock approximation › Phase-sensitive finite-state formulas · En02-E@2#eq:permanent · lines 651–667
Open as its own pageLet . In the normalized occupation basis,
The repeated-row and repeated-column matrix contains row exactly times and column exactly times. The empty permanent is one.
lemmaLemma: Orientation-sensitive blocks and momentsDeterministic flagged Fock approximation › Phase-sensitive finite-state formulas · En02-E@2#lem:orientation, En02-E@2#eq:truncatedmoments · proof attached · lines 668–703
Open as its own pageFor the one-particle block,
Extend compressed annihilators by zero on the flag: . If
then the truncated number covariance is
It need not equal ; the discarded moments are absent.
Proof. Equation (eq:permanent) is the matrix element of the symmetric tensor power in (eq:density); symmetrization sums over permutations and occupation normalization supplies the factorials. Its one-particle specialization is immediate.
The cutoff is invariant under passive mode rotation. In the normal-mode basis the retained, unnormalized state is diagonal, and its mean in mode is . Rotating its one-particle matrix back and applying (eq:K) proves (eq:truncatedmoments).
sectionPhase-sensitive finite-state formulasDeterministic flagged Fock approximation › Phase-sensitive finite-state formulas · lines 703–708
Open as its own pageThese formulas permit regressions that distinguish from , unlike eigenvalues, vacuum probability, or total-number tails.
propositionProposition: Reference-compatible cutoffDeterministic flagged Fock approximation › General referenced inputs · En02-E@2#prop:generalcut · proof attached · lines 711–735
Open as its own pageFor any state , with arbitrary reference , put . Then
If , then . Without an input constraint, the cutoff's half-diamond distance from the identity embedding is one for every finite .
Proof. Purify to and set . The trace norm of is . Partial trace contracts it. The additional flag block has trace norm . Markov's inequality gives the constraint estimate. A high-block input is sent to an orthogonal flag and attains distance one.
sectionGeneral referenced inputsDeterministic flagged Fock approximation › General referenced inputs · lines 735–740
Open as its own pageThis explicitly realizes an occupation-constrained approximation; energy-constrained channel topologies are discussed in Shirokov.
sectionCombining errors and binary embeddingDeterministic flagged Fock approximation › Combining errors and binary embedding · En02-E@2#eq:combined · lines 741–769
Open as its own pageFor a positive approximation , define . In the common embedding,
Entrywise errors at most imply . A numerical convergence difference is not automatically a justified entrywise error bound.
Choose an ordered occupation basis, append the flag, and map these states to the first computational basis states of qubits. Unused binary states have zero prepared weight. A reverse representation map pinches valid versus invalid binary subspaces and sends invalid weight to the flag; it is CPTP by the same Kraus construction as the cutoff. Its action on valid encoded states is exact.
The representation does not realize bosonic CCR exactly in finite dimension. For bounded embedded observables the expectation error is at most ; number and energy require the separate moment estimates.
Scattering, energy, and observer interfaces
sectionBarrier conventionScattering, energy, and observer interfaces › Barrier convention · lines 774–786
Open as its own pageEither start with the horizon state and apply its scattering map, or start with outgoing covariance . Route A uses the latter and does not apply the greybody barrier twice.
An additional detector amplitude , with an independent vacuum loss environment, would give . This is separately labelled detector loss. Beamsplitter vacuum dilations are appropriate under those input assumptions Weedbrook,Caruso.
theoremTheorem: Finite communication representationScattering, energy, and observer interfaces › Exact finite scattering for declared incoming preparations · En02-E@2#thm:finitescatter · proof attached · lines 789–811
Open as its own pageLet have dimension . Prepare arbitrary inputs in in the two incoming channels, with orthogonal incoming modes in vacuum. The restriction of multiplication by is an isometry into , where each output space is spanned by the relevant output components of the incoming packet functions and has dimension at most .
On total input occupation at most , its bosonic lift is an exact finite isometry into at most output modes with total occupation at most . Tracing one output gives a finite CPTP communication channel.
Proof. Restriction of a unitary one-particle operator is isometric. Its output components lie in the specified spans. On the -particle sector, the symmetric tensor power is isometric and preserves total number. Take the direct sum for , then partial trace.
sectionExact finite scattering for declared incoming preparationsScattering, energy, and observer interfaces › Exact finite scattering for declared incoming preparations · lines 811–816
Open as its own pageThis is a communication problem after a declared preparation. It does not replace unselected horizon modes by vacuum in the stationary Unruh-state calculation.
theoremTheorem: Amplitude-to-channel boundScattering, energy, and observer interfaces › Exact finite scattering for declared incoming preparations · En02-E@2#thm:scattererror · proof attached · lines 817–844
Open as its own pageFor unitary two-channel multiplication matrices on , suppose
Their cutoff lifted isometries satisfy
and their complete channels, before or after the same partial trace, satisfy
Proof. Telescope the -fold tensor-power difference. Every factor is an isometry, giving . Symmetric restriction and direct sum preserve the bound. For referenced pure inputs, trace distance of the two isometric outputs is at most their vector-norm difference. Purification, convexity, and partial-trace contraction finish.
sectionExact finite scattering for declared incoming preparationsScattering, energy, and observer interfaces › Exact finite scattering for declared incoming preparations · lines 844–873
Open as its own pageFor mean occupation at most , using a common cutoff and common flag extension gives the additional bound
It is not inferred from matching mean counts.
Frequency-dependent amplitudes generally leave the selected packet span:
A piecewise-constant unitary on subbands preserves the packet span when each packet belongs to one subband. Its discrepancy must include phases and be bounded as above.
For covariance only, contraction-valued amplitudes with imply
This does not control coherent scattering phases.
sectionCompressed energyScattering, energy, and observer interfaces › Compressed energy · lines 874–882
Open as its own pageLet be multiplication by , and let
The selected span need not be invariant under .
propositionProposition: Energy and bandwidth errorsScattering, energy, and observer interfaces › Compressed energy · En02-E@2#prop:energy · proof attached · lines 883–909
Open as its own pageCompression of field energy to states with particles only in is , with selected Gaussian expectation .
Suppose packets lie in pairwise disjoint subbands whose halfwidths are at most . Several packets may belong to the same subband. Let assign its midpoint to each such packet. Then
Assigning the flag zero energy omits selected energy between zero and .
Proof. On each -particle sector, energy is the sum of one-particle operators; compression gives . Using gives . Multiplication by frequency minus the subband midpoint has norm at most ; compression and the -fold sum give the first two estimates. Finally , and both commute with the cutoff projector.
sectionCompressed energyScattering, energy, and observer interfaces › Compressed energy · lines 909–929
Open as its own pageThe compressed observable is not the energy of all radiation. It need not commute with the selected state. A surrogate's exact energy conservation is not exact conservation of the continuum field energy.
On the full band,
the cutoff Fock evolution error is at most .
Route A represents the entire flagged finite state as one raw block. Frequency orthogonality does not establish sharply localized arrivals. Any demultiplexing or streaming implementation needs its own delivery convention and resource ledger.
State-to-channel transfer under a common interface
theoremTheorem: Independent ancillary interfaceState-to-channel transfer under a common interface · En02-E@2#thm:ancilla · proof attached · lines 933–952
Open as its own pageLet be ancillary states in a common space, independent of the message and its reference. For a fixed CPTP map , define and similarly . Then
The bound also holds after any common deterministic decoder.
Proof. For a referenced message state , the input difference is , with trace norm . Apply CPTP contraction and take the supremum over references.
sectionState-to-channel transfer under a common interfaceState-to-channel transfer under a common interface · lines 952–959
Open as its own pageThus (eq:combined) supplies a complete-channel bound when this interface is supplied. It does not identify the encoding from radiation covariance or justify changing a purification, message correlation, or internal dynamics without a new comparison.
Nonvacuum-calibrated recovery benchmark
sectionWhat is transferredNonvacuum-calibrated recovery benchmark › What is transferred · lines 964–986
Open as its own pageDefine
This is the selected nonvacuum probability, not a rate or a mean. It is preserved exactly by the flagged cutoff when the flag is classified as nonvacuum. A binary vacuum measurement gives
Also
because .
Only is transferred to the benchmark. Different correlated Gaussian states may give the same parameter. The benchmark decoder is not given their covariance or full finite state.
sectionDeclared encoder and dilationNonvacuum-calibrated recovery benchmark › Declared encoder and dilation · En02-E@2#eq:Nbench · lines 987–1031
Open as its own pageThe message is a qubit. On five qubits, define
Gate products act rightmost first.
A physical operational packet has basis , represented by . Its atomic raw width is two qubits. The unused binary state is assigned an invalid-input failure treatment.
At horizon three,
A coherent dilation retains a branch label in the core, with amplitudes , and extracts encoded factors on the occupied branch. Tracing the labelled core gives (eq:Nbench). This is a declared operational purification, not the physical purifier of the selected Unruh state.
A surrogate occupied-rail energy and source energy give core energies after occupied extractions. This finite conservation law is not identified with the Schwarzschild mass.
assumptionAssumption: Single-pass atomic deliveryNonvacuum-calibrated recovery benchmark › Atomic resource model · En02-E@2#ass:atomic · lines 1034–1045
Open as its own pageThree raw width-two packets arrive once, in order. A supplier may buffer, but may not measure, demultiplex, select, or decode them. Every arrival occupies its full width atomically.
All laboratory quantum data, work, records, and output count toward . Classical storage is unrestricted. There is no uncounted storage, auxiliary shared entanglement, return of intermediate quantum data, or quantum export before all horizon packets have been consumed.
sectionAtomic resource modelNonvacuum-calibrated recovery benchmark › Atomic resource model · lines 1045–1051
Open as its own pageLet optimize over all CPTP decoders. Let optimize over deterministic protocols obeying Assumption ass:atomic with . Protocol memory is a global execution constraint Bisio.
lemmaLemma: Bell and Pauli witnessesNonvacuum-calibrated recovery benchmark › Atomic resource model · En02-E@2#lem:bell · proof attached · lines 1052–1070
Open as its own pageA decoded constant qubit channel has Bell-input overlap . A separable reference–output state has Bell overlap at most . For a Pauli channel ,
Proof. A constant channel gives , whose overlap with a maximally entangled qubit state is . A product pure state has overlap at most ; convexity gives the separable bound. For Pauli channels the Bell errors are orthogonal, giving the lower bound , while the channel triangle inequality gives the same upper bound.
theoremTheorem: Exact calibrated recovery and memory optimaNonvacuum-calibrated recovery benchmark › Atomic resource model · En02-E@2#thm:recovery · proof attached · lines 1072–1143
Open as its own pageFor , both parities satisfy
For even ,
For odd , .
Proof. Conjugation gives
Hence . Every proper even subset is constant. Applying to the full triple and discarding factors recovers the message.
The occupied Bell overlap cannot exceed one and the vacuum-branch overlap is . Lemma lem:bell therefore gives the unrestricted lower bound . Recover on the occupied branch and prepare on vacuum to attain it.
At capacity two, no quantum slot remains from the first packet at the second atomic arrival. An arbitrary first-packet instrument therefore leaves only a classical outcome. On the occupied rail, its effect is , . The normalized conditional reference–future state is
where , , , . It equals
The reference factors are positive and the joint projectors are rank one, so the state is separable across . This also covers arbitrary first-packet label mixing: the input branch blocks are already incoherent and orthogonal. Later operations preserve separability. The Bell overlap is at most , giving .
Measuring and preparing the logical eigenstate of their negative parity realizes
which attains the bound. The explicit decoders below attain unrestricted recovery at the remaining capacities.
sectionComplete protocols, including off-support inputsNonvacuum-calibrated recovery benchmark › Complete protocols, including off-support inputs · lines 1145–1213
Open as its own pageSet
three-slot protocol. Read and consume labels. Retain the first occupied rail through the second arrival. If both early labels are occupied, apply , read both rails as , and consume them. If all three labels are occupied, apply to rail three and return it after the final arrival. Otherwise consume all remaining data and prepare .
two-slot protocol. The identity allows separate early readouts. Consume each early rail before the next arrival. On the all-occupied history apply the same final correction; otherwise prepare after consuming all packets.
two-slot protocol. Read on the occupied rails, retaining only classical outcomes. On the all-occupied history prepare the logical eigenstate of negative parity; otherwise prepare .
The identities
verify the successful corrected channel. Equivalently, substituting the three logical Pauli representatives into the four early-readout Kraus maps gives the logical Pauli operators at the corrected output. The early pair is , so all four outcomes have probability . The complete decoded channels are and , respectively.
To extend each protocol to every physical packet input, mixed vacuum/occupied histories are failures. Invalid binary packet states are also failures. All such histories are consumed before fixed-output preparation. Cross-history coherence is removed by the complete label-readout instrument.
accounting. Single-qubit gates, CNOT, CZ, allocation, destructive computational readout, classical control, and final return are admitted. Preparing uses one recyclable slot: allocate zero, apply , destructively read a random bit, retain it classically, reallocate zero, conditionally apply , and return. Preparation of an eigenstate uses zero allocation, conditional , and . These events are included in the ledger; a final direct return is not recorded as a destructive measurement.
The even reference state is locally Clifford-equivalent to Smolin's unlockable state Smolin. Indeed, for , conjugation by maps it to . The unlocking mechanism is inherited.
sectionWhat the calibration error controlsNonvacuum-calibrated recovery benchmark › What the calibration error controls · lines 1214–1226
Open as its own pageSince (eq:Nbench) is affine in ,
This is a channel bound for a fixed specified calibration interface. It is not a general conversion of count error into diamond error. The flagged cutoff adds no error to this particular binary statistic.
Analytical controls and numerical acceptance
sectionA selected two-packet familyAnalytical controls and numerical acceptance › A selected two-packet family · lines 1231–1249
Open as its own pageOn , choose
zero outside . They are orthonormal and
The covariance is evaluated without deleting off-diagonal entries. Midpoint energy has compressed error , bounded by . These packets are not sharp arrival events.
exampleExample: Exact phase-sensitive algebraic controlAnalytical controls and numerical acceptance › A selected two-packet family · En02-E@2#ex:control · lines 1250–1287
Open as its own pageFor the synthetic, non-Schwarzschild covariance
the eigenvalues are ,
In the explicit order , the one-particle density block is
For cutoff , its number-moment matrix is the transpose:
These entries distinguish from .
The cutoff dimension including the flag is four, and
The calibrated recovery errors are
These are analytical values, not executed pilot results.
sectionPilot and archive specificationAnalytical controls and numerical acceptance › Pilot and archive specification · lines 1289–1312
Open as its own pageThe first radial pilot uses , , , , the two packets above, and cutoff . It constructs the full finite state and links it to the nonvacuum-calibrated benchmark by a parameter identifier.
The appendix separates synthetic tests from the radial pilot. It records complex amplitudes; flux residuals; separate boundary, quadrature, and ODE-tolerance comparisons; covariance and energy; finite Fock matrices and basis dictionaries; complete decoder matrices; resource histories; and optional SDP variables.
The analytical potential-tail bound is actually evaluated and archived for each radial boundary choice. Its floating-point evaluation is labelled as such. It excludes unverified integration error, and a vacuous bound remains recorded as vacuous.
BlackHawk may provide a version-pinned spectral comparison BlackHawk, while low-frequency scalar results Higuchi provide checks under their own hypotheses. Neither supplies the complex amplitude error needed here. No such comparison or numerical run is asserted.
sectionSDP acceptance is not a status stringAnalytical controls and numerical acceptance › SDP acceptance is not a status string · lines 1313–1346
Open as its own pageThe SDP formulations are given in Appendix app:sdp. Every requested solve first archives raw variables, constraint duals, settings, and solver statistics, before residual checks or another solve. Failure therefore preserves any obtained decoder.
For complex PSD constraints, the implementation uses realification:
It separately checks Hermiticity of every relevant original matrix. CVXPY constraint residuals and solver statistics are recorded as diagnostics CVXPYConstraints,CVXPYAdvanced,CVXPYSolvers. Independent original-matrix residuals determine acceptance.
The declared floating-point tests are:
finite values and acceptable solver status;
Hermiticity residual and Frobenius norm of the negative spectral part at most ;
affine residual Frobenius norm at most ;
independent primal–dual objective difference at most ;
Choi positivity and trace preservation for every encoded or decoded channel;
agreement with analytical controls at most .
Raw and repaired decoder residuals are both retained. A numerical decoder repair is not an interval certificate. Agreement of objectives is insufficient without feasibility.
sectionError budget by mathematical objectAnalytical controls and numerical acceptance › Error budget by mathematical object · lines 1347–1375
Open as its own page{}1.12
Error Controlled object Valid transfer Radial approximation Complex amplitudes or Cutoff channel bound of Theorem thm:scattererror Covariance quadrature in a justified norm Gaussian state continuity Packet selection Named target observables Equation (eq:subspace) Occupation cutoff State and discarded moments Exact Gaussian error; separate referenced-input bound Energy surrogate Compressed energy/evolution and Calibration Vacuum/nonvacuum statistic Specified affine benchmark only Ancillary approximation Independent resource state Common-interface Theorem thm:ancilla Decoder implementation Complete decoded channel CPTP contraction and triangle inequality
Analytical conclusion
theoremTheorem: Field-to-finite interfaceAnalytical conclusion · proof attached · lines 1379–1399
Open as its own pageFor the specified stationary model and finite orthonormal packet family, the selected state is , its flagged cutoff has dimension , and its exact Gaussian state error is . A justified covariance approximation gives (eq:combined). Energy and coherent scattering have the separate estimates of Section sec:scattering. State error controls an encoded channel under the independent ancillary interface. The specified nonvacuum-calibrated benchmark has the exact recovery and memory optima of Theorem thm:recovery.
Proof. Apply Theorems thm:gaussian, thm:continuity, thm:cutoff, thm:finitescatter, thm:scattererror, thm:ancilla, and thm:recovery, together with Propositions prop:tails, prop:generalcut, and prop:energy.
sectionAnalytical conclusionAnalytical conclusion · lines 1399–1410
Open as its own pageThe principal incorporation is a full finite-state construction, linked to a nonvacuum-calibrated recovery benchmark. No logical encoding, core, clock, or microscopic information-release dynamics is selected by the radiation covariance. The appendix supplies an unexecuted implementation with operational acceptance conditions; it supplies no empirical conclusion about the pilot.
Radial boundary-error estimate
sectionRadial boundary-error estimateRadial boundary-error estimate · lines 1412–1424
Open as its own pageFor real , the right Jost solution satisfies
For another real potential , put , , .
lemmaLemma: Conservative amplitude boundRadial boundary-error estimate · En02-E@2#lem:josterror · proof attached · lines 1425–1460
Open as its own pageFor ,
For incoming and reflected coefficients ,
Consequently
Proof. Volterra iteration gives . Subtracting equations and applying the Volterra resolvent bound gives the solution difference.
The coefficient integrals contain . Write to obtain . Current conservation gives , , and ; hence the stated transmission and reflection bounds. Apply the analogous left Jost construction for opposite incidence. The four-entry Frobenius error is at most ; unitarity separately bounds it by two.
sectionRadial boundary-error estimateRadial boundary-error estimate · lines 1460–1482
Open as its own pageFor (eq:radial),
If , then , and
where , . These are exact potential-tail integrals, not ODE solver errors.
The implementation computes the near-horizon potential using , rather than subtracting a rounded value of from one. This avoids prematurely rounding the exponentially small near-horizon potential to zero at the pilot boundaries.
Finite SDPs and feasibility directions
sectionFinite SDPs and feasibility directionsFinite SDPs and feasibility directions · lines 1484–1544
Open as its own pageUse output-first, unnormalized Choi matrices
For a decoder ,
For a difference of CPTP channels, the half-diamond primal and dual are
and
Their common value is Watrous.
For noise , unrestricted recovery minimizes over
All these constraints are tested in the implementation.
For every channel , the independent acceptance checks include and . A fixed-channel distance primal lower-bounds only that decoder's error, not the optimal recovery over other decoders. Here the benchmark's matching recovery lower bound is analytical.
For a raw decoder Choi matrix, the explicit numerical repair is
It is positive and trace preserving in exact arithmetic. The implementation verifies these properties numerically and archives the repair size. Floating-point residual acceptance is not formal or interval-certified feasibility.
Unexecuted reproducibility supplement
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 1546–1642
Open as its own pageCopy this listing to
02_e_v2.py. Dependencies are Python, NumPy, and SciPy; optional SDPs require CVXPY and SCS. Installed versions are recorded when run.python en02_e_v2.py –mode synthetic python en02_e_v2.py –mode pilot python en02_e_v2.py –mode pilot –sdp –tex En02-E.tex –compile
The synthetic command requires no radial calculation. The pilot runs synthetic checks first, then the field layer and linked operational layer. The source filename is consistently
02-E.tex.Array artifacts have companion basis metadata. Raw solver artifacts are saved in the solve wrapper's
block, before status or feasibility acceptance. No passing status is written if a requested check fails."""En02-E v2. Unexecuted implementation; no results are prepopulated.""" import argparse import datetime import hashlib import itertools as it import json import math from pathlib import Path import shutil import subprocess import sys import traceback import numpy as np import scipy from scipy.integrate import solve_ivp from scipy.special import lambertw
I = np.eye(2,dtype=complex) X = np.array([[0,1],[1,0]],complex) Y = np.array([[0,-1j],[1j,0]],complex) Z = np.diag([1,-1]).astype(complex) H = np.array([[1,1],[1,-1]],complex)/np.sqrt(2) SD = np.diag([1,-1j]).astype(complex) CZ = np.diag([1,1,1,-1]).astype(complex) CX = np.array([[1,0,0,0],[0,1,0,0], [0,0,0,1],[0,0,1,0]],complex) ROOT = None TOL, STOL, GAP = 1e-9, 3e-4, 5e-4 DATA = {"checks":{}, "residuals":{}, "solves":[], "field":{}, "operational":[], "occupancy":[], "certified_numerics":False}
def need(ok,msg): if not ok: raise AssertionError(msg)
def clean(x): if isinstance(x,np.ndarray): return clean(x.tolist()) if isinstance(x,np.generic): return clean(x.item()) if isinstance(x,complex): return "real":clean(x.real),"imag":clean(x.imag) if isinstance(x,float) and not np.isfinite(x): return str(x) if isinstance(x,dict): return str(k):clean(v) for k,v in x.items() if isinstance(x,(list,tuple)): return [clean(v) for v in x] if x is None or isinstance(x,(str,int,float,bool)): return x return repr(x)
def jwrite(name,obj): (ROOT/(name+".json")).write_text( json.dumps(clean(obj),indent=2,allow_nan=False))
def dump(): jwrite("records",DATA)
def save(name,**arrays): np.savez_compressed(ROOT/(name+".npz"),**arrays)
def herm(A): return (A+A.conj().T)/2
def check(name,A,B,tol=TOL): need(name not in DATA["checks"],"duplicate check "+name) A,B = np.asarray(A),np.asarray(B) need(A.shape==B.shape,"shape "+name) err = float(np.max(np.abs(A-B))) DATA["checks"][name] = err need(np.isfinite(err) and err<=tol,name+" residual "+str(err))
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 1642–1744
Open as its own pagedef psd_metrics(A): A = np.asarray(A) need(np.all(np.isfinite(A)),"nonfinite PSD matrix") vals = np.linalg.eigvalsh(herm(A)) return "hermiticity_op":float(np.linalg.norm(A-A.conj().T,2)), "minimum_eigenvalue":float(vals.min()), "negative_part_fro":float(np.linalg.norm(np.minimum(vals,0)))
def accept(name,psds=None,equalities=None,tol=STOL): psds,equalities = psds or {},equalities or {} record = {"PSD":k:psd_metrics(v) for k,v in psds.items(), "affine_fro":k:float(np.linalg.norm(np.asarray(v))) for k,v in equalities.items(), "tolerance":tol,"certified":False} DATA["residuals"][name] = record dump() for k,m in record["PSD"].items(): need(m["hermiticity_op"]<=tol and m["negative_part_fro"]<=tol, name+" PSD residual "+k) for k,v in record["affine_fro"].items(): need(np.isfinite(v) and v<=tol,name+" affine residual "+k)
def kron(*ops): A = np.array([[1]],complex) for B in ops: A = np.kron(A,B) return A
def bits(i,n): return tuple((i>>(n-1-j))&1 for j in range(n))
def integer(b): n = 0 for z in b: n = 2*n+int(z) return n
def embed(G,pos,n): A = np.zeros((2**n,2**n),complex) for col in range(2**n): b = list(bits(col,n)) gc = integer([b[p] for p in pos]) for row in range(2**len(pos)): a = b.copy() for p,z in zip(pos,bits(row,len(pos))): a[p] = z A[integer(a),col] += G[row,gc] return A
def units(d=2): for i,j in it.product(range(d),repeat=2): E = np.zeros((d,d),complex) E[i,j] = 1 yield i,j,E
def dep(A): return np.trace(A)*I/2
def ptout(A,o,b): return sum(A[a*b:(a+1)*b,a*b:(a+1)*b] for a in range(o))
def ptrace(A,keep,n): keep = tuple(keep) drop = tuple(i for i in range(n) if i not in keep) axes = keep+drop+tuple(n+i for i in keep)+tuple(n+i for i in drop) A = A.reshape((2,)*(2*n)).transpose(axes) A = A.reshape(2**len(keep),2**len(drop), 2**len(keep),2**len(drop)) return np.einsum("abcb->ac",A)
def choi(N,d=2): o = len(N[0,0]) return sum((np.kron(N[i,j],E) for i,j,E in units(d)), np.zeros((o*d,o*d),complex))
def channel_check(N,name,tol=TOL): d = int(round(np.sqrt(len(N)))) o = len(N[0,0]) J = choi(N,d) save(name+"_Choi",J=J) jwrite(name+"_Choi_basis","ordering":"output then input", "output_dimension":o,"input_dimension":d,"normalized":False) accept(name,"Choi":J,"TP":ptout(J,o,d)-np.eye(d),tol) return J
def entropy(A): accept("entropy_"+str(len(DATA["residuals"])), "state":A,"trace":np.array(np.trace(A)-1),TOL) vals = np.linalg.eigvalsh(herm(A)) vals = vals[vals>1e-13] return float(-np.sum(vals*np.log2(vals)))
def occupation_basis(J,N): return [n for n in it.product(range(N+1),repeat=J) if sum(n)<=N]
def permanent(A): n = len(A) if n==0: return 1.+0j return sum(np.prod([A[i,p[i]] for i in range(n)]) for p in it.permutations(range(n)))
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 1744–1812
Open as its own pagedef annihilators(basis): lookup = n:i for i,n in enumerate(basis) out = [] d = len(basis)+1 for a in range(len(basis[0])): B = np.zeros((d,d),complex) for col,n in enumerate(basis): if n[a]: m = list(n) m[a] -= 1 B[lookup[tuple(m)],col] = np.sqrt(n[a]) out.append(B) return out
def gaussian_cutoff(K,N,name): J = len(K) accept(name+"_covariance","K":K,tol=TOL) vals,W = np.linalg.eigh(herm(K)) # No silent eigenvalue clipping in state construction. need(vals.min()>=0,"negative covariance eigenvalue") z = vals/(1+vals) basis = occupation_basis(J,N) T = [email protected](np.eye(J)+K) p0 = 1/float(np.linalg.det(np.eye(J)+K).real) rho = np.zeros((len(basis)+1,len(basis)+1),complex) for i,a in enumerate(basis): rows = [r for r,n in enumerate(a) for _ in range(n)] for j,b in enumerate(basis): if sum(a)!=sum(b): continue cols = [r for r,n in enumerate(b) for _ in range(n)] den = np.sqrt(np.prod([math.factorial(n) for n in a+b])) rho[i,j] = p0*permanent(T[np.ix_(rows,cols)])/den tail = 1-float(np.trace(rho).real) rho[-1,-1] = tail save(name,rho=rho,K=K,C=K.T,T=T,eigenvalues=vals) width = int(math.ceil(math.log2(len(rho)))) jwrite(name+"_basis", "matrix_axes":["ket occupation or flag","bra occupation or flag"], "occupation_order":basis,"flag_index":len(basis), "raw_width":width, "physical_to_binary":[format(i,"0 "unused_binary_indices":list(range(len(rho),2**width)), "unused_prepared_weight":0, "reverse_map":"pinch valid/invalid; invalid weight goes to flag", "annihilators_on_flag":0) accept(name+"_density","rho":rho, "trace":np.array(np.trace(rho)-1),TOL)
probs = np.zeros(N+1) for i,n in enumerate(basis): probs[sum(n)] += rho[i,i].real independent_probs = np.zeros(N+1) means = np.zeros(J) for n in basis: weight = float(np.prod((1-z)*z**np.array(n))) independent_probs[sum(n)] += weight means += np.array(n)*weight check(name+"_occupation_distribution",probs,independent_probs) B = annihilators(basis) Ctrunc = np.array([[np.trace([email protected]().T@Bop) for Bop in B] for A in B]) expectedC = ([email protected](means)@W.conj().T).T check(name+"_phase_sensitive_moments",Ctrunc,expectedC) save(name+"_moments",C_truncated=Ctrunc,C_expected=expectedC, occupation_probabilities=probs,normal_mode_retained_means=means) return rho,basis,tail,probs,Ctrunc
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 1812–1883
Open as its own pagedef synthetic_audit(): K = np.array([[.15,.05j],[-.05j,.15]],complex) rho,basis,tail,p,Cn = gaussian_cutoff(K,1,"synthetic_N1") ix = [basis.index((1,0)),basis.index((0,1))] expected = np.array([[425,125j],[-125j,425]],complex)/4356 check("synthetic_one_particle_entries",rho[np.ix_(ix,ix)],expected) check("synthetic_moment_orientation",Cn,expected.T) need(abs(Cn[0,1]-expected[0,1])>1e-3, "phase-sensitive regression is not discriminating") check("synthetic_eigenvalues",np.linalg.eigvalsh(K),np.array([.1,.2])) check("synthetic_vacuum",np.array(p[0]),np.array(25/33)) check("synthetic_tail",np.array(tail),np.array(103/2178)) gaussian_cutoff(K,3,"synthetic_N3") DATA["synthetic"] = "field_dataset":False,"a":8/33, "orientation_test":"explicit imaginary entries and truncated moments" dump() return 8/33
def zcoord(x): # Pilot |x| <= 80; retain z rather than forming r-1 afterwards. return float(lambertw(np.exp(x-1)).real)
def potential(x,ell): z = zcoord(x) r = 1+z return (z/r)*(ell*(ell+1)/r**2+1/r**3)
def radial_tail(cut,ell,omega_min): za,zb = zcoord(-cut),zcoord(cut) L = ell*(ell+1) v = L+.5 left = L*za/(1+za)+.5*za*(2+za)/(1+za)**2 right = L/(1+zb)+.5/(1+zb)**2 d = left+right w = v-d need(d>=0 and w>=0,"potential-tail quantities") A = d/(2*omega_min)*np.exp((v+w)/omega_min)*(1+w/omega_min) return "x_a":-cut,"x_b":cut,"r_h":1, "omega_min":omega_min,"left_tail":left,"right_tail":right, "d":d,"v":v,"w":w,"A":float(A), "S_error_bound_formula_value":float(min(2,4*A)), "vacuous_for_unitary_difference":bool(4*A>=2), "evaluation":"floating-point evaluation of analytical formula", "includes_ODE_error":False,"interval_certified":False
def radial(omega,ell,cut,rtol): def rhs(x,y): return np.array([y[1],(potential(x,ell)-omega**2)*y[0]],complex) y0 = np.array([np.exp(1j*omega*cut), 1j*omega*np.exp(1j*omega*cut)],complex) sol = solve_ivp(rhs,(cut,-cut),y0,method="DOP853", rtol=rtol,atol=rtol*1e-2) need(sol.success,"radial integration") f,fp = sol.y[:,-1] xa = -cut a = .5*np.exp(-1j*omega*xa)*(f+fp/(1j*omega)) b = .5*np.exp(1j*omega*xa)*(f-fp/(1j*omega)) tau,rh = 1/a,b/a ri = -np.conj(rh)*tau/np.conj(tau) S = np.array([[rh,tau],[tau,ri]],complex) flux = abs(abs(a)**2-abs(b)**2-1) unitary = np.linalg.norm(S.conj().T@S-I,2) return tau,rh,S,float(flux),float(unitary),int(sol.nfev)
def simpson_weights(grid): need(len(grid)>=3 and len(grid) weights = np.ones(len(grid)) weights[1:-1:2] = 4 weights[2:-1:2] = 2 return weights*(grid[-1]-grid[0])/(3*(len(grid)-1))
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 1883–1947
Open as its own pagedef field_layer(count,cut,rtol,name): lo,hi = .08,.24 omega = np.linspace(lo,hi,count) width,mid = hi-lo,(hi+lo)/2 h = np.column_stack([np.ones(count)/np.sqrt(width), np.sqrt(12)*(omega-mid)/width**1.5]) bound = radial_tail(cut,0,lo) jwrite(name+"_radial_tail",bound) runs = [radial(om,0,cut,rtol) for om in omega] tau = np.array([r[0] for r in runs]) reflection = np.array([r[1] for r in runs]) S = np.array([r[2] for r in runs]) flux = np.array([r[3] for r in runs]) unitary = np.array([r[4] for r in runs]) weights = simpson_weights(omega) q = np.abs(tau)**2/np.expm1(4*np.pi*omega) K = h.conj().T@((weights*q)[:,None]*h) energy = h.conj().T@((weights*omega)[:,None]*h) save(name,omega=omega,tau=tau,reflection=reflection,S=S, K=K,C=K.T,H=energy,packets=h,weights=weights, flux_residual=flux,unitarity_residual=unitary, ODE_function_evaluations=np.array([r[5] for r in runs])) jwrite(name+"_basis","packet_order":["constant","linear"], "frequency_grid_order":"ascending", "S_rows":["outgoing horizon","outgoing infinity"], "S_columns":["incoming horizon","incoming infinity"], "K_indices":"one-particle ket, bra","C":"K transpose", "radial_tail_artifact":name+"_radial_tail.json") need(max(flux)<1e-5 and max(unitary)<1e-5,"radial flux residual") check(name+"_packet_gram",h.conj().T@(weights[:,None]*h),I,1e-10) check(name+"_energy",energy, np.array([[mid,width/np.sqrt(12)],[width/np.sqrt(12),mid]]),1e-10) return K,energy,"id":name,"grid":count,"cut":cut,"rtol":rtol, "radial_tail":bound,"max_flux_residual":float(max(flux)), "max_unitarity_residual":float(max(unitary)), "certified_total_amplitude_error":False
def field_pilot(): K17,H17,r17 = field_layer(17,80,1e-10,"field_grid17") K33,H33,r33 = field_layer(33,80,1e-10,"field_grid33") K65,H65,r65 = field_layer(65,80,1e-10,"field_grid65") Kb,Hb,rb = field_layer(33,40,1e-10,"field_boundary40") Kt,Ht,rt = field_layer(33,80,1e-7,"field_coarse_tolerance") rho,basis,tail,p,Cn = gaussian_cutoff(K65,2,"field_finite_state") a = 1-1/float(np.linalg.det(I+K65).real) mu = float(np.trace(K65).real) DATA["field"] = {"dataset_id":"field_grid65", "parameters":"r_h":1,"beta":4*np.pi,"ell":0, "band":[.08,.24],"J":2,"N":2, "runs":[r17,r33,r65,rb,rt], "diagnostics_not_certificates": "quadrature_17_33":float(np.linalg.norm(K17-K33,2)), "quadrature_33_65":float(np.linalg.norm(K33-K65,2)), "boundary_40_80":float(np.linalg.norm(Kb-K33,2)), "ODE_tolerance":float(np.linalg.norm(Kt-K33,2)), "mean_occupation":mu,"selected_energy":float(np.trace(H65@K65).real), "normal_mode_means":np.linalg.eigvalsh(K65), "Gaussian_tail_estimate":tail,"Markov_tail":min(1,mu/3), "discarded_mean":mu-float(np.dot(np.arange(3),p)), "offdiagonal_magnitude":float(abs(K65[0,1])), "a":a,"benchmark_uses_only":"a, not full K or finite state"} dump() return a
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 1947–2019
Open as its own pagedef encoder(odd): U = np.eye(8,dtype=complex) sequence = [(CZ,(1,2)),(CZ,(0,1)),(SD,(2,)),(H,(2,)), (SD,(0,)),(H,(0,)),(CX,(0,1)),(CX,(2,1)),(Y,(1,))] for G,p in sequence: U = embed(G,p,3)@U J = np.zeros((32,2),complex) for m,a,b in it.product(range(2),repeat=3): J[integer((a,m,b,a,b)),m] = .5 V = kron(U.conj().T,np.eye(4))@J return embed(CZ,(0,1),5)@V if odd else V
def dilation(V,a,t): dk = list(it.product(range(3),repeat=t)) ek = [(0,b) for b in it.product(range(2),repeat=5)] ek += [(1,b) for b in it.product(range(2),repeat=5-t)] di,ei = d:i for i,d in enumerate(dk),e:i for i,e in enumerate(ek) A = np.zeros((len(dk),len(ek),2),complex) for b in it.product(range(2),repeat=5): row = V[integer(b)] A[di[(0,)*t],ei[0,b]] += np.sqrt(1-a)*row d = tuple(z+1 for z in b[:t]) A[di[d],ei[1,b[t:]]] += np.sqrt(a)*row return A,dk,ek
def channel(A): return (i,j):A[:,:,i]@A[:,:,j].conj().T for i,j,E in units()
def decoupling(A): E = (i,j):A[:,:,i].T@A[:,:,j].conj() for i,j,U in units() bell = np.block([[E[0,0],E[0,1]],[E[1,0],E[1,1]]])/2 marginal = (E[0,0]+E[1,1])/2 return float(np.sum(np.abs(np.linalg.eigvalsh( herm(bell-kron(I/2,marginal)))))/2)
def decoder_kraus(dk,odd=False,low=False): """Complete decoder on all 27 physical input configurations.""" occupied = [dk.index(tuple(z+1 for z in b)) for b in it.product(range(2),repeat=3)] E = np.eye(len(dk),dtype=complex)[occupied,:] ops = [] if low: for t,s,u in it.product(range(2),repeat=3): row = kron(I[:,t].conj()[None,:], H[:,s].conj()[None,:], I[:,u].conj()[None,:]) sign = -(-1)**(t+s+u) out = np.array([[1],[sign]],complex)/np.sqrt(2) ops.append(out@row@E) else: B12 = kron(H,I)@kron(SD,I)@CX@kron(I,H) early = B12@(CZ if odd else np.eye(4)) for t,s in it.product(range(2),repeat=2): correction = np.linalg.matrix_power(X,1-t)@np.linalg.matrix_power(Z,1-s) ops.append(correction@H@SD@kron(early[2*t+s][None,:],I)@E) for j in range(len(dk)): if j not in occupied: for bit in range(2): ops.append(I[:,bit:bit+1]@np.eye(len(dk))[j:j+1,:]/np.sqrt(2)) return ops
def kraus_archive(ops,name): o,d = ops[0].shape R = sum(np.outer(A.reshape(-1),A.reshape(-1).conj()) for A in ops) completeness = sum(A.conj().T@A for A in ops) save(name,Kraus=np.array(ops),Choi=R) jwrite(name+"_basis","Kraus_axes":["path","output","input"], "Choi_axes":"output then input", "output_dimension":o,"input_dimension":d) accept(name,"Choi":R,"Kraus_completeness":completeness-np.eye(d), "Choi_TP":ptout(R,o,d)-np.eye(d),TOL)
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 2019–2097
Open as its own pagedef binary_decoder(ops,dk): B = np.zeros((64,27),complex) for j,d in enumerate(dk): codeword = [0 if z==0 else z+1 for z in d] idx = 0 for z in codeword: idx = 4*idx+z B[idx,j] = 1 out = [[email protected]().T for A in ops] valid = set(np.where(np.sum(np.abs(B),axis=1)>0)[0]) for j in range(64): if j not in valid: for bit in range(2): out.append(I[:,bit:bit+1]@np.eye(64)[j:j+1,:]/np.sqrt(2)) return out,B
def apply_ops(ops,A): return sum(K@[email protected]().T for K in ops)
def ledger(programme,labels,outcomes,coin): """All label histories; quantum slots and physically separate events.""" live,peak,events = 0,0,[] failed,held = False,False def event(action,change=0,**detail): nonlocal live,peak live += change need(live>=0,"negative ledger occupancy") peak = max(peak,live) events.append("action":action,"live":live,**detail) def consume(action,**detail): event(action,-1,**detail) for j,label in enumerate(labels): event("atomic_arrival",2,packet=j) event("label_readout_and_consumption",-1,packet=j,label=label) if label==0: failed = True if failed: if held: consume("retained_rail_destructive_discard",outcomes="both") held = False consume("incoming_rail_or_dummy_destructive_discard",outcomes="both") continue if programme=="even_full" and j==0: held = True event("retain_first_rail") elif programme=="even_full" and j==1: event("early_joint_unitary",gates=["H2","CX1to2","Sdag1","H1"]) consume("early_rail_destructive_readout",rail=1,outcome=outcomes[0]) consume("early_rail_destructive_readout",rail=2,outcome=outcomes[1]) event("classical_outcome_retention",bits=list(outcomes[:2])) held = False elif j<2 or programme=="even_low": gates = [] if programme=="even_low" and j!=1 else \ ["H"] if programme=="even_low" or j==1 else ["Sdag","H"] event("rail_basis_rotation",packet=j,gates=gates) consume("early_destructive_rail_readout", packet=j,outcome=outcomes[j]) event("classical_outcome_retention",bit=outcomes[j]) else: event("final_basis_rotation",gates=["Sdag","H"]) event("final_classical_Pauli_correction", x=1-outcomes[0],z=1-outcomes[1]) event("final_direct_return",-1) if failed: event("allocate_random_bit_slot",1) event("random_bit_H") consume("random_bit_destructive_readout",outcome=coin) event("classical_random_bit_retention",bit=coin) event("reallocate_output_zero",1) event("conditional_X_for_I_over_2",bit=coin) event("failure_state_final_return",-1) elif programme=="even_low": sign = -(-1)**sum(outcomes) event("allocate_output_zero",1) event("conditional_X_for_logical_eigenstate",bit=int(sign<0)) event("output_H") event("pre
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 2097–2114
Open as its own pagepared_logical_eigenstate_final_return",-1) bound = 3 if programme=="even_full" else 2 need(live==0 and peak<=bound,"ledger peak or final occupancy") return "programme":programme,"labels":labels, "readout_outcomes":outcomes,"coin":coin, "events":events,"peak":peak,"bound":bound
def ledgers(dataset): # Failure discard outcomes with identical occupancy are explicitly quotiented. for programme in ("even_low","even_full","odd_full"): count = 3 if programme=="even_low" else 2 for labels in it.product(range(2),repeat=3): for outcome in it.product(range(2),repeat=count): for coin in ((0,1) if not all(labels) else (0,)): record = ledger(programme,labels,outcome,coin) record["dataset_id"] = dataset DATA["occupancy"].append(record) dump()
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 2114–2173
Open as its own pagedef operational_pilot(a,dataset): record = "dataset_id":dataset,"a":a, "encoding":"declared Clifford encoding", "field_information_transferred":"nonvacuum probability only", "IT_error":.75*(1-a),"even_two_slot_error":.75-.25*a, "prefixes":[] evenN = None for odd in (False,True): V = encoder(odd) check(dataset+"_encoder_"+str(odd),V.conj().T@V,I) for t in range(4): name = dataset+"_operational_ A,dk,ek = dilation(V,a,t) save(name,A=A,**{"unit_ jwrite(name+"_basis",{ "A_axes":["accessible configuration","environment configuration","message"], "accessible_order":dk,"environment_order":ek, "packet_symbols":"0":"vacuum","1":"occupied rail 0","2":"occupied rail 1", "environment_branch_0":"all five encoded rails retained", "environment_branch_1":"remaining encoded rails t+1 through 5", "message_order":[0,1], "raw_packet_binary_map":"0":"00","1":"10","2":"11", "unused_packet_binary":"01, assigned failure"}) check(name+"_isometry",A.reshape(-1,2).conj()[email protected](-1,2),I) N = channel(A) channel_check(N,name) record["prefixes"].append("odd":odd,"t":t, "prepared_accessible_entropy":entropy(N[0,0]), "Bell_complement_distance":decoupling(A)) if t==3: for low in ([False,True] if not odd else [False]): decname = name+"_decoder_"+str(low) ops = decoder_kraus(dk,odd,low) kraus_archive(ops,decname) binaryops,B = binary_decoder(ops,dk) kraus_archive(binaryops,decname+"_binary") save(decname+"_embedding",physical_to_binary=B) out = {} for i,j,E in units(): out[i,j] = apply_ops(ops,N[i,j]) expected = a*(E+X@E@X)/2+(1-a)*dep(E) if low \ else a*E+(1-a)*dep(E) check(decname+"_unit_ save(decname+"_decoded", **{"unit_ channel_check(out,decname+"_decoded") if not odd: evenN = N DATA["operational"].append(record) ledgers(dataset) dump() return evenN
def cp_psd(A): import cvxpy as cp B = (A+A.H)/2 Re,Im = cp.real(B),cp.imag(B) return cp.bmat([[Re,-Im],[Im,Re]]) >> 0
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 2173–2227
Open as its own pagedef solve_archived(problem,name,expressions): """Save raw variables/duals immediately, even if solving raises.""" need(problem.is_dcp(),"non-DCP problem "+name) options = "solver":"SCS","eps":1e-7,"max_iters":50000, "verbose":False,"warm_start":False error = None try: problem.solve(**options) except BaseException: error = traceback.format_exc() raise finally: arrays,missing = {},[] for key,expression in expressions.items(): value = expression.value if value is None: missing.append(key) else: arrays[key] = np.asarray(value) for i,c in enumerate(problem.constraints): if c.dual_value is not None: arrays["constraint_dual_"+str(i)] = np.asarray(c.dual_value) save(name+"_raw",**arrays) stats = problem.solver_stats info = {"name":name,"status":problem.status,"objective":problem.value, "options":options,"missing_values":missing,"exception":error, "solver_statistics":None if stats is None else "solver_name":stats.solver_name,"solve_time":stats.solve_time, "setup_time":stats.setup_time,"num_iters":stats.num_iters, "extra_stats":stats.extra_stats} jwrite(name+"_solve",info) DATA["solves"].append(info) dump() # Raw artifact is already durable before diagnostics or acceptance. diagnostics = [] for i,c in enumerate(problem.constraints): try: diagnostics.append("index":i,"violation":c.violation()) except Exception as e: diagnostics.append("index":i,"unavailable":repr(e)) jwrite(name+"_CVXPY_diagnostics",diagnostics) need(problem.status in ("optimal","optimal_inaccurate"),"solver status "+name) need(problem.value is not None and np.isfinite(problem.value),"objective "+name) for key,e in expressions.items(): need(e.value is not None and np.all(np.isfinite(e.value)), "missing/nonfinite "+name+" "+key) return float(problem.value)
def decoder_apply(R,N): b = len(N[0,0]) return (i,j):np.array([[np.trace( R[a*b:(a+1)*b,z*b:(z+1)*b]@N[i,j].T) for z in range(2)] for a in range(2)]) for i,j,E in units()
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 2227–2288
Open as its own pagedef independent_distance(N,name): import cvxpy as cp channel_check(N,name+"_input",STOL) J = choi(N)-choi((i,j):E for i,j,E in units()) accept(name+"_Hermitian_difference",equalities="skew":J-J.conj().T) W = cp.Variable((4,4),hermitian=True) rho = cp.Variable((2,2),hermitian=True) upper = cp.kron(I,rho)-W primal = cp.Problem(cp.Maximize(cp.real(cp.trace(J@W))), [cp_psd(W),cp_psd(rho),cp.trace(rho)==1,cp_psd(upper)]) lo = solve_archived(primal,name+"_primal", "W":W,"rho":rho,"upper_slack":upper) accept(name+"_primal_feasibility", "W":W.value,"rho":rho.value,"upper_slack":upper.value, "trace_rho":np.array(np.trace(rho.value)-1)) D = cp.Variable((4,4),hermitian=True) lam = cp.Variable() slack = lam*I-ptout(D,2,2) dual = cp.Problem(cp.Minimize(lam), [cp_psd(D),cp_psd(D-J),cp_psd(slack)]) hi = solve_archived(dual,name+"_dual", "Z":D,"lambda":lam,"upper_slack":slack) accept(name+"_dual_feasibility", "Z":D.value,"Z_minus_J":D.value-J,"upper_slack":slack.value) need(abs(hi-lo)<=GAP,"distance objective gap "+name) save(name+"_difference",J=J) result = "primal_estimate":lo,"dual_estimate":hi, "gap":hi-lo,"certified":False jwrite(name+"_distance_result",result) return result
def recovery_sdp(N,name,target): import cvxpy as cp channel_check(N,name+"_noise",STOL) b = len(N[0,0]) R = cp.Variable((2*b,2*b),hermitian=True) output = {} for i,j,E in units(): output[i,j] = cp.bmat([[cp.reshape(cp.trace( R[a*b:(a+1)*b,z*b:(z+1)*b]@N[i,j].T),(1,1),order="C") for z in range(2)] for a in range(2)]) J = sum(cp.kron(output[i,j],E) for i,j,E in units()) \ -choi((i,j):E for i,j,E in units()) D = cp.Variable((4,4),hermitian=True) lam = cp.Variable() upper = lam*I-ptout(D,2,2) problem = cp.Problem(cp.Minimize(lam),[ cp_psd(R),ptout(R,2,b)==np.eye(b), cp_psd(D),cp_psd(D-J),cp_psd(upper)]) value = solve_archived(problem,name+"_recovery", "R":R,"Z":D,"lambda":lam,"difference_Choi":J,"upper_slack":upper) raw = np.asarray(R.value).copy() rawdecoded = decoder_apply(raw,N) Jnum = choi(rawdecoded)-choi((i,j):E for i,j,E in units()) accept(name+"_raw_recovery_feasibility", "R":raw,"Z":D.value,"Z_minus_J":D.value-Jnum, "upper_slack":float(lam.value)*I-ptout(D.value,2,2), "decoder_TP":ptout(raw,2,b)-np.eye(b), "affine_Choi":J.value-Jnum) channel_check(rawdecoded,name+"_raw_decoded",STOL)
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 2288–2342
Open as its own pagevals,V = np.linalg.eigh(herm(raw)) P = (V*np.maximum(vals,0))@V.conj().T+1e-12*np.eye(2*b) M = herm(ptout(P,2,b)) vals,V = np.linalg.eigh(M) need(vals.min()>0,"decoder normalization singular") G = (V*(1/np.sqrt(vals)))@V.conj().T fixed = kron(I,G)@P@kron(I,G) save(name+"_repaired_decoder",R=fixed) accept(name+"_repaired_decoder_feasibility","R":fixed, "TP":ptout(fixed,2,b)-np.eye(b)) recovered = decoder_apply(fixed,N) save(name+"_repaired_decoded", **{"unit_ channel_check(recovered,name+"_repaired_decoded",STOL) independent = independent_distance(recovered,name+"_independent") result = "recovery_estimate":value,"analytical_target":target, "repair_Frobenius_size":float(np.linalg.norm(fixed-raw)), "independent_error":independent,"certified":False jwrite(name+"_recovery_result",result) need(abs(value-target)<=GAP,"recovery analytical regression") need(abs(independent["dual_estimate"]-target)<=GAP, "repaired decoder analytical regression") return result
def solver_validation(N,a,dataset): import cvxpy as cp need("SCS" in cp.installed_solvers(),"SCS unavailable") tests = [ ("identity",(i,j):E for i,j,E in units(),0.), ("constant",(i,j):dep(E) for i,j,E in units(),.75), ("dephasing",(i,j):(E+Z@E@Z)/2 for i,j,E in units(),.5), ("calibrated_even",N,.75*(1-a))] for name,noise,target in tests: recovery_sdp(noise,dataset+"_"+name,target)
def compile_source(tex): source = Path(tex).resolve() need(source.exists(),"missing TeX") shutil.copy2(source,ROOT/source.name) for run in (1,2): result = subprocess.run( ["pdflatex","-interaction=nonstopmode","-halt-on-error",source.name], cwd=ROOT,stdout=subprocess.PIPE,stderr=subprocess.STDOUT,text=True) (ROOT/("pdflatex_ need(result.returncode==0,"pdfLaTeX failure") need((ROOT/(source.stem+".pdf")).exists(),"missing PDF") log = ROOT/(source.stem+".log") warnings = [] if log.exists(): warnings = [line for line in log.read_text(errors="replace").splitlines() if "Warning" in line or "Overfull" in line or "Underfull" in line] jwrite("compilation_warnings","warnings":warnings, "return_code_checks_passed":True,"human_warning_inspection_pending":True)
sectionUnexecuted reproducibility supplementUnexecuted reproducibility supplement · lines 2342–2406
Open as its own pagedef main(): global ROOT parser = argparse.ArgumentParser() parser.add_argument("–mode",choices=("synthetic","pilot"),default="synthetic") parser.add_argument("–sdp",action="store_true") parser.add_argument("–tex") parser.add_argument("–compile",action="store_true") args = parser.parse_args() stamp = datetime.datetime.now(datetime.timezone.utc).strftime(" ROOT = Path("en02_e_v2_"+stamp) ROOT.mkdir() source = Path(__file__).resolve() shutil.copy2(source,ROOT/source.name) manifest = "status":"RUNNING","mode":args.mode,"python":sys.version, "numpy":np.__version__,"scipy":scipy.__version__, "source_sha256":hashlib.sha256(source.read_bytes()).hexdigest(), "audit_tolerance":TOL,"SDP_feasibility_tolerance":STOL, "SDP_gap_tolerance":GAP,"sdp_requested":args.sdp, "compilation_requested":args.compile,"numerical_certificate":False path = ROOT/"manifest.json" path.write_text(json.dumps(clean(manifest),indent=2)) try: a = synthetic_audit() N = operational_pilot(a,"synthetic_control") if args.sdp: import cvxpy import scs manifest.update(cvxpy=cvxpy.__version__,scs=scs.__version__, installed_solvers=cvxpy.installed_solvers()) solver_validation(N,a,"synthetic_control") if args.mode=="pilot": a = field_pilot() N = operational_pilot(a,"field_grid65") if args.sdp: recovery_sdp(N,"field_calibrated_even",.75*(1-a)) if args.compile: need(args.tex is not None,"–compile requires –tex") compile_source(args.tex) elif args.tex: shutil.copy2(Path(args.tex),ROOT/Path(args.tex).name) dump() manifest["status"] = "REQUESTED_FLOATING_POINT_CHECKS_PASSED" manifest["compilation"] = "RETURN_CODES_PASSED_WARNINGS_NEED_INSPECTION" \ if args.compile else "NOT_RUN" manifest["scope"] = ("requested finite regressions only; radial convergence " "diagnostics are not certified total errors; human inspection pending") except BaseException: dump() (ROOT/"failure.txt").write_text(traceback.format_exc()) manifest["status"] = "FAILED" raise finally: manifest["artifact_sha256"] = f.name:hashlib.sha256(f.read_bytes()).hexdigest() for f in ROOT.iterdir() if f.is_file() and f.name!="manifest.json" path.write_text(json.dumps(clean(manifest),indent=2,allow_nan=False)) print(ROOT) print(manifest["status"])
if __name__=="__main__": main()
sectionInterpretation of a future archiveUnexecuted reproducibility supplement › Interpretation of a future archive · lines 2407–2432
Open as its own pageThe raw Fock basis is lexicographic occupation order followed by the flag; binary indices are explicitly archived. Operational dilations use ordered accessible configurations, ordered branch-labelled core configurations, and the declared message basis. Every tensor axis is documented.
The complete decoder Kraus maps include all physical label histories and an extension to invalid binary states. This repairs a support-only decoder implementation that would otherwise fail trace preservation on unpopulated input configurations.
The resource ledger enumerates all label histories. Destructive discard outcomes with identical occupancy are quotiented and explicitly marked as both outcomes; they are not postselected. Its random-bit preparation path logs destructive measurement, classical retention, reallocation, and return separately.
A passing archive establishes only the requested floating-point regressions at recorded tolerances. It does not certify the exact radial amplitudes, formal SDP feasibility, or a generic recovery optimum. The universal analytical statements do not depend on that archive.
Declarations
sectionDeclarationsDeclarations · lines 2433–2455
Open as its own pageinterests. The author declares no competing interests.
. No specific grant supported this work.
contribution. N.C.\ developed the model formulation and manuscript. Analytical statements, external dependencies, operational choices, and execution conditions are distinguished explicitly.
and code availability. Formulas and the unexecuted implementation are included. No numerical field dataset, executed solver archive, or compilation record is asserted in this version.
. Not applicable.
bibliographyReferencesDeclarations · lines 2456–2593
Open as its own pageEm03A
N. Cheung, Em03-A: A Fixed-Background Hawking Emission Theorem, version 1, 8 October 2026. Supplied manuscript,
03-A-v1.tex. The stationary boundary model is restated explicitly in this paper.En02D
N. Cheung, Energy-Resolved Radiation and Resource-Limited Recovery: Exact Memory Benchmarks, Loss-Closed Emission, and Explicit Streaming Protocols, version 4, 8 October 2026. Supplied manuscript,
02D-v4.tex. The benchmark specialization used here is proved in the text.Hawking
S. W. Hawking, Particle creation by black holes, Communications in Mathematical Physics 43, 199–220 (1975). doi:10.1007/BF02345020.
DMP
C. Dappiaggi, V. Moretti, and N. Pinamonti, Rigorous construction and Hadamard property of the Unruh state in Schwarzschild spacetime, Advances in Theoretical and Mathematical Physics 15, 355–447 (2011). arXiv:0907.1034v2, revised 21 February 2012.
Weedbrook
C. Weedbrook, S. Pirandola, R. García-Patrón, N. J. Cerf, T. C. Ralph, J. H. Shapiro, and S. Lloyd, Gaussian Quantum Information, Reviews of Modern Physics 84, 621–669 (2012). arXiv:1110.3234. doi:10.1103/RevModPhys.84.621.
Caruso
F. Caruso, J. Eisert, V. Giovannetti, and A. S. Holevo, Multi-mode bosonic Gaussian channels, New Journal of Physics 10, 083030 (2008). arXiv:0804.0511. doi:10.1088/1367-2630/10/8/083030.
FredenhagenHaag
K. Fredenhagen and R. Haag, On the derivation of Hawking radiation associated with the formation of a black hole, Communications in Mathematical Physics 127, 273–284 (1990). doi:10.1007/BF02096757.
HollandsWald
S. Hollands and R. M. Wald, Quantum fields in curved spacetime, Physics Reports 574, 1–35 (2015). arXiv:1401.2026. doi:10.1016/j.physrep.2015.02.001.
Shirokov
M. E. Shirokov, Energy-constrained diamond norms and their use in quantum information theory, Problems of Information Transmission 54, 20–33 (2018). arXiv:1706.00361. doi:10.1134/S0032946018010027.
BlackHawk
A. Arbey and J. Auffinger, BlackHawk v2.0: A public code for calculating the Hawking evaporation spectra of any black hole distribution, arXiv:1905.04268v3, 6 August 2021. Version-specific manual. Original article: European Physical Journal C 79, 693 (2019), doi:10.1140/epjc/s10052-019-7161-1. No execution or comparison is asserted here.
Higuchi
A. Higuchi, Low-frequency scalar absorption cross sections for stationary black holes, Classical and Quantum Gravity 18, L139 (2001); Addendum, 19, 599 (2002). arXiv:hep-th/0108144v2. doi:10.1088/0264-9381/18/20/102.
Watrous
J. Watrous, Semidefinite programs for completely bounded norms, Theory of Computing 5, 217–238 (2009). arXiv:0901.4709. doi:10.4086/toc.2009.v005a011.
Smolin
J. A. Smolin, A four-party unlockable bound-entangled state, Physical Review A 63, 032306 (2001). arXiv:quant-ph/0001001. doi:10.1103/PhysRevA.63.032306.
Bisio
A. Bisio, G. M. D'Ariano, P. Perinotti, and M. Sedlák, Memory cost of quantum protocols, Physical Review A 85, 032333 (2012). arXiv:1112.3853. doi:10.1103/PhysRevA.85.032333.
CVXPYConstraints
CVXPY authors, Constraints: API reference.
https://www.cvxpy.org/api_reference/cvxpy.constraints.htmlConsulted for constraint-violation diagnostics. Installed software versions are recorded by execution.CVXPYAdvanced
CVXPY authors, Advanced Constraints.
https://www.cvxpy.org/tutorial/constraints/index.htmlConsulted for complex expressions and Hermitian variables.CVXPYSolvers
CVXPY authors, Solver Features.
https://www.cvxpy.org/tutorial/solvers/index.htmlConsulted for solver invocation, settings, and statistics.