All manuscripts

Manuscript En02-D@4 · En02-D-v4.tex · e19ec871

Energy-Resolved Radiation and Resource-Limited Recovery Exact Memory Benchmarks, Loss-Closed Emission, and Explicit Streaming Protocols

Export En02-D-v4.tex

Records exact transmission-dependent recovery for one energy-labelled three-packet Clifford channel. The unrestricted half-diamond error is 3(1-p)/4, where p is the full-transmission probability. Under atomic single-pass delivery of q-qubit packets, the even-family optimum at capacity q is 3/4-p/4, and capacity q+1 attains the unrestricted optimum. A controlled-Z modification has a matching q-slot decoder. The reference state is locally Clifford-equivalent to the Smolin state; the unlocking mechanism is inherited and is not a new joint measurement. A sector-feasibility criterion constrains energy-preserving isometries and state-independent prescribed probabilities. A repeated emission model has a unique terminal core, coherent vacuum opportunities, and a loss-closed multiparticle packet space. Its absorption tail is a binomial bound, and its mean absorption time is at most K/r_*. An explicit collect-and-invert protocol has a complete-channel recovery bound. Five ordinary emissions give the prepared-state entropy sequence 0, 1, 2, 2, 1, 0 without a terminal drain. That sequence is not a Page curve. A localized-message transport family has exact unrestricted recovery. Inter-emission entangling dynamics are specified, including four decoder programmes and an unexecuted semidefinite-program supplement. No numerical dynamics result, passing archive, solver certificate, or compilation record is asserted. En02-C's one-live-qubit error of one half is not this transmission-dependent gap. En02-A's global capacity is not the packet width q. En02-B's perfect-code optimum is not this error. Em02-D's inverse-cubic coefficient is not p and not this entropy sequence. Em02-E's relational lapse is not a Hawking flux. The identifier En02-D is not Em02-D. This is not a derivation of Hawking radiation, not generic scrambling, not an island, not an entanglement wedge, not spacetime emergence, and not a solution of the information paradox. The supplement is package evidence, not a certificate, and it is not reported as executed. H2, I3, and J2 remain unresolved. XV-B is not opened. This manuscript does not close O.1, restore bulk symmetry, or discharge Route B. No quantum coefficient is admitted. No compilation is asserted.

Front matter

  • abstractAbstractFront matter · lines 115–152
    Open as its own page

    We separate information availability from the resources needed to execute recovery in specified finite quantum-radiation models. An energy-labelled three-packet Clifford channel has unrestricted optimal half-diamond recovery error , where is the full-transmission probability. Under atomic single-pass delivery of -qubit packets, its even-family optimum at capacity is , whereas capacity attains unrestricted recovery. A controlled- modification has a matching -slot decoder. The reference state is explicitly locally Clifford-equivalent to the Smolin state; its unlocking mechanism is inherited.

    We prove a sector-feasibility criterion for energy-preserving isometries and its stronger counterpart for state-independent prescribed probabilities. A repeated emission model has a unique terminal core, coherent vacuum opportunities, internal unitaries, and a loss-closed multiparticle packet space. Its absorption tail is bounded by a binomial tail, and its mean absorption time is at most . An explicit collect-and-invert protocol has a complete-channel recovery bound with an event-wise memory ledger. Five ordinary emissions give a prepared-state entropy sequence , without a terminal drain.

    A localized-message transport family gives exact unrestricted recovery and analytically evaluated streaming channels. For inter-emission entangling dynamics, we specify coherent simulation, four complete decoder programmes, numerical semidefinite-program validation, and failure-preserving archival procedures. This computational supplement is not reported as executed: no numerical dynamics result, passing archive, solver certificate, or compilation record is asserted. The proved results are finite-model statements, not a derivation of Hawking radiation, generic scrambling, or gravitational islands.

Introduction and scope

  • sectionIntroduction and scopeIntroduction and scope · lines 157–199
    Open as its own page

    A spectrum does not specify a quantum channel. Occupation statistics leave phases, temporal correlations, remnant states, and logical encoding undetermined. An entropy curve likewise does not determine a decoder or its execution resources.

    Hayden–Preskill retrieval assumes rapidly mixing unitary dynamics and extensive access to radiation HP. Random-unitary evaporation models already distinguish internal and environment-coupling timescales and investigate information retrieval Piroli. Memory minimization is a global multistep optimization problem, even when classical memory is free Bisio.

    Our mathematical contributions are:

    1. exact transmission-dependent recovery and atomic-delivery memory optima for a finite benchmark;

    2. realizability constraints for prescribed emission probabilities;

    3. loss-compatible repeated emission, quantitative absorption, and explicit complete recovery programmes.

    The underlying benchmark state is locally Clifford-equivalent to Smolin's unlockable state Smolin. We therefore claim neither a new unlockable state nor a new joint-measurement unlocking mechanism. Our additional statements concern complete-channel error, propagation loss, and a declared delivery interface.

    Operator-spreading diagnostics have a separate role Nahum; they are not recovery certificates. Clifford components admit stabilizer simulation AaronsonGottesman, but arbitrary emission amplitudes and non-Clifford internal gates do not make the complete process a stabilizer circuit. Pure-loss purification provides relevant propagation and error-detection context Winnel, without establishing the finite deterministic recovery results proved here.

  • sectionRevision and execution statusIntroduction and scope › Revision and execution status · lines 200–224
    Open as its own page

    This revision repairs the computational specification by:

    • distinguishing S0's final direct return from earlier measure-and-prepare paths;

    • testing the entire loss-closed scattering domain with nonuniform constituent energies;

    • adding a coherent multiparticle collect-and-invert regression;

    • defining inter-emission entangling circuits and complete streaming programmes with priced occupancy;

    • including recovery and independent channel-distance SDPs;

    • retaining running and failed archives instead of writing an unearned passing manifest.

    limitation. The supplement has not been executed in preparing this revision. There is no supplied passing audit, executed dynamics dashboard, SDP result, or compilation log. Consequently the manuscript's analytical statements and its unexecuted computational specification are explicitly separated. The requested minimum standard for an executed dynamics study remains pending.

  • sectionPhysical scopeIntroduction and scope › Physical scope · lines 225–239
    Open as its own page

    We use , with base-two entropy. Energy conservation refers to the displayed finite Hamiltonians. Equal-energy rails are orthogonal scalar modes, not particle polarizations. Rotational covariance, an autonomous clock, apparatus work, detector absorption, and a field-to-qubit transducer are not derived.

    Reflections remain inaccessible and do not return to the core. No companion manuscript is a proof premise. The finite models do not establish semiclassical evaporation, a typical Page curve, or a gravitational island formula.

Channels and the observer interface

  • sectionChannels and the observer interfaceChannels and the observer interface · lines 241–260
    Open as its own page

    All spaces are finite dimensional. A channel is completely positive and trace preserving (CPTP). We use

    including external references WatrousBook.

    For the accessible radiation channel , define

  • assumptionAssumption: Atomic single-pass deliveryChannels and the observer interface · En02-D@4#ass:interface · lines 261–276
    Open as its own page

    For a declared horizon, packets arrive once, in order. Each packet atomically occupies its entire declared binary width.

    A passive supplier may buffer undelivered packets but may not measure, demultiplex, select, or decode them. The observer may pause delivery but may not revisit consumed packets, return intermediate quantum data to the supplier, use uncounted storage, share auxiliary entanglement, or export quantum output before consuming every horizon packet.

    Classical memory is unrestricted. Every laboratory qubit is destructively measured or returned as the final output.

  • sectionChannels and the observer interfaceChannels and the observer interface · lines 276–302
    Open as its own page

    The class consists of finite deterministic protocols satisfying this assumption and . Lower bounds permit arbitrary instruments. counts delivered inputs, work, quantum records, retained data, and output. additionally counts supplier buffers. The inaccessible core, reflected environment, and correctness reference are not observer storage.

    A retained output is live memory. The no-early-export rule can make operational error nonmonotone in the mandatory delivery horizon.

    The exact benchmark library contains , zero allocation, destructive computational readout, classical control, and return. A classically selected Pauli costs at most one gate. Parallel register readout takes one instruction round. Allocation, transfer, and return are instantaneous in this convention.

    Preparing uses one recyclable slot and at most two gates: generate a random bit by and destructive readout, then reallocate and conditionally apply .

The Clifford benchmark and its inherited unlocking state

  • sectionThe Clifford benchmark and its inherited unlocking stateThe Clifford benchmark and its inherited unlocking state · lines 304–330
    Open as its own page

    The message occupies among five qubits. Let

    and define, rightmost factor first,

    There are thirteen preparation gates. Put and . Only 's parity matters.

    For ,

  • lemmaLemma: Signed logical representativesThe Clifford benchmark and its inherited unlocking state · En02-D@4#lem:logical · proof attached · lines 331–361
    Open as its own page

    For ,

    where

    The linear extension replaces by .

    Proof. Gate conjugation gives

    The identity gives the signed word. Conjugating by , using , , and , gives the odd row. The displayed channel normal form proves the expansion.

  • sectionThe Clifford benchmark and its inherited unlocking stateThe Clifford benchmark and its inherited unlocking state · lines 361–378
    Open as its own page

    Every proper even-family subset is constant. The only nonconstant proper odd-family subsets are and , carrying and , respectively. For example, the former is , an entanglement-breaking measure-and-prepare channel. Both chronological prefixes , are constant. Applying and discarding positions recovers the message from the full triple.

    For even parity, the normalized Bell-input state is

  • propositionProposition: Explicit Smolin identificationThe Clifford benchmark and its inherited unlocking state · En02-D@4#prop:smolin · proof attached · lines 379–398
    Open as its own page

    Let and . Then

    where runs over the four Bell states.

    Proof. The right side is . Conjugation by cycles . The two rail rotations give signs . Conjugation by reverses the first and third signs.

Benchmark energy, transmission, and optimal recovery

  • sectionBenchmark energy, transmission, and optimal recoveryBenchmark energy, transmission, and optimal recovery · lines 402–461
    Open as its own page

    Choose weights summing to one and frequencies . A raw packet has vacuum and occupied states , , with energies . Its declared representation has a label and one rail:

    Fix . Inject

    Branch zero emits vacuum and retains all five qubits. Branch extracts in successive packets. After extractions its core energy is ; branch zero retains energy . These maps are isometries on their declared domains because branches are orthogonal and extraction transfers a tensor factor. Their output energies equal their input energies.

    Propagation is the rail-independent isometry

    with vacuum mapped to two vacua. Thus on the evolved input space.

    For , set

    Tracing the branch-labelled core and reflected positions gives orthogonal accessible blocks for nonempty . Their rail channels are the corresponding reductions of . All empty surviving sets form one constant vacuum block. In particular, all flag weights are message-independent.

    Define

    and

  • lemmaLemma: Recovery witnessesBenchmark energy, transmission, and optimal recovery · En02-D@4#lem:witness · proof attached · lines 462–478
    Open as its own page

    Decoded constant and entanglement-breaking qubit channels have half-diamond error at least and , respectively. For a Pauli channel ,

    Proof. A constant channel's Bell-input output has Bell overlap . A separable two-qubit state has Bell overlap at most . Testing the Bell projector gives the lower bounds. For a Pauli channel the Bell errors are orthogonal, giving ; the triangle inequality gives the matching upper bound.

  • theoremTheorem: Benchmark unrestricted and memory optimaBenchmark energy, transmission, and optimal recovery · En02-D@4#thm:benchmark · proof attached · lines 480–534
    Open as its own page

    For either parity, for . At horizon three,

    Under Assumption ass:interface,

    and

    Proof. Constant early prefixes give the first claim. Flagwise Bell witnesses give the unrestricted lower bounds. The complete channels

    attain them.

    For the even -slot lower bound, the first packet must leave only classical information before the second atomic arrival. A positive effect on its occupied rail has the form , . The conditional reference–future state is

    where , , , and . For joint projectors , it equals

    This is separable. Subsequent operations preserve separability. Label-mixing effects do not avoid the argument because spectral blocks are already incoherent. Decoded Bell overlap is therefore at most .

    Measuring and preparing the logical eigenstate of their negative parity on full transmission attains . The remaining upper bounds follow from the compiled programmes below.

  • sectionCompiled programmes and complete failure outputsBenchmark energy, transmission, and optimal recovery › Compiled programmes and complete failure outputs · lines 536–586
    Open as its own page

    Set

    The even programme consumes packet labels, holds the first rail until the second arrival, applies , and reads the early pair as . It consumes both early rails before the third arrival. On full transmission it applies and returns rail three; otherwise it consumes the remaining inputs and prepares .

    Indeed,

    The corrected path maps intertwine logical with output , hence have the form . The early pair is , giving path probability .

    For odd parity,

    Separate early and measurements suffice. The and failure flags use product parity readouts and logical eigenstate preparation.

    The ledgers are

    They include failure preparation. For a three-packet snapshot, .

    Every destructive readout is part of a complete instrument. If are the full instruction-history maps, then . Thus successful branches are never renormalized into a deterministic claim.

Entropy and complementary information

  • sectionEntropy and complementary informationEntropy and complementary information · lines 588–647
    Open as its own page

    Entropy calculations use input ; recovery uses a Bell reference with unchanged dynamics.

    For , define

    Let contain and the nonempty flag weights. For even parity the rail entropy is one for a singleton and two for a pair or triple. For odd parity the exception is . Then

    This follows from the orthogonal-block entropy identity. For ,

    Propagation preserves entropy of the complete emitted region.

    For the Bell experiment let and

    A constant qubit channel has a complementary Bell state isometric to , so its distance is . This follows from a dilation of a fixed output .

    Consequently the even benchmark has

    Complementary full-transmission sectors are constant; failure sectors complement constant accessible channels. The vacuum sector is retained coherently as one sector.

    This equality is special to this channel, not a general identification of Bell-input decoupling with worst-case recovery.

Sector feasibility

  • sectionSector feasibilitySector feasibility · lines 649–661
    Open as its own page

    Let . Outcome has radiation energy and degeneracy . Write

  • theoremTheorem: Feasibility and fixed probabilitiesSector feasibility · En02-D@4#thm:feasibility · proof attached · lines 662–692
    Open as its own page

    An energy-preserving isometry exists if and only if

    for every . A specified map is isometric precisely when

    Prescribed probabilities , independent of every state in , are realizable precisely when they are nonnegative, sum to one, and

    Their branch effects must equal .

    Proof. The total-energy output subspace must contain orthogonal vectors, and this dimension condition is sufficient. Different total energies are orthogonal. Orthogonal radiation outcomes give the isometry equation.

    State-independent expectations imply the scalar effect identity by polarization. A positive scalar identity has rank . Conversely, choose an isometry into each sufficiently large branch and multiply it by .

  • sectionSector feasibilitySector feasibility · lines 692–699
    Open as its own page

    Total dimension can suffice while individual branches are too small for a fixed probability law. A coarse count law and a law of individual rail configurations are different requirements.

Repeated emission and the loss-closed interface

  • sectionRepeated emission and the loss-closed interfaceRepeated emission and the loss-closed interface · lines 701–756
    Open as its own page

    Fix , , and

    The core is

    Sector zero is the unique endpoint. Mode pair has energy . There is at most one quantum per retained mode pair.

    Emission of constituents occupies . Its energy is .

    Define the deduplicated occupation family

    The loss-closed packet space is

    with rail bits ordered by decreasing mode index and energy . A configuration is identified once, regardless of its hidden origin.

    The label count and physical dimension are

    For a span of length , both endpoints are present; interior indices have two occupation choices or three physical choices. This proves the formulas.

    The declared representation uses

    The label is the surviving set; its actual rail bits are followed by zero padding. For stage A, , .

  • propositionProposition: Propagation on the full loss-closed domainRepeated emission and the loss-closed interface · En02-D@4#prop:scatter · proof attached · lines 757–778
    Open as its own page

    For rail-independent coefficients,

    is an isometry on all of and preserves energy.

    Proof. Different assignments are orthogonal and their squared amplitudes sum to one. Different inputs are distinguished by the union of occupied output modes and rail bits. Both subsets remain in , and their energies add to the input energy.

  • sectionRepeated emission and the loss-closed interfaceRepeated emission and the loss-closed interface · lines 778–796
    Open as its own page

    For example, loss from can produce . No emitted-interval tag survives for free. Accessible vacuum can mean no emission, complete reflection, or an already terminal core.

    At opportunity , specify summing to one and a unitary . Let transfer the first current factors to the ordered mode interval . Set

  • theoremTheorem: Repeated dilationRepeated emission and the loss-closed interface · En02-D@4#thm:repeated · proof attached · lines 797–816
    Open as its own page

    Each is isometric and energy preserving. Its coarse branch effect is , for every rail state and reference. With propagation,

    on the evolved initial sector.

    Proof. Each extraction is isometric, distinct counts are orthogonal, and their effects sum to the identity. The branch dimension is . Its energy is . Different sectors have different total energies. Compose with Proposition prop:scatter.

  • sectionRepeated emission and the loss-closed interfaceRepeated emission and the loss-closed interface · lines 816–822
    Open as its own page

    Arbitrary rail gates preserve this Hamiltonian because each sector is degenerate. This is not an excitation-number conservation claim for another Hamiltonian.

Absorption and drain-free turnover

  • sectionAbsorption and drain-free turnoverAbsorption and drain-free turnover · lines 824–837
    Open as its own page

    For initial sector , let , . Then

    Branch effects are scalar and propagation does not change the core reduction. Distinct core energies have distinct emitted complementary energies, eliminating inter-sector coherences. Thus this recursion is independent of internal gates and loss.

  • theoremTheorem: Absorption tail and meanAbsorption and drain-free turnover · En02-D@4#thm:absorption · proof attached · lines 838–863
    Open as its own page

    If for every nonterminal sector and opportunity, then

    Terms are zero; for , the tail is . Absorption occurs almost surely, not necessarily by a deterministic finite horizon.

    Proof. Couple the population recursion to independent uniform variables. A value at most forces a sector decrease of at least one. The waiting time for Bernoulli- successes dominates absorption. Its tail is the displayed binomial tail and its mean is the sum of geometric means . This auxiliary probability construction does not measure the coherent quantum history.

  • sectionAbsorption and drain-free turnoverAbsorption and drain-free turnover · lines 863–886
    Open as its own page

    For time-homogeneous stage A, ,

    For the synthetic law , , the uniform bound is opportunities and the exact mean is .

    For a pure input and ,

    The endpoint block is one-dimensional and the complement has dimension at most . Also

    Permanent inaccessible loss need not give zero accessible entropy.

  • theoremTheorem: Prepared-state turnoverAbsorption and drain-free turnover · En02-D@4#thm:turnover · proof attached · lines 887–909
    Open as its own page

    For , deterministic emission, initial state , and extraction of in order, apply between emissions three and four. At perfect transmission,

    The third prefix retains Theorem thm:benchmark with width and .

    Proof. The first three channels are the benchmark channels with known descending mode labels. The remaining Bell-partner reduction is , unchanged by the controlled . After the fourth extraction it is ; after the fifth the core is one-dimensional. No exceptional drain operation is used.

Collect-and-invert recovery

  • sectionCollect-and-invert recoveryCollect-and-invert recovery · lines 913–934
    Open as its own page

    Initialize by a known isometry with known unitary preparation.

    Full simulator histories include hidden reflections. Accessible histories contain only observed surviving sets and observer measurement outcomes.

    Let be the probability that every one of the actual constituents has been emitted and transmitted. For complete no-loss histories ,

    Distinct complete no-loss histories have orthogonal accessible occupation configurations.

  • theoremTheorem: Complete recovery programmeCollect-and-invert recovery · En02-D@4#thm:collect · proof attached · lines 935–975
    Open as its own page

    A deterministic protocol has

    and complete decoded channel

    Thus its achieved error is . At perfect transmission .

    Proof. Measure each surviving-set label, consume padding, and retain only actual transmitted rails. Each mode is emitted at most once. Collecting rails therefore certifies completion and no loss. Only then do observed vacua certify no-emission opportunities.

    The complete history is reconstructible. Its collected map is , with a known unitary on factors. Apply , undo initialization, and consume the ancillary factors. Every corrected success is the identity channel. On incomplete collections, consume everything and prepare .

    Before an arrival there are at most undecoded rails or one decoded output. The atomic arrival adds slots. Label and padding consumption leave at most real rails. The inverse uses these existing slots. Early completion leaves one live output through subsequent arrivals; .

    The total success effect is a scalar identity, so fixed-output failure has input-independent total probability. This proves the complete channel, including references.

  • sectionCollect-and-invert recoveryCollect-and-invert recovery · lines 975–982
    Open as its own page

    Specified continuous gates and their inverses may be admitted as primitives. Discrete-library compilation requires an additional error and workspace budget. This theorem is an achieved bound, not a memory optimum.

Analytical transport controls and horizon-dependent execution

  • sectionAnalytical transport controls and horizon-dependent executionAnalytical transport controls and horizon-dependent execution · lines 984–1004
    Open as its own page

    Use stage A, identity inter-emission gates, transmission , and initialization

    An initial sequence of adjacent swaps moves the message to extraction position . Its mode is . This is transport, not scrambling.

    Let be its emission time, , . The population recursion gives

  • propositionProposition: Transport controlsAnalytical transport controls and horizon-dependent execution · En02-D@4#prop:transport · proof attached · lines 1005–1041
    Open as its own page

    Unrestricted recovery and a one-retained-qubit programme satisfy

    A -slot programme S0 implements

    and has achieved error

    No stochastic -slot optimum is asserted.

    Proof. If the message mode is transmitted by the horizon, it carries the message exactly. Otherwise the message remains in a different core sector or a reflected message mode, and the accessible channel is constant. These success and failure subspaces are distinguished in the complement, so their cross terms vanish. Bell witnesses give the lower bound.

    S1 retains the observed message rail through later arrivals. S0 measures an earlier-arriving message rail in and consumes it, retaining a classical outcome. If the message arrives at the final opportunity, S0 returns it directly without a logical measurement. An earlier record causes eigenstate preparation after the last packet; no record causes preparation of . The stated complete channel follows.

  • sectionAnalytical transport controls and horizon-dependent executionAnalytical transport controls and horizon-dependent execution · lines 1041–1083
    Open as its own page

    For deterministic emissions,

    The last lower bound follows because mandatory later delivery forces consumption of the earlier message qubit.

    For constant ,

    For pure input , all rails remain zero, so .

    At , the following values are analytical, not solver outputs:

    The common sector vector is , ordered . Its entropy is .

    warning. At two opportunities, “emit then vacuum” and “vacuum then emit” can share the same final core and reflected configuration. For constant , perfect transmission, and zero rails, their temporal off-diagonal element is . A mixture of simulator trajectories would incorrectly remove it.

Inter-emission dynamics and explicit protocol classes

  • sectionInter-emission dynamics and explicit protocol classesInter-emission dynamics and explicit protocol classes · lines 1085–1090
    Open as its own page

    This section defines the unexecuted computational study precisely. It does not supply numerical conclusions.

  • sectionControlled dynamicsInter-emission dynamics and explicit protocol classes › Controlled dynamics · lines 1091–1121
    Open as its own page

    Use stage A with constant , localized initialization, and initially perfect transmission. At every opportunity and sector, apply alternating nearest-neighbour layers before the emission decision. Layer parity alternates with opportunity and layer index.

    Each two-qubit gate is

    with independent angles uniform on . These are specified entangling gates, not Haar- samples. The supplement records every angle and gate matrix. Depths are nested using the same preselected layer arrays.

    Controls are identity dynamics and initial SWAP transport. The depth parameter in the new family changes actual inter-emission gates, not just initialization.

    The proposed first pilot uses , , , two declared gate realizations, and horizons . The extension is a separate command, not an executed result.

  • sectionDecoder A: readout and preparationInter-emission dynamics and explicit protocol classes › Decoder A: readout and preparation · lines 1122–1132
    Open as its own page

    Measure every observed occupied rail in , consume it, and retain the latest readout bit. After all horizon packets, prepare that bit as a computational basis state. If no occupied rail was observed, prepare . The laboratory peak is at most . This is a fixed achieved baseline, not the optimum of .

  • sectionDecoder B: one retained qubitInter-emission dynamics and explicit protocol classes › Decoder B: one retained qubit · lines 1133–1142
    Open as its own page

    Retain the first observed occupied rail as memory. For every later occupied rail , apply , then , measure as , consume it, and apply . Vacuum dummy rails are consumed. Return after the horizon; if no memory exists, prepare . The peak is at most .

  • sectionDecoder C: two retained qubitsInter-emission dynamics and explicit protocol classes › Decoder C: two retained qubits · lines 1143–1156
    Open as its own page

    Retain the first two occupied rails. For each later occupied rail , apply , , and ; measure and consume , applying . At the horizon, if two rails remain, apply , , measure and consume , and apply . Return the remaining rail. One or zero retained rails are handled by direct return or preparation. The peak is at most .

  • sectionDecoder D: collect and invertInter-emission dynamics and explicit protocol classes › Decoder D: collect and invert · lines 1157–1163
    Open as its own page

    Use Theorem thm:collect. At perfect transmission its achieved error is , with peak at most . It is a correctness reference, not generally an optimal batch decoder.

  • propositionProposition: Implementability of A–CInter-emission dynamics and explicit protocol classes › Decoder D: collect and invert · En02-D@4#prop:stream · proof attached · lines 1164–1182
    Open as its own page

    The specified programmes are deterministic CPTP maps with the stated laboratory peaks.

    Proof. Occupation-label readout determines actual occupied rails. No supplier-side operation or hidden emission record is used. At most memory qubits coexist with the next atomic packet. Every gate acts on existing memory and an existing incoming rail. Every measurement has both outcomes and its declared feedback. Padding and consumed rails are destructively removed. Finalization leaves exactly one output, or allocates one recyclable slot for fixed-output preparation. Instrument completeness proves trace preservation and includes all references.

  • sectionDecoder D: collect and invertInter-emission dynamics and explicit protocol classes › Decoder D: collect and invert · lines 1182–1188
    Open as its own page

    No ordering of achieved errors across these heuristic programmes is assumed. More permitted memory cannot worsen an optimum, but different fixed heuristic programmes need not be monotone.

Recovery SDPs and numerical verification

  • sectionRecovery SDPs and numerical verificationRecovery SDPs and numerical verification · lines 1190–1250
    Open as its own page

    Use output-first unnormalized Choi matrices

    For a decoder ,

    For logical dimension , let

    Entanglement fidelity is . Its recovery SDP and dual are

    Strict feasibility holds on both sides. This is fixed-noise fidelity recovery Fletcher. A verified dual value implies

    by a normalized Bell-projector test. It is not diamond optimization.

    For a difference of CPTP channels, the SDP

    has dual

    Their common value is WatrousSDP.

    Unrestricted diamond recovery is therefore

    This affine finite-dimensional SDP is not a bounded-memory strategy optimization.

  • sectionNumerical acceptance policyRecovery SDPs and numerical verification › Numerical acceptance policy · lines 1251–1270
    Open as its own page

    The implementation first checks identity, constant, dephasing, and the flagged even benchmark against analytical optima. For every new channel it records:

    • raw recovery variables and affine/positivity residuals;

    • a positive trace-preserving decoder obtained by explicit Choi normalization;

    • an independent fixed-channel diamond primal and dual;

    • a fidelity-dual lower-bound candidate;

    • solver settings, statuses, and computed gaps.

    Numerical positivity checks and scalar repairs are not interval certificates. Values remain numerical estimates unless stronger verification is supplied. An optimizer's status string alone is insufficient.

Joint dashboard and evidence boundaries

  • sectionJoint dashboard and evidence boundariesJoint dashboard and evidence boundaries · lines 1271–1313
    Open as its own page

    For each realized circuit and horizon, the supplement is designed to record

    the exact finite energy expectations, unrestricted recovery estimates, complete A–D channels, and resource histories.

    The predeclared closed-core spreading diagnostic is

    Set . The dashboard uses . This is an opportunity-local closed-core diagnostic, not a cumulative open-system OTOC or recovery certificate.

    Opportunity, actual emitted count, and accumulated internal layers are distinct clocks. Recording the distribution of emitted counts does not grant the decoder access to hidden counts. Replotting against their mean is not conditioning on a physical emission-count trajectory.

    Ensemble summaries must average per-realization quantities. Entropy or recovery of an averaged channel is a different object.

    status. No dashboard values for the new entangling study are supplied. No conclusion about depth, memory improvement, or recovery coincidence is prewritten. The analytical transport table is the only results table above.

Errors and retained calibration boundary

  • sectionErrors and retained calibration boundaryErrors and retained calibration boundary · lines 1314–1371
    Open as its own page

    For compatible complete-channel errors,

    For a common packet embedding and common feasible protocol class, the optimized errors differ by at most . Both statements follow from triangle inequalities and CPTP contraction.

    For common isometry embeddings,

    For changed branch probabilities,

    Such stepwise errors telescope. The supplement discards no amplitude by a nonzero threshold. Entropy eigenvalue tolerances and numerical solver tolerances are not trajectory truncations.

    The optional benchmark spectral comparison retains its pre-barrier convention:

    These external scalar-rate inputs are motivated by Hawking,BlackHawk, not computed here. Transmission is applied once. For weight mismatch , transmission mismatch , frequency Lipschitz constant , mass derivative bound , and mass variation , the selected two-rail count error is bounded by

    The proof is weight comparison, midpoint integration, and the mass mean-value bound. Omitted target number expectation adds separately. This does not calibrate the repeated model or determine coherent channel error.

Conclusions

  • sectionConclusionsConclusions · lines 1372–1390
    Open as its own page

    The finite analytical core supplies exact benchmark memory optima, sector feasibility, loss closure, absorption, a drain-free prepared turnover, and explicit complete-channel recovery programmes.

    The present revision additionally supplies a concrete computational study specification with repaired resource histories, multiparticle regression, inter-emission entangling gates, and numerical SDP checks. It does not substitute this specification for executed evidence.

    Release as a completed numerical dynamics study requires the actual passing archive, recovered decoder arrays, independent distance calculations, dashboard records, and compilation logs. Until then, only the analytical statements are presented as proved.

Computational supplement

  • sectionComputational supplementComputational supplement · lines 1392–1500
    Open as its own page

    Copy the following listing to 02_d_v4.py. Dependencies are Python, NumPy, CVXPY, and a supported SDP solver. The default command requests SCS; installed versions are recorded. Complex Hermitian variables and solver invocation follow the official implementation documentation CVXPY.

    python en02_d_v4.py –mode audit python en02_d_v4.py –mode pilot –tex En02-D-v4.tex –compile # Run the larger extension only after inspecting pilot cost: python en02_d_v4.py –mode extend –tex En02-D-v4.tex –compile

    Each invocation creates a new archive directory. It initially has status RUNNING. Exceptions preserve arrays, residuals, and a traceback with FAILED status. A numerical passing status is issued only after the requested checks finish. Compilation is separately recorded and is required for the combined numerical-and-compilation status.

    The archive is a finite floating-point regression, not a formal certificate. The code below has not been executed here.

    """En02-D-v4: unexecuted coherent audit and pilot implementation.""" 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 from fractions import Fraction as F import numpy as np

    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) SW = np.array([[1,0,0,0],[0,0,1,0], [0,1,0,0],[0,0,0,1]],complex) TOL, STOL = 1e-10, 3e-4 DATA = {"checks":{}, "records":[], "solvers":[], "occupancy":[]} ROOT = None SOLVER = "SCS"

    def need(ok, msg): if not ok: raise AssertionError(msg)

    def herm(A): return (A+A.conj().T)/2

    def mineig(A): return float(np.linalg.eigvalsh(herm(A)).min())

    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) e = float(np.max(np.abs(A-B))) DATA["checks"][name] = e need(e<=tol, name+" residual "+str(e))

    def save(name, **arrays): np.savez_compressed(ROOT/(name+".npz"), **arrays)

    def dump(): (ROOT/"records.json").write_text(json.dumps(DATA,indent=2))

    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): out = 0 for z in b: out = 2*out+int(z) return out

    def embed(G,pos,n): pos = tuple(pos) A = np.zeros((2**n,2**n),complex) for col in range(2**n): b = list(bits(col,n)) 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,integer([b[p] for p in pos])] return A

  • sectionComputational supplementComputational supplement · lines 1500–1592
    Open as its own page

    def ptrace(A,keep,n): keep = tuple(keep) drop = tuple(j for j in range(n) if j not in keep) axes = keep+drop+tuple(n+j for j in keep)+tuple(n+j for j 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 entropy(A): e = np.linalg.eigvalsh(herm(A)) need(e.min()>=-TOL,"entropy positivity") # Eigenvalue handling only; no simulation amplitudes are dropped. e = e[e>1e-12] return float(-np.sum(e*np.log2(e)))

    def units(d=2): for a,b in it.product(range(d),repeat=2): E = np.zeros((d,d),complex) E[a,b] = 1 yield a,b,E

    def dep(A): return np.trace(A)*I/2

    def choi(N): return sum((np.kron(N[a,b],E) for a,b,E in units()), np.zeros((2*N[0,0].shape[0],)*2,complex))

    def idchoi(): return choi((a,b):E for a,b,E in units())

    def channel(A): return (a,b):A[:,:,a]@A[:,:,b].conj().T for a,b,E in units()

    def decoupling(A): C = (a,b):A[:,:,a].T@A[:,:,b].conj() for a,b,E in units() rho = np.block([[C[0,0],C[0,1]],[C[1,0],C[1,1]]])/2 env = (C[0,0]+C[1,1])/2 return float(np.abs(np.linalg.eigvalsh( herm(rho-np.kron(I/2,env)))).sum()/2)

    def encoder(): U = np.eye(8,dtype=complex) seq = [(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 seq: 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 return U,np.kron(U.conj().T,np.eye(4))@J

    def benchmark(V,w0=.25,gamma=(.5,2/3,.75),t=3): entries = {} def put(key,v): entries[key] = entries.get(key,np.zeros(2,complex))+v for b in it.product(range(2),repeat=5): v = V[integer(b)] put(((0,)*t,(0,b,(0,)*t)),np.sqrt(w0)*v) for mask in it.product(range(2),repeat=t): d = tuple(b[j]+1 if mask[j] else 0 for j in range(t)) f = tuple(0 if mask[j] else b[j]+1 for j in range(t)) z = np.sqrt(1-w0)*np.prod([ np.sqrt(gamma[j] if mask[j] else 1-gamma[j]) for j in range(t)]) put((d,(1,b[t:],f)),z*v) dk = list(it.product(range(3),repeat=t)) ek = sorted(e for d,e in entries) dl,el = 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 (d,e),v in entries.items(): A[dl[d],el[e]] += v return A,dk

    B12 = kron(H,I)@kron(SD,I)@CX@kron(I,H) R0 = H@SD

    def parity(A,O,P): return sum((np.trace((np.eye(len(A))+z*O)@A/2)*(I+z*P)/2 for z in (-1,1)),np.zeros((2,2),complex))

    def full_decode(A,odd): early = B12@(CZ if odd else np.eye(4)) out = np.zeros((2,2),complex) for t,s in it.product(range(2),repeat=2): C = np.linalg.matrix_power(X,1-t)@np.linalg.matrix_power(Z,1-s) K = C@R0@kron(early[2*t+s][None,:],I) out += K@[email protected]().T return out

  • sectionComputational supplementComputational supplement · lines 1592–1654
    Open as its own page

    def benchdecode(A,dk,odd=False,low=False): lookup = d:i for i,d in enumerate(dk) out = np.zeros((2,2),complex) for count in range(4): for S in it.combinations(range(3),count): ix = [] for b in it.product(range(2),repeat=count): d = [0]*3 for j,z in zip(S,b): d[j] = z+1 ix.append(lookup[tuple(d)]) B = A[np.ix_(ix,ix)] if S==(0,1,2): out += parity(B,-kron(Z,X,Z),X) if low else full_decode(B,odd) elif odd and S==(1,2): out += parity(B,-kron(X,Z),X) elif odd and S==(0,2): out += parity(B,-kron(Y,Y),Z) else: out += dep(B) return out

    def benchmark_audit(): U,V = encoder() F3 = embed(CZ,(0,1),3) Vo = kron(F3,np.eye(4))@V check("encoder",V.conj().T@V,I) words = [-kron(Z,X,Z),-kron(X,Y,X),-kron(Y,Z,Y)] oddwords = [-kron(I,X,Z),kron(Y,X,X),-kron(Y,I,Y)] for k,(P,Q) in enumerate(zip((X,Y,Z),words)): check("logical_"+str(k),U.conj().T@kron(I,P,I)@U,Q) check("odd_logical_"+str(k),F3@Q@F3,oddwords[k]) omega = np.block([[ptrace(V[:,a:a+1]@V[:,b:b+1].conj().T, (0,1,2),5) for b in range(2)] for a in range(2)])/2 T = kron(Y,R0,I,R0) smolin = (np.eye(16)+kron(X,X,X,X)+kron(Y,Y,Y,Y)+kron(Z,Z,Z,Z))/16 check("smolin",T@[email protected]().T,smolin) p,qx,qz = .75*.5*(2/3)*.75, .75*.5*(2/3)*.75, .75*.5*(1/3)*.75 r = 1-p-qx-qz for odd,enc in [(False,V),(True,Vo)]: A,dk = benchmark(enc) N = channel(A) check("benchmark_iso_"+str(odd),A.reshape(-1,2).conj()[email protected](-1,2),I) for low in ([False,True] if not odd else [False]): for a,b,E in units(): expected = (p*(E+X@E@X)/2+(1-p)*dep(E)) if low else \ (p*E+qx*(E+X@E@X)/2+qz*(E+Z@E@Z)/2+r*dep(E)) if odd else \ p*E+(1-p)*dep(E) check("bench_channel_ benchdecode(N[a,b],dk,odd,low),expected) v = enc[:,0] later = kron(np.eye(8),CZ)@v for t,target in enumerate((0,1,2,2,1,0)): z = v if t<=3 else later check("turnover_ np.array(entropy(ptrace(np.outer(z,z.conj()),range(t),5))), np.array(float(target))) save("benchmark",U=U,V=V,Vo=Vo,A=A) A,dk = benchmark(V) return channel(A),.75*(1-p)

  • sectionComputational supplementComputational supplement · lines 1654–1734
    Open as its own page

    def loss_domain_audit(): K,c = 4,3 sets = [()] for k in range(1,c+1): sets += [tuple(sorted(S,reverse=True)) for S in it.combinations(range(1,K+1),k) if max(S)-min(S)+1<=c] cfg = [(S,b) for S in sets for b in it.product(range(2),repeat=len(S))] M = 1+K+sum((K-d)*2**(d-1) for d in range(1,c)) D = 1+2*K+sum((K-d)*4*3**(d-1) for d in range(1,c)) need(len(sets)==M and len(cfg)==D,"loss-domain count") need((3,1) in sets,"missing nonconsecutive input") ix = z:i for i,z in enumerate(cfg) omega = 1:1.,2:2.,3:3.,4:5. gamma = r:.2+.12*r for r in range(1,K+1) A = np.zeros((D*D,D),complex) for col,(S,b) in enumerate(cfg): for mask in it.product(range(2),repeat=len(S)): ds = tuple(r for r,z in zip(S,mask) if z) fs = tuple(r for r,z in zip(S,mask) if not z) db = tuple(a for a,z in zip(b,mask) if z) fb = tuple(a for a,z in zip(b,mask) if not z) amp = np.prod([np.sqrt(gamma[r] if z else 1-gamma[r]) for r,z in zip(S,mask)]) A[ix[ds,db]*D+ix[fs,fb],col] += amp e = np.array([sum(omega[r] for r in S) for S,b in cfg]) eo = (e[:,None]+e[None,:]).reshape(-1) check("full_loss_domain_isometry",A.conj().T@A,np.eye(D)) check("nonuniform_loss_energy",eo[:,None]*A,A*e[None,:]) save("loss_domain",scattering=A,energy=e)

    def put(out,key,v): # Exact-zero optimization only: no nonzero amplitude is truncated. if np.any(v!=0): out[key] = out.get(key,np.zeros(2,complex))+v

    def localized(K,ell=0): J = np.zeros((2**K,2),complex) for m in range(2): J[m,m] = 1 U = np.eye(2**K,dtype=complex) for edge in range(K-2,K-ell-2,-1): U = embed(SW,(edge,edge+1),K)@U return U@J

    def initial(J,K): return ((K,bits(i,K)),(),()):J[i] for i in range(2**K) if np.any(J[i]!=0)

    def advance(entries,j,law,U,gamma): out = {} for ((n,b),dh,fh),v in entries.items(): G = U.get((j,n),np.eye(2**n,dtype=complex)) for a in range(2**n): z = G[a,integer(b)] if n else 1 if z==0: continue bb = bits(a,n) for k,p in enumerate(law[n]): if p==0: continue modes = tuple(range(n,n-k,-1)) for mask in it.product(range(2),repeat=k): dp = tuple((r,x) for r,x,s in zip(modes,bb[:k],mask) if s) fp = tuple((r,x) for r,x,s in zip(modes,bb[:k],mask) if not s) amp = z*np.sqrt(float(p))*np.prod([ np.sqrt(gamma(j,r) if s else 1-gamma(j,r)) for r,s in zip(modes,mask)]) put(out,((n-k,bb[k:]),dh+(dp,),fh+(fp,)),amp*v) return out

    def dense(entries): dk = sorted(d for core,d,f in entries) ek = sorted((core,f) for core,d,f in entries) 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 (core,d,f),v in entries.items(): A[di[d],ei[core,f]] += v return A,dk,ek

  • sectionComputational supplementComputational supplement · lines 1734–1814
    Open as its own page

    def labels(d): return tuple(tuple(r for r,a in p) for p in d)

    def blocks(M,dk): groups = {} for i,d in enumerate(dk): groups.setdefault(labels(d),[]).append(i) for lab,ix in groups.items(): e = sum(map(len,lab)) B = np.zeros((2**e,2**e),complex) bi = i:integer([a for p in dk[i] for r,a in p]) for i in ix for i in ix: for j in ix: B[bi[i],bi[j]] += M[i,j] yield lab,B

    def core_density(entries): ck = sorted(core for core,d,f in entries) ci = c:i for i,c in enumerate(ck) rk = sorted((d,f) for core,d,f in entries) ri = r:i for i,r in enumerate(rk) A = np.zeros((len(ck),len(rk)),complex) for (core,d,f),v in entries.items(): A[ci[core],ri[d,f]] += v[0] C = [email protected]().T s = np.linalg.svd(A,compute_uv=False)**2 emitted_entropy = float(-sum(x*np.log2(x) for x in s if x>1e-12)) return C,ck,emitted_entropy

    def popstep(pi,law): q = [F(0)]*len(pi) for n,p in enumerate(pi): for k,r in enumerate(law[n]): q[n-k] += p*r return q

    def transport_decode(M,dk,target,retain,t): out = np.zeros((2,2),complex) for lab,B in blocks(M,dk): positions = [i for i,r in enumerate([r for S in lab for r in S]) if r==target] if not positions: out += dep(B) continue e = sum(map(len,lab)) R = ptrace(B,positions,e) j = next(j for j,S in enumerate(lab) if target in S) out += R if retain or j==t-1 else (R+Z@R@Z)/2 return out

    def transport_ledger(lab,target,retain,h): """S0 final direct-return path is not logged as preparation.""" q,live,held,record = h+1,0,False,False events,peak = [],0 for j,S in enumerate(lab): live += q peak = max(peak,live) events.append(["arrival",j,live]) live -= h if target in S and (retain or j==len(lab)-1): held = True events.append(["retain_target",j,live]) else: if target in S: record = True events.append(["Z_target_readout",j,live]) live -= 1 events.append(["consume_rail_or_dummy",j,live]) if held: events.append(["direct_return",len(lab),live]) live -= 1 else: live += 1 peak = max(peak,live) events.append(["prepare_eigenstate" if record else "prepare_I_over_2", len(lab),live]) live -= 1 need(live==0 and peak<=q+int(retain),"transport occupancy") return "labels":lab,"retain":retain,"events":events,"peak":peak

  • sectionComputational supplementComputational supplement · lines 1814–1852
    Open as its own page

    def transport_audit(): K = 3 law = {0:[F(1)],**n:[F(1,2),F(1,2)] for n in range(1,K+1)} for ell in range(K): entries = initial(localized(K,ell),K) pi = [F(0)]*K+[F(1)] d,target = K-ell,ell+1 for t in range(4): A,dk,ek = dense(entries) check("transport_iso_ A.reshape(-1,2).conj()[email protected](-1,2),I) if t: a = sum(pi[:K-d+1]) b = F(math.comb(t-1,d-1),2**t) if t>=d else F(0) for retain in (False,True): for i,j,E in units(): expected = float(F(3,4)*a)*E+(1-float(F(3,4)*a))*dep(E) \ if retain else float(F(3,4)*b)*E+ \ float(F(3,4)*(a-b))*(E+Z@E@Z)/2+ \ (1-float(F(3,4)*a))*dep(E) check("transport_channel_ transport_decode(channel(A)[i,j],dk,target,retain,t), expected) for lab in sorted(labels(x) for x in dk): DATA["occupancy"].append( transport_ledger(lab,target,retain,2)) if t<3: entries = advance(entries,t+1,law,{},lambda j,r:.75) pi = popstep(pi,law) entries = initial(localized(3),3) for j in (1,2): entries = advance(entries,j,law,{},lambda j,r:1.) A,dk,ek = dense(entries) d1,d2 = (((3,0),),()),((),((3,0),)) check("temporal_coherence", np.array(channel(A)[0,0][dk.index(d1),dk.index(d2)]), np.array(.25+0j))

  • sectionComputational supplementComputational supplement · lines 1852–1949
    Open as its own page

    def stream_ops(e,m): """Kraus maps for A/B/C on actual occupied rails, in arrival order.""" branches = [(np.eye(2**e,dtype=complex),0,None,[])] for pos in range(e): nxt = [] for T,k,last,rec in branches: rem = e-pos n = k+rem if k<m: nxt.append((T,k+1,last,rec)) continue if m==1: T = embed(CX,(0,k),n)@T T = embed(H,(k,),n)@T elif m==2: T = embed(CX,(0,k),n)@T T = embed(CZ,(1,k),n)@T T = embed(H,(k,),n)@T A = T.reshape(2**k,2,2**(rem-1),2**e) for z in range(2): P = A[:,z,:,:].reshape(2**(k+rem-1),2**e) if m: G = Z if m==1 else X if z: P = embed(G,(0,),k+rem-1)@P nxt.append((P,k,z,rec+[["incoming",pos,z]])) branches = nxt out = [] for T,k,last,rec in branches: if k==2: T = kron(I,H)@CX@T for z in range(2): P = T.reshape(2,2,2**e)[:,z,:] if z: P = Z@P out.append((P,rec+[["final_memory",z]])) elif k==1: out.append((T,rec)) elif last is None: for z in range(2): out.append((I[:,z:z+1]@T/np.sqrt(2),rec+[["coin",z]])) else: out.append((I[:,last:last+1]@T,rec)) return out

    def stream_decode(M,dk,m): out = np.zeros((2,2),complex) for lab,B in blocks(M,dk): for K,rec in stream_ops(int(round(np.log2(len(B)))),m): out += K@[email protected]().T return out

    def stream_ledger(lab,m,h,rec): live,held,peak,events = 0,0,0,[] for j,S in enumerate(lab): live += h+1 peak = max(peak,live) events.append(["arrival",j,live]) live -= h if not S: live -= 1 events.append(["consume_vacuum_dummy",j,live]) elif held<m: held += 1 events.append(["retain_incoming",j,live]) else: events.append(["readout_incoming_and_feedback",j,live]) live -= 1 if held==2: live -= 1 held = 1 events.append(["final_memory_readout_feedback",len(lab),live]) if held: live -= 1 events.append(["return",len(lab),live]) else: live += 1 peak = max(peak,live) events.append(["prepare_and_return",len(lab),live]) live -= 1 need(live==0 and peak<=h+1+m,"stream occupancy") return "labels":lab,"m":m,"outcomes":rec,"events":events,"peak":peak

    def history_unitary(lab,K,U): B,e = np.eye(2**K,dtype=complex),0 for j,S in enumerate(lab,1): n = K-e if S: need(tuple(S)==tuple(range(n,n-len(S),-1)), "complete collection has wrong interval") G = U.get((j,n),np.eye(2**n,dtype=complex)) if n: B = embed(G,range(e,K),K)@B e += len(S) need(e==K,"incomplete inverse history") return B

  • sectionComputational supplementComputational supplement · lines 1949–2021
    Open as its own page

    def collect_decode(M,dk,K,U): out = np.zeros((2,2),complex) for lab,A in blocks(M,dk): modes = [r for S in lab for r in S] need(len(modes)==len(set(modes)),"repeated emitted mode") if len(modes)==K: B = history_unitary(lab,K,U) R = B.conj().T@A@B out += ptrace(R,(K-1,),K) else: out += dep(A) return out

    def collect_ledger(lab,K,h,c): live,held,peak,events = 0,0,0,[] for j,S in enumerate(lab): live += h+c peak = max(peak,live) events.append(["arrival",j,live]) live -= h+c-len(S) held += len(S) events.append(["label_and_padding_consumed",j,live]) if held==K: live -= K-1 held = 1 events.append(["invert_consume_ancillas",j,live]) if sum(map(len,lab))==K: live -= 1 events.append(["return",len(lab),live]) else: live -= held events.append(["discard_incomplete",len(lab),live]) live += 1 peak = max(peak,live) events.append(["prepare_I_over_2",len(lab),live]) live -= 1 need(live==0 and peak<=h+c+K-1,"collect occupancy") return "labels":lab,"events":events,"peak":peak, "discard_readout_outcomes":"all computational outcomes"

    def multiparticle_audit(): K,c = 3,2 law = 0:[F(1)],1:[F(1,2),F(1,2)], 2:[F(1,2),F(1,4),F(1,4)], 3:[F(1,2),F(1,4),F(1,4)] U = {} for j in (1,2,3): for n in range(1,K+1): G = embed(H,(0,),n) if n>1: G = embed(CZ,(0,1),n)@embed(CX,(0,1),n)@G U[j,n] = G entries = initial(localized(K),K) for j in (1,2,3): entries = advance(entries,j,law,U,lambda j,r:.7+.05*r) A,dk,ek = dense(entries) check("multiparticle_process_iso", A.reshape(-1,2).conj()[email protected](-1,2),I) N = channel(A) p = sum(np.trace(B).real for lab,B in blocks(N[0,0],dk) if sum(map(len,lab))==K) for i,j,E in units(): check("multiparticle_recovery_ collect_decode(N[i,j],dk,K,U),p*E+(1-p)*dep(E)) for lab in sorted(labels(d) for d in dk): DATA["occupancy"].append(collect_ledger(lab,K,3,c)) save("multiparticle_process",A=A,P_all=np.array(p), **{"U_

    def rot(P,t): return np.cos(t/2)*I-1j*np.sin(t/2)*P

  • sectionComputational supplementComputational supplement · lines 2021–2089
    Open as its own page

    def schedule(K,tmax,L,seed,name): rng = np.random.default_rng(seed) U,gates = {},{} for j in range(1,tmax+1): for n in range(1,K+1): A = np.eye(2**n,dtype=complex) for layer in range(2): parity = (j-1+layer) for edge in range(parity,n-1,2): th = rng.uniform(-np.pi,np.pi,4) G = kron(rot(Y,th[0]),rot(Y,th[1]))@CZ@ \ kron(rot(X,th[2]),rot(X,th[3])) if layer<L: A = embed(G,(edge,edge+1),n)@A gates["gate_ gates["theta_ U[j,n] = A check(name+"_U_ save(name+"_gates",**gates,**{"U_ return U

    def spreading(G,n): if n<2: return 0. value = 0. for a,b in it.permutations(range(n),2): A = G.conj().T@embed(X,(a,),n)@G B = embed(Z,(b,),n) C = A@B-B@A value += np.trace(C.conj().T@C).real/(4*2**n) return float(value/(n*(n-1)))

    def cp_solve(problem,name): import cvxpy as cp opts = "eps":1e-7,"max_iters":50000 if SOLVER=="SCS" else {} problem.solve(solver=SOLVER,verbose=False,**opts) DATA["solvers"].append("name":name,"solver":SOLVER, "status":problem.status,"value":None if problem.value is None else float(problem.value), "iterations":problem.solver_stats.num_iters, "solve_time":problem.solver_stats.solve_time) need(problem.status in ("optimal","optimal_inaccurate"),"solver "+name) return float(problem.value)

    def partial_output(A,outdim,indim): return sum((A[a*indim:(a+1)*indim,a*indim:(a+1)*indim] for a in range(outdim)))

    def repaired_decoder(R): vals,V = np.linalg.eigh(herm(R)) P = (V*np.maximum(vals,0))@V.conj().T b = len(R)//2 M = partial_output(P,2,b) vals,V = np.linalg.eigh(herm(M)) if vals.min()<=1e-12: P += 1e-10*np.eye(len(P)) M = partial_output(P,2,b) vals,V = np.linalg.eigh(herm(M)) G = (V*(1/np.sqrt(vals)))@V.conj().T R = kron(I,G)@P@kron(I,G) return herm(R)

    def apply_decoder(R,N): b = len(R)//2 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()

  • sectionComputational supplementComputational supplement · lines 2089–2161
    Open as its own page

    def distance(N,name): import cvxpy as cp J = herm(choi(N)-idchoi()) W = cp.Variable((4,4),hermitian=True) rho = cp.Variable((2,2),hermitian=True) primal = cp.Problem(cp.Maximize(cp.real(cp.trace(J@W))), [W>>0,rho>>0,cp.trace(rho)==1,cp.kron(I,rho)-W>>0]) lo = cp_solve(primal,name+"_diamond_primal") D = cp.Variable((4,4),hermitian=True) lam = cp.Variable() dual = cp.Problem(cp.Minimize(lam), [D>>0,D-J>>0,lam*I-(D[:2,:2]+D[2:,2:])>>0]) hi = cp_solve(dual,name+"_diamond_dual") rv = herm(D.value) shift = max(0.,-mineig(rv),-mineig(rv-J))+1e-9 rv += shift*np.eye(4) upper = float(np.linalg.eigvalsh( herm(partial_output(rv,2,2))).max()) resid = max(0.,-mineig(W.value),-mineig(rho.value), -mineig(np.kron(I,rho.value)-W.value), abs(np.trace(rho.value)-1)) need(resid<=STOL and abs(hi-lo)<=STOL,"diamond numerical gap "+name) save(name+"_distance",J=J,W=W.value,rho=rho.value, Z_raw=D.value,Z_repaired=rv) return "primal":lo,"dual":hi,"repaired_dual":upper, "primal_residual":float(resid),"gap":hi-lo, "certified":False

    def recovery(N,name): import cvxpy as cp b = len(N[0,0]) R = cp.Variable((2*b,2*b),hermitian=True) mats = {} for i,j,E in units(): mats[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(mats[i,j],E) for i,j,E in units())-idchoi() D = cp.Variable((4,4),hermitian=True) lam = cp.Variable() prob = cp.Problem(cp.Minimize(lam), [R>>0,R[:b,:b]+R[b:,b:]==np.eye(b), D>>0,D-J>>0,lam*I-(D[:2,:2]+D[2:,2:])>>0]) estimate = cp_solve(prob,name+"_recovery") raw = R.value rr = max(0.,-mineig(raw), float(np.max(np.abs(partial_output(raw,2,b)-np.eye(b))))) need(rr<=STOL,"raw recovery residual "+name) fixed = repaired_decoder(raw) check(name+"_repaired_TP",partial_output(fixed,2,b),np.eye(b),STOL) need(mineig(fixed)>=-STOL,"repaired decoder positivity") achieved = apply_decoder(fixed,N) achieved_distance = distance(achieved,name+"_recovered")

    C = sum((np.kron(E.T,N[i,j].T)/4 for i,j,E in units()), np.zeros((2*b,2*b),complex)) Yv = cp.Variable((b,b),hermitian=True) dual = cp.Problem(cp.Minimize(cp.real(cp.trace(Yv))), [cp.kron(I,Yv)-C>>0]) cp_solve(dual,name+"_fidelity_dual") Ynum = herm(Yv.value) shift = max(0.,-mineig(np.kron(I,Ynum)-C))+1e-9 Ynum += shift*np.eye(b) lower = max(0.,1-float(np.trace(Ynum).real)) need(lower<=achieved_distance["repaired_dual"]+STOL, "inconsistent recovery bounds") save(name+"_decoder",R_raw=raw,R_repaired=fixed,Y=Ynum, **{"unit_ return "estimate":estimate,"raw_residual":rr, "achieved_distance":achieved_distance, "fidelity_lower_candidate":lower,"certified":False

  • sectionComputational supplementComputational supplement · lines 2161–2196
    Open as its own page

    def solver_audit(benchN,bench_error): tests = [("identity",(a,b):E for a,b,E in units(),0.), ("constant",(a,b):dep(E) for a,b,E in units(),.75), ("dephasing",(a,b):(E+Z@E@Z)/2 for a,b,E in units(),.5), ("flagged_even",benchN,bench_error)] for name,N,target in tests: result = recovery(N,"validation_"+name) check("solver_expected_"+name,np.array(result["estimate"]), np.array(target),STOL) check("solver_achieved_"+name, np.array(result["achieved_distance"]["repaired_dual"]), np.array(target),STOL) DATA["records"].append("validation":name,"result":result)

    def dashboard(entries,pi,K,U,t,name): A,dk,ek = dense(entries) N = channel(A) check(name+"_isometry",A.reshape(-1,2).conj()[email protected](-1,2),I) C,ck,SDF = core_density(entries) actual_pi = np.array([sum(C[i,i].real for i,(m,b) in enumerate(ck) if m==n) for n in range(K+1)]) check(name+"_population",actual_pi,np.array(list(map(float,pi)))) check(name+"_entropy_purity",np.array(entropy(C)),np.array(SDF)) ec = sum(n*float(p) for n,p in enumerate(pi)) ed = sum(N[0,0][i,i].real*sum(len(p) for p in d) for i,d in enumerate(dk)) ef = sum(np.linalg.norm(A[:,i,0])**2*sum(len(p) for p in f) for i,(core,f) in enumerate(ek)) check(name+"_energy",np.array(ec+ed+ef),np.array(float(K))) save(name+"_channel",A=A,core=C,Choi=choi(N)) return A,dk,N,"population":list(map(float,pi)), "emitted_count_distribution":list(reversed(list(map(float,pi)))), "S_core":entropy(C),"S_accessible":entropy(N[0,0]),"S_DF":SDF, "decoupling":decoupling(A),"energy":[ec,ed,ef]

  • sectionComputational supplementComputational supplement · lines 2196–2257
    Open as its own page

    def pilot(K): h = math.ceil(math.log2(K+1)) cases = [("identity",0,0,0),("swap",0,0,K-1)] cases += [("entangling",L,seed,0) for L in (1,2) for seed in (0,1)] for family,L,seed,ell in cases: base = "K U = schedule(K,K,L,seed,base) for r in (F(1),F(1,2)): law = {0:[F(1)],**n:[1-r,r] for n in range(1,K+1)} entries = initial(localized(K,ell),K) pi = [F(0)]*K+[F(1)] for t in range(1,K+1): prev = pi entries = advance(entries,t,law,U,lambda j,r:1.) pi = popstep(pi,law) name = base+"_r A,dk,N,record = dashboard(entries,pi,K,U,t,name) record.update(case=name,K=K,L=L,seed=seed,t=t,r=str(r), family=family,internal_layers=t*L, spreading=sum(float(prev[n])*spreading( U.get((t,n),np.eye(2**n)),n) for n in range(K+1))) record["batch"] = recovery(N,name) record["streaming"] = {} for m in (0,1,2): out = (i,j):stream_decode(B,dk,m) for (i,j),B in N.items() record["streaming"][str(m)] = distance(out,name+"_m"+str(m)) for lab in sorted(labels(d) for d in dk): e = sum(map(len,lab)) ops = stream_ops(e,m) check(name+"_Kraus_ sum((Kx.conj().T@Kx for Kx,rec in ops), np.zeros((2**e,2**e),complex)), np.eye(2**e)) for Kx,rec in ops: DATA["occupancy"].append(stream_ledger(lab,m,h,rec)) outD = (i,j):collect_decode(B,dk,K,U) for (i,j),B in N.items() p = float(pi[0]) for i,j,E in units(): check(name+"_collect_ p*E+(1-p)*dep(E)) record["collect_error"] = .75*(1-p) for lab in sorted(labels(d) for d in dk): DATA["occupancy"].append(collect_ledger(lab,K,h,1)) DATA["records"].append(record) dump()

    def absorption_audit(): K = 5 law = {0:[F(1)],**n:[1-F(1,2**n+1),F(1,2**n+1)] for n in range(1,K+1)} rs = F(1,33) need(F(K)/rs==165 and sum(1/law[n][1] for n in range(1,K+1))==67, "absorption means") pi = [F(0)]*K+[F(1)] for t in range(20): bound = sum(F(math.comb(t,i))*rs**i*(1-rs)**(t-i) for i in range(min(K-1,t)+1)) need(1-pi[0]<=bound and sum(pi)==1,"absorption tail") pi = popstep(pi,law)

  • sectionComputational supplementComputational supplement · lines 2257–2332
    Open as its own page

    def compile_tex(tex): tex = Path(tex).resolve() need(tex.exists(),"missing TeX source") target = ROOT/tex.name shutil.copy2(tex,target) for run in (1,2): p = subprocess.run(["pdflatex","-interaction=nonstopmode", "-halt-on-error",target.name], cwd=ROOT,stdout=subprocess.PIPE, stderr=subprocess.STDOUT,text=True) (ROOT/("pdflatex_run_ need(p.returncode==0,"pdfLaTeX failure") need((ROOT/(tex.stem+".pdf")).exists(),"missing compiled PDF")

    def main(): global ROOT,SOLVER parser = argparse.ArgumentParser() parser.add_argument("–mode",choices=("audit","pilot","extend"),default="audit") parser.add_argument("–solver",default="SCS") parser.add_argument("–tex") parser.add_argument("–compile",action="store_true") args = parser.parse_args() SOLVER = args.solver stamp = datetime.datetime.now(datetime.timezone.utc).strftime(" ROOT = Path("en02d_v4_"+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__,"solver":SOLVER, "audit_tolerance":TOL,"solver_tolerance":STOL, "source_sha256":hashlib.sha256(source.read_bytes()).hexdigest(), "synthetic":True,"formal_certificate":False path = ROOT/"manifest.json" path.write_text(json.dumps(manifest,indent=2)) try: benchN,expected = benchmark_audit() loss_domain_audit() transport_audit() multiparticle_audit() absorption_audit() for e in range(5): for m in range(3): ops = stream_ops(e,m) check("generic_stream_Kraus_ sum((A.conj().T@A for A,rec in ops), np.zeros((2**e,2**e),complex)),np.eye(2**e)) if args.mode!="audit": import cvxpy manifest["cvxpy"] = cvxpy.__version__ manifest["installed_solvers"] = cvxpy.installed_solvers() need(SOLVER in cvxpy.installed_solvers(),"solver not installed") solver_audit(benchN,expected) pilot(3) if args.mode=="extend": pilot(4) if args.compile: need(args.tex is not None,"–compile requires –tex") compile_tex(args.tex) elif args.tex: shutil.copy2(Path(args.tex),ROOT/Path(args.tex).name) dump() manifest["status"] = "NUMERICAL_CHECKS_AND_COMPILATION_PASSED" \ if args.compile else "NUMERICAL_CHECKS_PASSED_COMPILATION_NOT_RUN" manifest["scope"] = "finite floating-point regression; not certified optimum" except BaseException: dump() (ROOT/"failure.txt").write_text(traceback.format_exc()) manifest["status"] = "FAILED" path.write_text(json.dumps(manifest,indent=2)) raise finally: manifest["artifact_sha256"] = { f.name:hashlib.sha256(f.read_bytes

  • sectionComputational supplementComputational supplement · lines 2332–2341
    Open as its own page

    ()).hexdigest() for f in ROOT.iterdir() if f.is_file() and f.name!="manifest.json"} path.write_text(json.dumps(manifest,indent=2)) print(ROOT) print(manifest["status"])

    if __name__=="__main__": main()

Interpretation of the archive

  • sectionInterpretation of the archiveInterpretation of the archive · lines 2342–2367
    Open as its own page

    Occupation-label blocks are used only inside the explicitly occupation-measuring decoders. The simulator itself adds amplitudes whenever final physical basis states coincide. The unrestricted SDP receives the coherent channel before occupation pinching.

    Resource logs for destructive discards can quotient outcomes that have identical occupancy; the channel computation still includes the full trace over all discarded outcomes. For A–C, the supplement constructs explicit Kraus maps and checks their completeness on every occupied-rail input space.

    The multiparticle regression uses , vacuum, one- and two-constituent probabilities, entangling internal Clifford gates, and partial transmission. The scattering-domain regression separately includes every loss-closed input, with constituent energies .

    A passing finite archive would not prove the universal analytical memory lower bounds, interval-certified SDP feasibility, a physical spectral model, or an ensemble scaling law.

Declarations

  • sectionDeclarationsDeclarations · lines 2368–2390
    Open as its own page

    interests. The author declares no competing interests.

    . No specific grant supported this work.

    contribution. N.C.\ developed the finite-model specification and manuscript. Analytical statements and computational acceptance conditions are distinguished in the text.

    and code availability. All formulas and the computational supplement are included. No executed archive, numerical dynamics dataset, solver certificate, or compilation log is asserted in this version.

    . Not applicable.

  • bibliographyReferencesDeclarations · lines 2391–2486
    Open as its own page

    HP

    P. Hayden and J. Preskill, Black holes as mirrors: quantum information in random subsystems, Journal of High Energy Physics 2007(09), 120 (2007). arXiv:0708.4025v2. doi:10.1088/1126-6708/2007/09/120.

    Piroli

    L. Piroli, C. Sünderhauf, and X.-L. Qi, A Random Unitary Circuit Model for Black Hole Evaporation, Journal of High Energy Physics 2020(04), 063 (2020). arXiv:2002.09236v2. doi:10.1007/JHEP04(2020)063.

    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.

    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.

    Nahum

    A. Nahum, S. Vijay, and J. Haah, Operator spreading in random unitary circuits, Physical Review X 8, 021014 (2018). arXiv:1705.08975v2. doi:10.1103/PhysRevX.8.021014.

    AaronsonGottesman

    S. Aaronson and D. Gottesman, Improved simulation of stabilizer circuits, Physical Review A 70, 052328 (2004). arXiv:quant-ph/0406196v5. doi:10.1103/PhysRevA.70.052328.

    Winnel

    M. S. Winnel, J. J. Guanzon, N. Hosseinidehaj, and T. C. Ralph, Achieving the ultimate end-to-end rates of lossy quantum communication networks, npj Quantum Information 8, 129 (2022). arXiv:2203.13924. doi:10.1038/s41534-022-00641-0.

    Fletcher

    A. S. Fletcher, P. W. Shor, and M. Z. Win, Optimum quantum error recovery using semidefinite programming, Physical Review A 75, 012338 (2007). arXiv:quant-ph/0606035. doi:10.1103/PhysRevA.75.012338.

    WatrousSDP

    J. Watrous, Semidefinite programs for completely bounded norms, Theory of Computing 5, 217–238 (2009). arXiv:0901.4709. doi:10.4086/toc.2009.v005a011.

    WatrousBook

    J. Watrous, The Theory of Quantum Information, Cambridge University Press, 2018.

    Hawking

    S. W. Hawking, Particle creation by black holes, Communications in Mathematical Physics 43, 199–220 (1975). doi:10.1007/BF02345020.

    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 software article: European Physical Journal C 79, 693 (2019). doi:10.1140/epjc/s10052-019-7161-1.

    CVXPY

    CVXPY developers, Official documentation: Advanced Constraints and Solver Features. Documentation consulted for complex Hermitian variables, semidefinite constraints, and solver-specific invocation. Installed software versions are to be recorded by the supplement; no particular installed version or executed solver run is asserted.