All manuscripts

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

Export En02-E-v2.tex

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 page

    We 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 page

    The 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 page

    Fix , , 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 page

    The 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 page

    Fix 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 page

    The 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 page

    These 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 page

    The 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 page

    For 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 page

    Replacing 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 page

    Let , 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 page

    For 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 page

    The 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 page

    Write , 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 page

    For 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 page

    Let . 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 page

    For 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 page

    These 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 page

    For 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 page

    This 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 page

    For 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 page

    Either 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 page

    Let 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 page

    This 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 page

    For 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 page

    For 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 page

    Let 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 page

    Compression 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 page

    The 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 page

    Let 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 page

    Thus (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 page

    Define

    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 page

    The 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 page

    Three 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 page

    Let 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 page

    A 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 page

    For , 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 page

    Set

    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 page

    Since (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 page

    On , 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 page

    For 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 page

    The 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 page

    The 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:

    1. finite values and acceptable solver status;

    2. Hermiticity residual and Frobenius norm of the negative spectral part at most ;

    3. affine residual Frobenius norm at most ;

    4. independent primal–dual objective difference at most ;

    5. Choi positivity and trace preservation for every encoded or decoded channel;

    6. 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

    ErrorControlled objectValid transfer
    Radial approximationComplex amplitudes or Cutoff channel bound of Theorem thm:scattererror
    Covariance quadrature in a justified normGaussian state continuity
    Packet selectionNamed target observablesEquation (eq:subspace)
    Occupation cutoffState and discarded momentsExact Gaussian error; separate referenced-input bound
    Energy surrogateCompressed energy/evolution and
    CalibrationVacuum/nonvacuum statisticSpecified affine benchmark only
    Ancillary approximationIndependent resource stateCommon-interface Theorem thm:ancilla
    Decoder implementationComplete decoded channelCPTP contraction and triangle inequality

Analytical conclusion

  • theoremTheorem: Field-to-finite interfaceAnalytical conclusion · proof attached · lines 1379–1399
    Open as its own page

    For 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 page

    The 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 page

    For 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 page

    For ,

    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 page

    For (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 page

    Use 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 page

    Copy 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 page

    def 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 page

    def 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 page

    def 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 page

    def 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 page

    def 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 page

    def 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 page

    pared_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 page

    def 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 page

    def 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 page

    def 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 page

    vals,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 page

    def 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 page

    The 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 page

    interests. 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 page

    Em03A

    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.html Consulted for constraint-violation diagnostics. Installed software versions are recorded by execution.

    CVXPYAdvanced

    CVXPY authors, Advanced Constraints. https://www.cvxpy.org/tutorial/constraints/index.html Consulted for complex expressions and Hermitian variables.

    CVXPYSolvers

    CVXPY authors, Solver Features. https://www.cvxpy.org/tutorial/solvers/index.html Consulted for solver invocation, settings, and statistics.