All manuscripts

Manuscript Psy04-A@1 · Psy04-A-v1.tex · d5800e2a

Psy04-A Delayed Random Access and Bounded Classical-Memory Exclusion: Sequential Qubit Benchmarks, Complete-Record Certificates, and the Environmental-Memory Boundary

Export Psy04-A-v1.tex

Specifies version 1 of a delayed random-access and bounded classical-memory exclusion framework. ass:boundary states the complete storage and access boundary. lem:deterministic reduces randomized strategies to deterministic tables. thm:classical proves the established sharp two-state success bound of three quarters. thm:quantumattainment and thm:quantumoptimal give the standard one-qubit value, with a sequential encoding that uses only the current bit and the qubit. thm:delay gives the depolarizing retention threshold. thm:robustgap, thm:fixedtest, and thm:anytime give complete-record robustness and finite-sample exclusion, including a history-conditional extension. thm:covering states the finite-capacity Hamming problem. thm:nonentailment records that a Markovian qubit can win the task and that a persistent classical register can create causal-break history dependence, so the witness does not certify quantum environmental memory. thm:release is the analytical release. The classical bound and the qubit code are established benchmarks, not new discoveries. Psy01-A, Psy02-A, Psy02-B, Psy03-A, Psy03-B, Psy03-C, Psy03-D, Em06-B, Em04-A, Em05-A, VII-J, and En01-B are documentary source records and are not premises. No newly executed numerical ranking is asserted. This is not a derivation of a cognitive construct, not a biological treatment mechanism, not neuronal quantum viability, and not conscious experience. This is not metric reconstruction, not Einstein dynamics, not holographic identification, not a Page curve, and not spacetime emergence. The inherited full characteristic map is not constructed. It does not repair XI-G. It does not close O.1. O.1 stays NOT_CLOSED. The series Route B is not discharged. XVI-N is not discharged. XV-B is not opened. XVI-P is registered and is not a premise. H2, I3, and J2 stay unresolved. Full spacetime emergence is not constructed. No quantum coefficient is admitted. No compilation is asserted. Numerical execution is not asserted. Independent execution is not asserted.

Front matter

  • abstractAbstractFront matter · lines 120–158
    Open as its own page

    We formulate a delayed random-access experiment in which two fresh uniform bits are encoded before an independent query specifies which bit must be returned. The complete input-dependent classical state accessible at decoding is restricted to two values. We independently prove the established sharp classical success bound of three quarters, allowing stochastic encoding, delay dynamics, decoding, and input-independent shared randomness. The standard one-qubit code attains . An explicit sequential encoding uses only the current input bit and the qubit. We prove the optimal qubit bound for arbitrary binary measurements and derive exact depolarizing-delay formulas. Failure and erasure records receive neutral scores and remain in the attempted-run law. Complete-law and reference-stable implementation allowances give a robust separation from an enlarged classical null. A one-sided finite-sample rejection certificate is proved, including a history-conditional extension permitting across-run memory under a fresh current-run bottleneck. The general finite-state classical optimum is expressed as a Hamming quantization problem, with an explicit covering upper certificate and exhaustive-verification specifications. A separate classical-environment null is defined for an already quantum carrier. A Markovian qubit can violate the wholly classical bound, while a persistent classical register can create causal-break history dependence. Accordingly, the present witness does not certify quantum environmental memory. The contribution is the sequential specification, complete resource accounting, robustness ledger, and statistical assembly, not discovery of the random-access-code benchmark. No experiment, biological correspondence, asymptotic computational advantage, spacetime emergence, or inherited field-theoretic admission is asserted.

  • sectionFront matterFront matter · lines 158–164
    Open as its own page

    Keywords: random access codes; bounded memory; delayed queries; sequential encoding; complete records; dimension assumptions; quantum memory; classical environments; concentration.

Question, contribution, and proof boundary

  • sectionQuestion, contribution, and proof boundaryQuestion, contribution, and proof boundary · lines 166–250
    Open as its own page

    The central question is:

    Can an accessible record violate a proved bound for every processor in a declared bounded classical-memory class?

    Random access codes provide an established affirmative benchmark: two classical bits encoded in one classical bit have optimal average retrieval probability , whereas one qubit attains AmbainisRAC. These inequalities and the standard qubit encoding are not new discoveries.

    The present contribution is an explicit delayed and sequential architecture, complete storage accounting, attempted-run scoring, implementation-error allowances, and statistical exclusion criteria. All positive results needed for this assembly are proved for the objects printed below.

    different exclusion questions. We distinguish:

    1. exclusion of a wholly classical processor whose complete current-input-dependent retained state has a specified finite cardinality;

    2. exclusion of a classical environmental memory when the visible carrier is already quantum.

    The first question is answered by the benchmark developed here. The second requires a different multitime null class and witness.

    Roy and colleagues study sequential prepare-transform-measure random access codes with an already quantum carrier and constraints on intermediate instruments RoySequential. Their environmental-memory question is not the same as the single-receiver delayed-storage question in this manuscript.

    to Cheung's series. Cheung's computational intervention and recurrent-network articles motivate careful separation of implementation, observation, and interpretation CheungModes,CheungOCD. Neither article implements the present random-access experiment or supplies its memory-capacity hypothesis.

    Psy01-A treats observation and statistical certificates CheungPsy01A. Psy02-A and Psy02-B distinguish channels, complete records, and mechanism identification CheungPsy02A,CheungPsy02B. Psy03-A separates intervention budgets CheungPsy03A; Psy03-B separates persistent classical memory from a quantum-memory resource CheungPsy03B; Psy03-C distinguishes carrier forgetting from retained structural labels CheungPsy03C; Psy03-D places observability before adaptation claims CheungPsy03D.

    These manuscripts are documentary and methodological predecessors, not unexplained premises. No identity between their carriers and the present memory is assumed.

    boundary. The manuscript contains analytic proofs and unexecuted verification specifications. It reports no new experimental or numerical result. Compilation, software execution, calibration, machine proof checking, and biological validation remain separate activities.

    of exclusion. A finite-sample rejection excludes the conjunction of the declared capacity, access, freshness, and error assumptions at its stated error level. It does not establish those assumptions from the score alone or rule out an unrestricted classical simulator.

The admitted delayed-query experiment

  • sectionOne attempted runThe admitted delayed-query experiment › One attempted run · Psy04-A@1#eq:witness · lines 254–288
    Open as its own page

    Each attempted run has the following order:

    1. Independently sample uniform bits

    2. Supply the bits to an encoder, either together or at two distinct encoding times.

    3. Enforce a storage boundary after the last encoding operation.

    4. Apply a declared delay.

    5. Only after encoding and storage, independently sample

    6. Supply to the decoder and record its answer .

    The ideal binary score is

    Its population expectation is

    The experimenter retains for scoring. That record is inaccessible to the device's decoder. Only one query is scored per independently encoded run.

  • assumptionAssumption: Complete storage and access boundaryThe admitted delayed-query experiment › One attempted run · Psy04-A@1#ass:boundary · lines 289–306
    Open as its own page

    For the wholly classical comparison:

    1. conditional on an input-independent random resource , the complete retained state available to decoding has at most classical values;

    2. no additional current-input-dependent register, record, timing signal, parameter change, or environment can influence decoding except through that state;

    3. is independent of the fresh , and does not become an uncounted current-input-dependent storage variable;

    4. the query is not accessible during encoding;

    5. the scoring record is not accessible to decoding.

    The main benchmark uses .

  • sectionOne attempted runThe admitted delayed-query experiment › One attempted run · lines 306–312
    Open as its own page

    The bound concerns the joint retained information, not merely the marginal state of a named carrier. Input-dependent correlations with another accessible system must be accounted for.

  • sectionThe classical factorizationThe admitted delayed-query experiment › The classical factorization · Psy04-A@1#eq:classicalfactor · lines 313–339
    Open as its own page

    Under Assumption ass:boundary, the binary response law has the form

    The kernels are arbitrary stochastic kernels.

    A -state delay with kernel is absorbed into

    More complicated delay dynamics are admitted whenever their complete decoder-accessible outcome still satisfies (eq:classicalfactor). An uncounted input-dependent delay record does not satisfy the stated boundary.

  • remarkRemark: Probabilities are not extra observable memoryThe admitted delayed-query experiment › The classical factorization · lines 340–349
    Open as its own page

    A two-state random variable with arbitrary probabilities is allowed. The decoder receives its realized value, not an exact numerical description of .

    Granting the latter as an additional observable can encode more information than two realized classical states. It defines a different resource class.

  • propositionProposition: Early-query and side-channel counterexamplesThe admitted delayed-query experiment › The late query is essential · Psy04-A@1#prop:loopholes · proof attached · lines 353–370
    Open as its own page

    The bound need not hold if the storage or access boundary is changed. In particular:

    1. if is known before encoding, one classical bit can store and succeed with probability one;

    2. if a one-bit carrier stores and an uncounted accessible register stores , success is one;

    3. an unrestricted exact-valued classical state can store the entire input and succeed with probability one.

    Proof. Use the indicated stored value at decoding.

  • sectionThe late query is essentialThe admitted delayed-query experiment › The late query is essential · lines 370–376
    Open as its own page

    A dimension label on one physical component is not a complete capacity certificate. Likewise, a digital simulation of a qubit using several real-valued variables is not a two-state classical memory.

Reduction to deterministic classical strategies

  • lemmaLemma: Randomized strategies are mixtures of deterministic tablesReduction to deterministic classical strategies · Psy04-A@1#lem:deterministic · proof attached · lines 380–412
    Open as its own page

    For finite input, memory, query, and answer alphabets, every law of the form (eq:classicalfactor) is a mixture of deterministic encoding and decoding strategies, with mixture randomness independent of .

    Consequently a score upper bound valid for every deterministic strategy is valid for arbitrary local and shared randomness in the admitted class.

    Proof. Condition first on . For each possible input , independently sample an encoding-table entry from . For each possible pair , independently sample a decoding-table entry from . Sample these complete tables before the fresh input is used.

    Each realization gives deterministic functions

    Averaging the table entries reproduces the two kernels and their composed law. Average also over .

    The expected score of a mixture is the mixture of its expected scores. It cannot exceed a common deterministic upper bound.

  • sectionReduction to deterministic classical strategiesReduction to deterministic classical strategies · lines 412–418
    Open as its own page

    This finite-table argument permits arbitrary stochastic strategies, not only a particular pseudorandom implementation. It is the elementary convexity reduction underlying the random-access-code benchmark AmbainisRAC.

The sharp two-state classical benchmark

  • sectionThe sharp two-state classical benchmarkThe sharp two-state classical benchmark · lines 420–432
    Open as its own page

    For a deterministic decoder, define one answer word per memory value:

    If is encoded as , its success averaged over the late query is

  • theoremTheorem: Sharp bounded classical-memory exclusion benchmarkThe sharp two-state classical benchmark · Psy04-A@1#thm:classical, Psy04-A@1#eq:classicalbound · proof attached · lines 433–470
    Open as its own page

    For every admitted classical processor with ,

    The bound permits arbitrary stochastic encoding, classical delay dynamics, decoding, and input-independent shared randomness.

    It is attained by a sequential one-bit implementation.

    Proof. By Lemma lem:deterministic, it suffices to consider deterministic tables. For fixed decoder words, the encoder cannot do better than choose a closest word:

    There are four inputs and at most two distinct answer words. At least two inputs are not answer words, and each has distance at least one. The distance sum is therefore at least two, giving .

    For attainment, store when it arrives, leave that state unchanged when arrives, and return the stored bit for query 1. For query 2, return a fixed bit or an independent fair guess. The success is

  • sectionThe sharp two-state classical benchmarkThe sharp two-state classical benchmark · lines 470–476
    Open as its own page

    The inequality is an established RAC benchmark AmbainisRAC. The present proof is included to make the exact alternative class and average-score convention explicit.

  • remarkRemark: Average, not pointwise, classical boundThe sharp two-state classical benchmark · lines 477–486
    Open as its own page

    A classical strategy can succeed with probability one on some input-query pairs. Equation (eq:classicalbound) concerns their fresh uniform average.

    For statistical testing, the relevant conditional expectation is taken before the current run's fresh , not after conditioning on their particular values.

  • propositionProposition: Classical delay cannot create a retrieval advantageThe sharp two-state classical benchmark · Psy04-A@1#prop:classicaldelay · proof attached · lines 488–501
    Open as its own page

    For a fixed encoder and admitted classical delay, the best post-delay decoding score is no larger than the best score available from the encoder's pre-delay memory state.

    Proof. A decoder receiving the pre-delay state can simulate the delay kernel internally and then apply any post-delay decoder. Thus the pre-delay optimization includes every such strategy.

  • sectionThe sharp two-state classical benchmarkThe sharp two-state classical benchmark · lines 501–506
    Open as its own page

    The classical benchmark allows a perfect delay. A noisy qubit is compared against that conservative null, not against an automatically equally noisy classical device.

A sequential one-qubit construction

  • sectionEncoding and complete readoutA sequential one-qubit construction › Encoding and complete readout · Psy04-A@1#eq:encoding · lines 510–544
    Open as its own page

    Let

    For , prepare

    Its Bloch vector has length one, so it is a pure density operator.

    For query , use projectors

    The complete projective instrument is

    Its branches are completely positive and their sum preserves trace.

  • theoremTheorem: Standard qubit attainment with sequential encodingA sequential one-qubit construction › Encoding and complete readout · Psy04-A@1#thm:quantumattainment, Psy04-A@1#eq:quantumvalue · proof attached · lines 545–589
    Open as its own page

    The encoding and readout satisfy, for every ,

    Hence

    The same encoding is obtained from sequentially supplied bits without retaining a classical copy of the earlier bit:

    1. initialize the qubit in ;

    2. apply

    3. apply if .

    Each operation uses only its current bit and the qubit.

    Proof. Born's rule gives

    The first rotation maps the initial Bloch vector to

    Conjugation by preserves the component and reverses the component. The final vector is exactly that of (eq:encoding).

  • sectionEncoding and complete readoutA sequential one-qubit construction › Encoding and complete readout · lines 589–601
    Open as its own page

    The qubit encoding and value are standard AmbainisRAC. The sequential realization is an explicit architecture for the benchmark, not a claim that sequential arrival strengthens the classical bound.

    The encoding control pulses are transient inputs. Any accessible input-dependent pulse log surviving the boundary must be counted as retained information. An input-independent phase reference is a declared control resource, not a copy of the bits.

  • assumptionAssumption: One-qubit quantum comparison classA sequential one-qubit construction › Optimality for arbitrary binary qubit measurements · Psy04-A@1#ass:qubit · lines 604–614
    Open as its own page

    Conditional on input-independent shared classical randomness, the complete input-dependent retained quantum system is a qubit. No additional input-dependent system or preshared entanglement is available to the decoder.

    Fresh decoder ancillas are independent of the encoded input and can be absorbed into a qubit POVM.

  • sectionOptimality for arbitrary binary qubit measurementsA sequential one-qubit construction › Optimality for arbitrary binary qubit measurements · lines 614–619
    Open as its own page

    An ancillary marginal being input independent is not enough: input-dependent correlations with it would enlarge the accessible retained system.

  • theoremTheorem: Sharp qubit upper benchmarkA sequential one-qubit construction › Optimality for arbitrary binary qubit measurements · Psy04-A@1#thm:quantumoptimal · proof attached · lines 620–672
    Open as its own page

    Under Assumption ass:qubit, arbitrary qubit preparations and binary POVMs satisfy

    Theorem thm:quantumattainment attains equality.

    Proof. Condition on the shared classical randomness. Write

    For the two binary measurements, their difference observables have the form

    Since ,

    Set , . The scalar terms cancel in the uniform input average, leaving

    Therefore

    By Cauchy–Schwarz and the parallelogram identity,

    This proves the bound. Average over the shared randomness.

  • sectionOptimality for arbitrary binary qubit measurementsA sequential one-qubit construction › Optimality for arbitrary binary qubit measurements · lines 672–678
    Open as its own page

    This reproduces the known optimal qubit benchmark AmbainisRAC. It concerns average retrieval of one late-selected bit. It does not claim simultaneous recovery of both bits.

Delay-dependent separation

  • sectionDepolarizing storageDelay-dependent separation › Depolarizing storage · Psy04-A@1#eq:depolarizing · lines 682–699
    Open as its own page

    For , define on arbitrary matrices

    This linear map is CPTP: it is a convex mixture of identity and replacement by .

    For steps with possibly different factors , put

  • theoremTheorem: Exact depolarizing retention and optimal scoreDelay-dependent separation › Depolarizing storage · Psy04-A@1#thm:delay, Psy04-A@1#eq:delayscore, Psy04-A@1#eq:delaythreshold · proof attached · lines 700–742
    Open as its own page

    The stored code states are

    The projective decoder gives

    This is also the optimum over all encodings and binary decoders for the specified input-independent depolarizing storage channel.

    Its strict violation of the perfect classical-storage benchmark occurs exactly when

    For constant , .

    Proof. Replacement and identity compose to another depolarizing channel, with multiplicative Bloch factor. Apply Born's rule to the displayed states.

    For arbitrary input Bloch vectors, the proof of Theorem thm:quantumoptimal acquires a common multiplier on its nonconstant term. The same square encoding attains that upper bound. Finally solve

  • corollaryCorollary: Continuous-time storage thresholdDelay-dependent separation › Depolarizing storage · Psy04-A@1#cor:continuous · proof attached · lines 744–764
    Open as its own page

    The generator

    has propagator . For , strict ideal separation survives exactly for

    For , it survives at every finite delay.

    Proof. The identity component is fixed and the traceless component decays as . Apply (eq:delaythreshold).

  • sectionDepolarizing storageDelay-dependent separation › Depolarizing storage · lines 764–770
    Open as its own page

    A nonzero retained Bloch component is not enough to beat the classical benchmark. The threshold concerns task success, not merely existence of a coherence contrast.

  • propositionProposition: Anisotropic storage comparisonDelay-dependent separation › The threshold depends on the channel · Psy04-A@1#prop:anisotropic, Psy04-A@1#eq:anisotropic · proof attached · lines 773–815
    Open as its own page

    Suppose a declared CPTP storage map acts on the relevant Bloch components by

    without adding an affine displacement or mixing these axes.

    For the fixed square encoding and decoder,

    Optimizing preparations while retaining these decoder axes gives

    Thus this restricted optimized comparison exceeds exactly when

    Proof. For the fixed square, the two query advantages are and . Average them.

    For optimized preparations, the variable term in the score is

    Each summand is maximized by a unit vector parallel to , giving the displayed value. At , the value is .

  • sectionThe threshold depends on the channelDelay-dependent separation › The threshold depends on the channel · lines 815–827
    Open as its own page

    Complete positivity is an assumption about the full map; the two coefficients alone do not specify it. No universal storage threshold is inferred from (eq:delaythreshold) outside its isotropic model.

    Changing storage parameters is a specified intervention. For fixed encoding, detector, and failure law, its score effect can be calculated. That is not an invariant intervention dose or a treatment mechanism.

Complete attempted-run records

  • sectionNeutral failure scoringComplete attempted-run records › Neutral failure scoring · Psy04-A@1#eq:neutralscore · lines 831–849
    Open as its own page

    Allow a record

    Define the predeclared score

    Every attempted run has one score. Timeouts and missing outputs need a predeclared record rule; they are not removed after inspection.

  • theoremTheorem: Neutral output failures preserve the classical boundComplete attempted-run records › Neutral failure scoring · Psy04-A@1#thm:abstention · proof attached · lines 850–876
    Open as its own page

    Suppose the complete record kernel factors through the classical state:

    With score (eq:neutralscore),

    The decoder's failure or erasure probability may depend on .

    Proof. Replace every neutral record by an independent fair binary answer. Its expected correctness is , so the expected score is unchanged. This replacement is another stochastic decoder using the same memory. Apply Theorem thm:classical.

  • sectionNeutral failure scoringComplete attempted-run records › Neutral failure scoring · lines 876–882
    Open as its own page

    This theorem does not license an additional input-dependent preparation flag outside the counted storage boundary. It only covers complete record laws with the displayed factorization.

  • exampleExample: Postselection can manufacture apparent perfect successComplete attempted-run records › Neutral failure scoring · lines 883–891
    Open as its own page

    Store , answer query 1, and erase query 2. The observed-answer success is one. The complete score is nevertheless

    Discarding the erased runs changes the estimand.

  • assumptionAssumption: Independent preparation and detector factorsComplete attempted-run records › A specified independent-loss detector · Psy04-A@1#ass:detector · lines 895–907
    Open as its own page

    Preparation succeeds with probability , observation succeeds with probability , and a valid binary answer is flipped with probability . These coins are independent of , the ideal binary outcome, and one another. Here

    Preparation failure and erasure receive neutral scores.

  • sectionA specified independent-loss detectorComplete attempted-run records › A specified independent-loss detector · lines 907–912
    Open as its own page

    The independent flags can be included among the freely allowed input-independent random resources. They do not retain current-input information.

  • theoremTheorem: Exact complete-record scoreComplete attempted-run records › A specified independent-loss detector · Psy04-A@1#thm:detector, Psy04-A@1#eq:recordscore · proof attached · lines 913–940
    Open as its own page

    For the code and storage of Theorem thm:delay, under Assumption ass:detector,

    The ideal complete score exceeds exactly when

    Proof. Conditional on a valid observed outcome, flipping gives

    Valid observed outcomes have probability . All remaining outcomes contribute . Substitute (eq:delayscore).

  • sectionA specified independent-loss detectorComplete attempted-run records › A specified independent-loss detector · lines 940–952
    Open as its own page

    This multiplicative formula must not be transplanted to input-dependent preparation success, outcome-dependent loss, or correlated assignment errors. Such models require their own complete-law calculation.

    Independent preparation failures can be represented by a complete preparation instrument. The projective readout followed by independent erasure and assignment channels is also complete. No failed branch is silently renormalized away.

Robust model and apparatus allowances

  • sectionRobust model and apparatus allowancesRobust model and apparatus allowances · lines 954–964
    Open as its own page

    Use

    The latter is reference stable on common channel spaces Watrous.

  • lemmaLemma: Bounded-score stabilityRobust model and apparatus allowances › Complete-law stability · Psy04-A@1#lem:tv · proof attached · lines 967–983
    Open as its own page

    For probability laws on the same complete record space and any score ,

    Proof. Use the layer-cake representation

    and the defining supremum for total variation.

  • theoremTheorem: Robust family separationRobust model and apparatus allowances › Complete-law stability · Psy04-A@1#thm:robustgap, Psy04-A@1#eq:robustgap, Psy04-A@1#eq:robustthreshold · proof attached · lines 985–1025
    Open as its own page

    Suppose:

    1. an actual quantum complete law is within total variation of the specified law in Theorem thm:detector;

    2. every actual classical null law is within total variation of some complete law satisfying Theorem thm:abstention.

    Then

    Therefore

    is a certified lower separation allowance. A positive value separates the declared families.

    Equivalently, positivity requires

    Proof. Apply Lemma lem:tv to the common score. Subtract the null upper bound from the quantum lower bound and rearrange.

  • sectionComplete-law stabilityRobust model and apparatus allowances › Complete-law stability · lines 1025–1029
    Open as its own page

    Bounds can be truncated to . In the positive-gap regime this does not alter the conclusion.

  • remarkRemark: What e C cannot doRobust model and apparatus allowances › Complete-law stability · lines 1030–1040
    Open as its own page

    The number must certify a discrepancy from the capacity-constrained complete-law class. It cannot stand for an unspecified or unrestricted side channel.

    If the task inputs are not exactly fresh uniform variables, a justified discrepancy may be charged at the input-law interface, provided the complete comparison is proved. The nominal uniform formula alone is then insufficient.

  • corollaryCorollary: Rectangular calibration allowanceRobust model and apparatus allowances › Complete-law stability · Psy04-A@1#cor:calibration · proof attached · lines 1042–1068
    Open as its own page

    Suppose simultaneous calibration gives

    Set

    A sufficient robust gap is

    For correlated calibration sets, rectangular enclosure is a conservative bound, not necessarily their exact optimum.

    Proof. The retained advantage is nondecreasing in each nonnegative factor and nonincreasing in the assignment error. Use the simultaneous endpoints.

  • sectionAn implementation route to e QRobust model and apparatus allowances › An implementation route to e Q · lines 1070–1079
    Open as its own page

    For a complete instrument , its recorded channel is

    The direct sum retains the classical record and unnormalized residual blocks.

  • propositionProposition: Reference-stable implementation ledgerRobust model and apparatus allowances › An implementation route to e Q · Psy04-A@1#prop:channelerrors, Psy04-A@1#eq:generatorbudget · proof attached · lines 1080–1120
    Open as its own page

    Suppose each input preparation has trace-distance error at most , and the successive common-space channels or complete recorded instruments have half-diamond errors . The final complete-law error is at most

    truncated at one.

    For bounded generators with CPTP propagators,

    Proof. Insert intermediate ideal outputs one map at a time. Trace distance contracts under channels, while a half-diamond error bounds every normalized input, including referenced inputs. The triangle inequality gives the telescoping ledger. Final measurement contracts it to total variation.

    For the generator estimate, variation of constants gives

    Channel composition has diamond norm one. Take norms and divide by two Watrous.

  • sectionAn implementation route to e QRobust model and apparatus allowances › An implementation route to e Q · lines 1120–1126
    Open as its own page

    The external references in this correctness statement are not uncounted systems accessible to the RAC decoder. Reference-stable error certification and allowed decoding resources are separate notions.

  • propositionProposition: Rare-branch normalization costRobust model and apparatus allowances › An implementation route to e Q · Psy04-A@1#prop:normalization · proof attached · lines 1127–1151
    Open as its own page

    For positive subnormalized blocks , with traces , suppose

    Then

    Proof. Insert . Since ,

    Divide by two.

  • sectionAn implementation route to e QRobust model and apparatus allowances › An implementation route to e Q · lines 1151–1156
    Open as its own page

    The unconditional score test below needs no such conditioning. A heralded diagnostic cannot reuse an unconditional allowance without paying the normalization cost.

Finite-sample exclusion certificates

  • sectionA conditional exponential boundFinite-sample exclusion certificates › A conditional exponential bound · lines 1160–1165
    Open as its own page

    Let contain the completed record history through attempted run . A run is scored only after its complete record is finalized.

  • lemmaLemma: Conditional bounded-score exponential estimateFinite-sample exclusion certificates › A conditional exponential bound · Psy04-A@1#lem:conditionalmgf, Psy04-A@1#eq:mgf, Psy04-A@1#eq:conditionaltail · proof attached · lines 1166–1220
    Open as its own page

    If and

    then for every real ,

    Consequently, for deterministic and ,

    and the same bound holds for the lower tail.

    Proof. Convexity on gives

    For fixed , define

    It satisfies and

    Integrating twice gives . This proves (eq:mgf), including the endpoint cases.

    Iterate conditional expectation to bound the moment of the centered sum by . Markov's inequality gives

    Optimize at . Use negative for the lower tail. This is the bounded-variable argument underlying Hoeffding's inequality Hoeffding.

  • sectionA conditional exponential boundFinite-sample exclusion certificates › A conditional exponential bound · lines 1220–1225
    Open as its own page

    The independent unit is an attempted run. Encoding stages, storage steps, and repeated observations within that run do not multiply the independent sample count.

  • theoremTheorem: One-sided bounded classical-memory rejectionFinite-sample exclusion certificates › Fixed-sample rejection · Psy04-A@1#thm:fixedtest, Psy04-A@1#eq:rejection · proof attached · lines 1228–1257
    Open as its own page

    Suppose every actual classical null satisfies

    at every attempted run. For a predeclared sample size and , let

    The rejection rule

    has Type-I error at most , uniformly over that null.

    Proof. Because ,

    Apply the upper-tail bound of Lemma lem:conditionalmgf.

  • sectionFixed-sample rejectionFinite-sample exclusion certificates › Fixed-sample rejection · lines 1257–1271
    Open as its own page

    For independent identically distributed runs, is a one-sided lower confidence bound for their common actual mean. For adaptive runs it bounds the average predictable mean , not an automatically stationary population parameter.

    The test uses the observed score and the classical allowance. The design error is not subtracted again from observed data. It supplies a prospective quantum lower mean and power calculation, not an extra penalty on an already measured mean.

  • assumptionAssumption: Fresh current-run bottleneckFinite-sample exclusion certificates › Across-run memory · Psy04-A@1#ass:conditionalboundary · lines 1274–1291
    Open as its own page

    Conditional on each past history:

    1. the next is uniform on ;

    2. the next query is chosen after encoding, uniformly and independently of the current input and retained state;

    3. all current-input-dependent retained information at the query still factors through at most two classical values;

    4. the actual complete-law discrepancy has a predictable allowance .

    Pre-existing device state may be arbitrarily history dependent, but must be independent of the new inputs before they are drawn. Any modification of that state carrying current input information across the boundary is subject to the same storage accounting.

  • corollaryCorollary: History-dependent device exclusionFinite-sample exclusion certificates › Across-run memory · Psy04-A@1#cor:devicememory · proof attached · lines 1293–1314
    Open as its own page

    Under Assumption ass:conditionalboundary,

    For fixed , rejection based on

    has Type-I error at most .

    Proof. Condition on the pre-run state and history. The stochastic classical bound applies to the fresh current-run experiment. Average any hidden pre-run state and apply the conditional complete-law allowance. Then use Lemma lem:conditionalmgf.

  • sectionAcross-run memoryFinite-sample exclusion certificates › Across-run memory · lines 1314–1320
    Open as its own page

    An unconditional long-run mean bound alone does not justify this test. Fresh random inputs, absence of query leakage, and the current-run storage boundary remain essential.

  • propositionProposition: Prospective power certificateFinite-sample exclusion certificates › Power and planned sample size · Psy04-A@1#prop:power, Psy04-A@1#eq:samplesize · proof attached · lines 1323–1355
    Open as its own page

    Suppose an alternative has conditional means

    For the fixed-sample rule (eq:rejection), if , its failure-to-reject probability is at most

    A sufficient sample size for Type-I error at most and failure-to-reject probability at most is

    Proof. If rejection fails,

    Apply the lower-tail bound. The stated sample size ensures

  • sectionPower and planned sample sizeFinite-sample exclusion certificates › Power and planned sample size · lines 1355–1361
    Open as its own page

    One may use only when that allowance is uniform for the actual attempted-run design. A positive ideal gap without calibrated actual-law control does not establish the power hypothesis.

  • theoremTheorem: An explicit anytime-valid certificateFinite-sample exclusion certificates › Optional stopping and multiple settings · Psy04-A@1#thm:anytime · proof attached · lines 1364–1394
    Open as its own page

    Suppose the conditional null bounds hold indefinitely. For , define

    Then

    Thus stopping at the first such crossing is licensed. Repeatedly inspecting the fixed- radius is not licensed by Theorem thm:fixedtest.

    Proof. At each , allocate

    The fixed-sample conditional bound gives failure probability at most . Since , a union bound proves the result.

  • sectionOptional stopping and multiple settingsFinite-sample exclusion certificates › Optional stopping and multiple settings · lines 1394–1407
    Open as its own page

    For multiple delays or intervention settings, allocate confidence across the predeclared tests or assess the selected setting on a fresh block. Choosing a favorable delay after examining its score does not preserve an unadjusted single-test certificate.

    If a prior calibration event has failure probability at most , and the statistical assumptions hold on that pre-assessment event, a union bound gives total false-certificate probability at most .

General finite classical capacity

  • sectionGeneral finite classical capacityGeneral finite classical capacity · lines 1409–1414
    Open as its own page

    Let be uniform on , and let the late query be independent and uniform on . Allow classical memory values.

  • theoremTheorem: Exact batch-encoding finite-capacity formulationGeneral finite classical capacity · Psy04-A@1#thm:covering, Psy04-A@1#eq:covering · proof attached · lines 1415–1448
    Open as its own page

    For arbitrary batch encoding with the complete -state boundary, the classical optimum is

    If , the optimum is one.

    For a more restricted streaming architecture, the right-hand side remains an upper bound, but attainment is not automatic.

    Proof. The deterministic-table reduction applies to the finite -bit task. Every decoder assigns an -bit answer word to each memory value. Its score on input is

    For fixed words, nearest-word encoding attains the best batch score. Optimize the word set and average over uniform inputs.

    A restricted streaming encoder is a subset of the batch encoding class and therefore cannot exceed its optimum.

  • sectionGeneral finite classical capacityGeneral finite classical capacity · lines 1448–1453
    Open as its own page

    This is a finite Hamming quantization problem. It does not assume that an arbitrary optimal batch partition can be implemented by a -state stream processor.

  • propositionProposition: A general covering upper certificateGeneral finite classical capacity · Psy04-A@1#prop:spherebound, Psy04-A@1#eq:spherebound · proof attached · lines 1454–1498
    Open as its own page

    Define the Hamming-ball volume

    Then

    For , the exact values are

    Proof. For any codebook , let . A union of at most balls covers at most points. Therefore

    The integer tail-sum identity gives

    Substitute into (eq:covering).

    For , one codeword has average distance one. Two codewords attain total distance two. Three distinct codewords leave only one input at distance one. Four codewords represent every input exactly. These constructions match the lower distance counts.

  • sectionGeneral finite classical capacityGeneral finite classical capacity · lines 1498–1504
    Open as its own page

    Only three classical states already permit , greater than the one-qubit benchmark. An uncounted additional state can therefore invalidate the intended exclusion.

  • propositionProposition: Exhaustive certificates versus feasible strategiesGeneral finite classical capacity · Psy04-A@1#prop:enumeration · proof attached · lines 1505–1527
    Open as its own page

    For a fixed finite task:

    1. a fully completed exact enumeration of all deterministic admitted strategies gives an exact optimum and hence an upper certificate;

    2. one feasible strategy, including a numerically optimized one, gives a lower bound on the maximum;

    3. a rigorously justified relaxation with a proved upper optimum can certify an upper bound, even if it is not sharp.

    For streaming tasks, the enumerated set must include the exact admitted transition and output rules, not an assumed batch replacement.

    Proof. A maximum over an exhausted finite set is its exact maximum. A feasible element cannot exceed that maximum. A containing relaxation has a maximum at least as large as the original one.

  • sectionGeneral finite classical capacityGeneral finite classical capacity · lines 1527–1533
    Open as its own page

    Numerical convergence of an optimizer is not an upper certificate. A search stopped early cannot report its best-found strategy as the exclusion threshold.

Bounded classical storage is not classical environmental memory

  • theoremTheorem: Non-entailment of quantum environmental memoryBounded classical storage is not classical environmental memory › A Markovian qubit already wins · Psy04-A@1#thm:nonentailment · proof attached · lines 1539–1558
    Open as its own page

    A violation of (eq:classicalbound) in the admitted one-receiver task does not imply quantum non-Markovianity or a quantum-memory environment.

    There is a process with a single qubit, no persistent environmental register, and memoryless storage that attains (eq:quantumvalue).

    Proof. Use Theorem thm:quantumattainment and identity storage. The storage intervals are fixed channels depending only on the current carrier state. Fresh independent ancillas, if used to realize those channels, need not persist across intervals. The winning resource is the retained qubit, not a history-bearing environment.

  • sectionA Markovian qubit already winsBounded classical storage is not classical environmental memory › A Markovian qubit already wins · lines 1558–1563
    Open as its own page

    The result certifies a bounded-storage performance separation from the wholly classical class, conditional on its boundary. It does not locate a physical resource in an environment.

  • definitionDefinition: Finite classical-environment process classBounded classical storage is not classical environmental memory › A separate classical-environment null · Psy04-A@1#def:cqnull · lines 1566–1606
    Open as its own page

    Fix:

    1. a quantum carrier of dimension ;

    2. a classical environmental alphabet ;

    3. a finite schedule and admitted laboratory interventions;

    4. the controller and accessible-record rules.

    Classical–quantum states have the form

    At an environmental update, specify CP maps

    on the carrier, with

    trace preserving for each . The update is

    Dependence on admitted past settings and records must be specified through the declared controller.

    The environment has no independent access to the encoded classical input unless such access is explicitly admitted. Initial environmental information is independent of the fresh input. Laboratory intervention records and persistent feedback are included in the complete process.

  • sectionA separate classical-environment nullBounded classical storage is not classical environmental memory › A separate classical-environment null · lines 1606–1617
    Open as its own page

    This is a physical finite classical-feedback specification: each update is a complete quantum instrument conditional on the prior classical label. It is not the wholly classical factorization (eq:classicalfactor), because the carrier is quantum.

    Let denote the resulting null class, where records the schedule, access, and intervention constraints.

  • propositionProposition: The 3/4 null does not apply to this larger classBounded classical storage is not classical environmental memory › A separate classical-environment null · Psy04-A@1#prop:largernull · proof attached · lines 1618–1634
    Open as its own page

    If permits the code of Theorem thm:quantumattainment and contains no compulsory intermediate disturbance, then

    Thus the classical bound cannot be reused as an environmental-memory exclusion bound for that class.

    Proof. A one-value classical environment is trivial. The winning Markovian qubit process belongs to the null.

  • exampleExample: Carrier-only history dependence from a classical registerBounded classical storage is not classical environmental memory › Classical hidden memory can pass a causal-break test · Psy04-A@1#ex:classicalmemory · lines 1638–1657
    Open as its own page

    Let a persistent hidden classical bit be uniform. Initialize a visible qubit in . Apply , measure in the basis, and record . Then reset the carrier to the same , independently of . Apply the same sector-controlled and measure again.

    Both first histories have probability , and

    The carrier input after the reset is identical in both histories. The retained history dependence is entirely classical, stored in .

  • sectionClassical hidden memory can pass a causal-break testBounded classical storage is not classical environmental memory › Classical hidden memory can pass a causal-break test · lines 1657–1675
    Open as its own page

    All carrier states in this example can remain diagonal. The example supplies no nonclassical environmental resource.

    A classical persistent register can produce a carrier-only causal-break witness. This is the refusal already illustrated by Psy03-B's separately defined scar-register pilot CheungPsy03B. Psy03-C similarly notes that carrier contraction does not erase a distinct persistent register distribution CheungPsy03C.

    Operational history dependence requires multitime intervention records; it is not settled by a one-time channel or one distinguishability curve PollockMarkov,PollockProcess.

  • sectionDirect comparison with sequential RAC literatureBounded classical storage is not classical environmental memory › Direct comparison with sequential RAC literature · Psy04-A@1#tab:nulls · lines 1676–1735
    Open as its own page

    Roy and colleagues consider a three-party prepare-transform-measure QRAC, where an intermediate receiver performs an instrument and the downstream receiver is assessed. Their analysis imposes carrier-dimension and intermediate-measurement assumptions; rank-one projective measurements are central to the sharp-measurement case, with additional analysis for unsharp instruments RoySequential.

    Their comparison concerns quantum versus classical environmental feedback in that multitime setting. Our theorem instead constrains the entire retained processor to classical states and has no intermediate receiver. Their environmental result is therefore not imported into the present single-receiver test.

    null hypotheses require different witnesses.

    FeaturePresent delayed-storage benchmarkEnvironmental-memory question
    Retained carrierTwo classical states under the nullAlready quantum, with declared dimension
    Query/readoutOne late-selected queryMultitime interventions and complete records
    Intermediate instrumentNone requiredSpecified and independently constrained
    Environmental informationIncluded in the classical storage boundarySeparate classical-feedback null
    Meaning of Sharp wholly classical average boundNot automatically an environmental bound
    Possible conclusionBounded classical-class exclusionRequires a new class-specific upper certificate

    Conditioning on an environmental outcome can alter the input ensemble. A branchwise argument cannot replace those conditional input laws by uniform ones without proof. This is another reason not to apply the elementary deterministic-table argument indiscriminately to a quantum-carrier process.

  • definitionDefinition: Environmental-memory exclusion obligationBounded classical storage is not classical environmental memory › What a stronger result would require · lines 1738–1757
    Open as its own page

    A stronger witness must supply:

    1. an exact null , or a justified union over allowed ;

    2. a complete multitime record score ;

    3. a proved upper bound

    4. an admitted quantum-environment construction with

    5. implementation and statistical allowances preserving that strict inequality.

  • sectionWhat a stronger result would requireBounded classical storage is not classical environmental memory › What a stronger result would require · lines 1757–1770
    Open as its own page

    No such new environmental bound is claimed here. Fixing excludes only that declared register class; excluding classical environments of arbitrary size needs a bound uniform over the admitted sizes.

    Once laboratory instruments are fixed, a process witness may be linear in a process representation. That observation does not automatically turn an unrestricted joint optimization over processes, instruments, and classical-memory decompositions into a convex problem. Any relaxation and its upper-bound status must be justified.

Complete-law identifiability and interpretation

  • propositionProposition: Complete-record equality prevents mechanism separationComplete-law identifiability and interpretation · Psy04-A@1#prop:testing · proof attached · lines 1774–1797
    Open as its own page

    For two complete attempted-run laws , every randomized test satisfies

    If the laws are equal, .

    Matching initial states, all conditional interval maps, and complete instruments in an admitted finite Markov schedule gives equal history laws.

    Proof. For a test declaring model 1,

    Apply Lemma lem:tv. For the process statement, induct through equal unnormalized conditional branches.

  • sectionComplete-law identifiability and interpretationComplete-law identifiability and interpretation · lines 1797–1815
    Open as its own page

    This independently states the complete-record identification boundary recorded in Psy02-B and Psy03-A CheungPsy02B,CheungPsy03A. A positive bounded-memory witness separates declared record families; it does not identify a unique hardware mechanism.

    The resource comparison is specifically one classical bit versus one qubit at the retained boundary. It is not a claim about equal energy, thermodynamic cost, control complexity, training cost, or biological memory capacity.

    No correspondence between the qubit, a neural activation, a synaptic coordinate, or a clinical variable is supplied. Nor is an asymptotic speed, query, sample, or computational complexity advantage proved.

Discussion and mathematical release

  • sectionDiscussion and mathematical releaseDiscussion and mathematical release · lines 1817–1836
    Open as its own page

    The advance over a generic history-dependence observation is a bound covering every strategy in a specified alternative class. The necessary class restriction is not optional: uncounted retained information or advance query access can invalidate the result.

    The standard RAC supplies the core separation. Its sequential implementation does not require earlier-bit copies in the mathematical controller. Its delay, complete-record, and statistical certificates remain conditional on their stated assumptions.

    The environmental question has a different boundary. A winning Markovian qubit and a causal-break witness generated by classical hidden memory give explicit counterexamples to two stronger interpretations.

  • theoremTheorem: Psy04-A mathematical releaseDiscussion and mathematical release · Psy04-A@1#thm:release · proof attached · lines 1837–1881
    Open as its own page

    For the objects and hypotheses printed here:

    1. the stochastic classical alternative reduces to mixtures of deterministic encoding-decoding tables;

    2. every complete two-state classical memory satisfies the sharp average bound ;

    3. the standard qubit code has an explicit sequential realization and attains the sharp qubit benchmark ;

    4. depolarizing storage has the exact retention score and threshold in Theorem thm:delay;

    5. neutral attempted-run scoring preserves the classical bound and has the stated independent-loss quantum formula;

    6. complete-law and channel allowances give the robust gap and implementation ledger;

    7. fixed-sample and anytime tests have their stated uniform Type-I guarantees under fresh-run bottlenecks;

    8. finite classical capacity has the stated covering formulation and upper certificates;

    9. the benchmark does not entail quantum non-Markovianity or quantum environmental memory.

    A statistically adjusted record can reject every model in the declared bounded classical-memory class. That conclusion remains conditional on its complete capacity, access, freshness, and discrepancy assumptions.

    No experimental violation, biological memory identification, clinical conclusion, asymptotic computational advantage, spacetime emergence, or inherited analytic admission is established.

    Proof. The preceding proofs establish each positive assertion. Propositions prop:loopholes and prop:largernull, Theorem thm:nonentailment, and Example ex:classicalmemory establish the relevant non-entailment boundaries. The experimental and physical correspondences are not hypotheses discharged by a mathematical score calculation.

  • sectionDiscussion and mathematical releaseDiscussion and mathematical release · lines 1881–1891
    Open as its own page

    No characteristic field product, gravitational response, Ward identity, or spacetime reconstruction is used. This finite-memory manuscript licenses no change to the documentary status O.1 = NOT_CLOSED, no opening of the downstream XV-B admission exit, and no admission of an inherited quantum coefficient. Those source boundaries are not premises of the RAC proof and are not independently audited here.

Declarations

  • sectionDeclarationsDeclarations · lines 1892–1927
    Open as its own page

    and competing interests. No specific funding or competing interests are declared.

    . No new human or animal experimentation is reported.

    availability. No new empirical dataset is used. All mathematical states, channels, scores, and hypotheses needed for the positive results are printed in this source.

    availability. The optional appendix gives independently extractable, unexecuted verification code. It is not an experimental controller, a complete device simulation, or a certified physical implementation.

    provenance. Analytic derivations and static debugging specifications are supplied. No executed compilation, exhaustive enumeration, numerical regression, laboratory realization, or machine-checked proof is asserted. No artifact hash, experimental record, or successful pass flag is invented.

    boundary. The paper recommends no drug, device, diagnostic procedure, or treatment. The mathematical memory resource is not identified with a validated cognitive or biological construct.

Exact finite-classical verification specifications

  • sectionExact finite-classical verification specificationsExact finite-classical verification specifications · lines 1929–1941
    Open as its own page

    The following Python uses only the standard library. The classical optimization is exhaustive and rational when it completes. The quantum calculations are floating-point checks of already proved formulas, not a machine proof.

    A practical guard rejects a requested exhaustive search before execution if its declared size is too large. It does not return a partial best-found value as an upper certificate.

  • listingListing: ListingExact finite-classical verification specifications · lines 1942–2123
    Open as its own page
    import itertools
    import math
    from fractions import Fraction
    
    def bits_of(word, n):
        return tuple((word >> (n - 1 - j)) & 1 for j in range(n))
    
    def hamming(a, b):
        return (a ^ b).bit_count()
    
    def exact_classical_covering(n, states, max_codebooks=1000000):
        if not isinstance(n, int) or n < 1:
            raise ValueError("positive integer input length required")
        if not isinstance(states, int) or states < 1:
            raise ValueError("positive integer state count required")
        if not isinstance(max_codebooks, int) or max_codebooks < 1:
            raise ValueError("positive search guard required")
    
        words = 1 << n
        k = min(states, words)
        number = math.comb(words, k)
        if number > max_codebooks:
            raise ValueError(
                "exhaustive search rejected; no upper certificate returned"
            )
    
        # Adding codewords never worsens the distance objective.
        # Thus exactly k words suffice for the <=states optimum.
        best_cost, best_book, visited = None, None, 0
        for book in itertools.combinations(range(words), k):
            cost = sum(
                min(hamming(x, c) for c in book)
                for x in range(words)
            )
            visited += 1
            if best_cost is None or cost < best_cost:
                best_cost, best_book = cost, book
    
        assert visited == number
        score = Fraction(1, 1) - Fraction(best_cost, n * words)
        return {
            "score": score,
            "minimum_total_distance": best_cost,
            "codebook": tuple(bits_of(c, n) for c in best_book),
            "visited": visited,
            "required": number,
            "certificate": "completed_exact_codebook_enumeration",
            "architecture": "batch encoder; not arbitrary streaming equality",
        }
    
    def enumerate_two_state_tables():
        inputs = tuple(itertools.product((0, 1), repeat=2))
        best = Fraction(0, 1)
        visited = 0
        for encoder in itertools.product((0, 1), repeat=4):
            # Flat decoder entries: (m=0,j=0), (m=0,j=1),
            #                       (m=1,j=0), (m=1,j=1).
            for decoder in itertools.product((0, 1), repeat=4):
                correct = 0
                for x_index, x in enumerate(inputs):
                    memory = encoder[x_index]
                    for j in range(2):
                        correct += decoder[2 * memory + j] == x[j]
                score = Fraction(correct, 8)
                best = max(best, score)
                visited += 1
        assert visited == 256
        return best, visited
    
    def square_state_from_sequential_gates(x1, x2):
        if x1 not in (0, 1) or x2 not in (0, 1):
            raise ValueError("binary inputs required")
        angle = ((-1) ** x1) * math.pi / 4
        state = (math.cos(angle / 2), math.sin(angle / 2))
        if x2:
            state = (state[1], state[0])
        return state
    
    def bloch_xz_from_real_state(state):
        a, b = state
        return 2 * a * b, a * a - b * b
    
    def quantum_success(eta=1.0, steps=0):
        eta = float(eta)
        if not math.isfinite(eta) or not 0 <= eta <= 1:
            raise ValueError("depolarizing factor outside [0,1]")
        if not isinstance(steps, int) or steps < 0:
            raise ValueError("nonnegative integer delay required")
        retained = eta ** steps if steps else 1.0
        values = []
        for x1, x2 in itertools.product((0, 1), repeat=2):
            rx, rz = bloch_xz_from_real_state(
                square_state_from_sequential_gates(x1, x2)
            )
            values.extend((
                0.5 * (1 + ((-1) ** x1) * retained * rx),
                0.5 * (1 + ((-1) ** x2) * retained * rz),
            ))
        return sum(values) / 8, tuple(values)
    
    def complete_score(p, v, assignment_error, eta, steps):
        p, v, assignment_error = map(float, (p, v, assignment_error))
        if not all(math.isfinite(x) for x in (p, v, assignment_error)):
            raise ValueError("finite detector factors required")
        if not 0 <= p <= 1 or not 0 <= v <= 1 \
                or not 0 <= assignment_error <= 0.5:
            raise ValueError("invalid independent-detector specification")
        q, _ = quantum_success(eta, steps)
        return 0.5 + p * v * (1 - 2 * assignment_error) * (q - 0.5)
    
    def exclusion_certificate(scores, delta, e_classical=0.0,
                              anytime=False):
        scores = tuple(float(s) for s in scores)
        if not scores or not all(
            math.isfinite(s) and 0 <= s <= 1 for s in scores
        ):
            raise ValueError("complete attempted-run scores required")
        delta, e_classical = float(delta), float(e_classical)
        if not math.isfinite(delta) or not 0 < delta < 1:
            raise ValueError("confidence error outside (0,1)")
        if not math.isfinite(e_classical) or e_classical < 0:
            raise ValueError("invalid classical discrepancy allowance")
        n = len(scores)
        null_bound = min(1.0, 0.75 + e_classical)
        logarithm = math.log(
            n * (n + 1) / delta if anytime else 1.0 / delta
        )
        radius = math.sqrt(logarithm / (2 * n))
        mean = sum(scores) / n
        return {
            "n_attempts": n,
            "mean": mean,
            "radius": radius,
            "lower_mean_allowance": max(0.0, mean - radius),
            "null_bound": null_bound,
            "reject": mean - radius > null_bound,
            "inspection_policy": "anytime" if anytime else "fixed_sample",
            "capacity_and_freshness_checked_by_code": False,
        }
    
    def proposed_tests():
        # Specifications only: no executed pass is asserted.
        best, count = enumerate_two_state_tables()
        assert best == Fraction(3, 4)
        assert count == 256
    
        for states, expected in (
            (1, Fraction(1, 2)),
            (2, Fraction(3, 4)),
            (3, Fraction(7, 8)),
            (4, Fraction(1, 1)),
        ):
            record = exact_classical_covering(2, states)
            assert record["score"] == expected
            assert record["visited"] == record["required"]
    
        ideal = 0.5 + 1 / (2 * math.sqrt(2))
        q, individual = quantum_success()
        assert math.isclose(q, ideal, abs_tol=1e-12)
        assert all(math.isclose(v, ideal, abs_tol=1e-12)
                   for v in individual)
    
        # At the exact theoretical isotropic boundary the score is 3/4.
        q, _ = quantum_success(1 / math.sqrt(2), 1)
        assert math.isclose(q, 0.75, abs_tol=1e-12)
    
        assert complete_score(0.0, 1.0, 0.0, 1.0, 0) == 0.5
        assert complete_score(1.0, 0.0, 0.0, 1.0, 0) == 0.5
        assert complete_score(1.0, 1.0, 0.5, 1.0, 0) == 0.5
    
        # Query-2 erasure must not be discarded.
        full_attempt_scores = (1.0, 0.5)
        assert sum(full_attempt_scores) / len(full_attempt_scores) == 0.75
    
        try:
            exact_classical_covering(8, 8, max_codebooks=1)
        except ValueError:
            pass
        else:
            raise AssertionError("oversized search was not rejected")
  • sectionExact finite-classical verification specificationsExact finite-classical verification specifications · lines 2123–2131
    Open as its own page

    The statistical function deliberately reports that capacity and freshness are not verified by the code. A score array cannot establish a storage boundary. An experimental generator must use the intended independent input and late-query law; pseudorandom seeds alone do not prove that law.

Capacity and experimental-access ledger

  • sectionCapacity and experimental-access ledgerCapacity and experimental-access ledger · lines 2133–2185
    Open as its own page
    must be counted at the delayed-query boundary.
    ObjectAdmitted statusRequired check
    ObjectAdmitted statusRequired check
    Named classical carrierAt most two realized states in the main nullIts joint decoder-accessible state, not only one marginal.
    Shared random seedFree only if independent of fresh No current-input-dependent mutation or correlated input generator.
    Controller and pulse logCounted if current-input dependentNo retained copy of an encoding bit or preparation setting.
    Delay environmentCounted if it can influence later decoding with input informationDeclared factorization or independently bounded discrepancy.
    Timing and stopping informationCounted if it reveals current inputFixed or input-independent schedule, or explicit resource model.
    Preparation and erasure flagsNeutral scored; independence needed for multiplicative formulaComplete record retained and input dependence audited.
    Scoring copy of Experimenter-side onlyNo access or feedback to the current decoder.
    Late query Fresh and independent after encodingNo advance leakage or predictable query schedule.
    Decoder ancillasInput-independent fresh resourcesNo retained input-dependent correlations or shared entanglement.
    Across-run memoryPermitted before the new inputsCurrent-run bottleneck still enforced after encoding.
    Repeated copies of the same inputDifferent storage experimentAll copies and retained observations must be counted.
    Experimental failuresComplete attempted-run denominatorNo favorable postselection or retrospective omission.

Claim-status and debugging ledger

  • sectionClaim-status and debugging ledgerClaim-status and debugging ledger · lines 2187–2268
    Open as its own page
    scope of the principal conclusions.
    ClaimStatusCertificate or boundary
    ClaimStatusCertificate or boundary
    Every stochastic two-state classical memory has score at most Proved benchmarkComplete factorization, fresh uniform bits, independent late query.
    Sequential arrival strengthens that boundNot assertedThe batch class already supplies the valid upper bound.
    One qubit attains the standard RAC valueProved benchmarkPrinted states, gates, and complete projective instruments.
    Any nonzero coherence beats the classical taskFalse generallyTask score must exceed the threshold, not only have a nonzero contrast.
    Neutral output erasures invalidate the boundFalse within the factorized classThey can be replaced by fair guesses without changing the mean.
    The independent-loss formula covers arbitrary lossesExcludedInput- and outcome-dependence need a separate complete law.
    Observed rejection requires subtracting twiceFalse supplies a design/power allowance, not a second data penalty.
    A fixed-sample radius permits arbitrary stoppingFalseUse the printed anytime allocation or another proved sequential test.
    A numerical best strategy is an upper boundFalseIt is feasible and therefore a lower bound on the maximum.
    A RAC violation certifies quantum environmental memoryFalseA Markovian qubit already wins.
    A causal-break witness certifies nonclassical memoryFalse generallyA classical hidden register can generate the same kind of history dependence.
    The present witness excludes every classical simulationNot assertedOnly the capacity- and access-restricted class is excluded.
    Biological or clinical memory identificationNot establishedNo participating-state, control, or observation correspondence.
    Asymptotic computational advantageNot establishedNo scalable task and full resource comparison supplied.
    Spacetime emergence or inherited analytic admissionOutside scopeNo characteristic-map, representation, or admission gate constructed.

    • Pauli notation. The input is a classical bit string. The operators are written , avoiding a type collision.

    • Sequential rotation sign. The convention sends to . The later flips the component but not the component.

    • Depolarizing linearity. The replacement term is . Writing without the trace is only a state-level formula, not the channel on arbitrary operators.

    • Zero delay. The empty storage product is one. No ambiguity at is used.

  • sectionClaim-status and debugging ledgerClaim-status and debugging ledger · lines 2268–2307
    Open as its own page

    • Classical versus quantum randomness. Shared classical randomness is admitted. Preshared entanglement or another correlated retained quantum system changes the quantum resource class.

    • Average input convention. The bound is not a pointwise limit on every input-query pair. The current pair is fresh before the conditional null mean is formed.

    • Complete records. A detection-conditioned average is not the attempted-run witness.

    • Calibration coverage. Error allowances must be justified simultaneously for the selected protocol before the assessment block.

    • Finite-state versus finite precision. A continuous classical description of a density matrix is not a two-state memory.

    • Null-class enlargement. Already quantum carriers require a process-level classical-environment bound, not reuse of the wholly classical inequality.

    • Source relations. The Psy predecessors and supplied analytic status records are documentary interfaces, not premises identifying different models.

    • Evidence types. Analytic proof, exhaustive software execution, compilation, laboratory implementation, and physical correspondence remain distinct.

  • bibliographyReferencesClaim-status and debugging ledger · lines 2308–2481
    Open as its own page

    AmbainisRAC

    A. Ambainis, D. Leung, L. Mancinska, and M. Ozols, Quantum random access codes with shared randomness. Author manuscript, arXiv:0810.2937v3 (2009); original submission 2008. https://arxiv.org/abs/0810.2937v3. Cited for the established classical and qubit RAC benchmarks and shared-randomness setting.

    RoySequential

    A. K. Roy, V. Srivastava, S. Mahanti, C. Giarmatzi, and A. Gilchrist, Semi-device-independent certification of quantum non-Markovianity using sequential random access codes. Physical Review A 110 (2024), 012608. Published 10 July 2024. https://doi.org/10.1103/PhysRevA.110.012608. Author manuscript: https://arxiv.org/abs/2309.16190. Its intermediate-instrument and process-class assumptions are not replaced by the present single-receiver storage bound.

    Hoeffding

    W. Hoeffding, Probability inequalities for sums of bounded random variables. Journal of the American Statistical Association 58, no. 301 (1963), 13–30. https://doi.org/10.1080/01621459.1963.10500830. The conditional bounded-score exponential estimate needed here is also proved explicitly.

    Watrous

    J. Watrous, The Theory of Quantum Information. Cambridge University Press, 2018. Author's manuscript: https://cs.uwaterloo.ca/ watrous/TQI/. Cited for finite channels, instruments, trace distance, and reference-stable channel comparisons.

    PollockMarkov

    F. A. Pollock, C. Rodríguez-Rosario, T. Frauenheim, M. Paternostro, and K. Modi, Operational Markov condition for quantum processes. Physical Review Letters 120 (2018), 040405. https://doi.org/10.1103/PhysRevLett.120.040405. https://arxiv.org/abs/1801.09811. Operational history dependence is not automatically a nonclassical environmental-memory resource.

    PollockProcess

    F. A. Pollock, C. Rodríguez-Rosario, T. Frauenheim, M. Paternostro, and K. Modi, Non-Markovian quantum processes: complete framework and efficient characterization. Physical Review A 97 (2018), 012127. https://doi.org/10.1103/PhysRevA.97.012127. https://arxiv.org/abs/1512.00589.

    CheungModes

    N. Cheung, Divergent mechanisms of antidepressant efficacy: a unified computational comparison of synaptogenesis, stabilization, and tonic inhibition in a model of depression. Cureus 18, no. 3 (2026), e105040. Published 11 March 2026. https://doi.org/10.7759/cureus.105040. Computational motivation, not a RAC experiment or clinical premise.

    CheungOCD

    N. Cheung, Structural synaptogenesis superior to functional modulation in a pruning-based recurrent network model of OCD. Frontiers in Computational Neuroscience 20 (2026), 1799705. Published 20 July 2026. https://doi.org/10.3389/fncom.2026.1799705. A separate modular recurrent task; no memory-dimension identification is inferred.

    CheungPsy01A

    N. Cheung, Psy01-A: Phased magnitude pruning in task-gated ReLU networks: cue certificates, stability, and conditional selectivity–fragility trade-offs. Undated manuscript, Psy01-A.tex, supplied in full. Relevant documentary record: thm:evaluation. Its architecture and density controls are not the present storage boundary.

    CheungPsy02A

    N. Cheung, Psy02-A: Conditional scalar-carrier bounds and operational separation: a mathematical framework for evaluating Orch-OR hypotheses. Undated manuscript, Psy02-A.tex, supplied in full. Relevant records concern instruments, operational witnesses, and interpretive non-entailment. Its scalar and reduction models are not imported.

    CheungPsy02B

    N. Cheung, Psy02-B: Quantitative viability and identifiability of a branch-matched reduction pilot: complete records, collective mass energies, and a self-contained interface to the inherited analytic problem. Undated manuscript, Psy02-B-v2.tex, version 2, supplied in full. Relevant records: thm:process, prop:dynamic, and thm:sampling. Its inherited analytic admission obligations remain separate.

    CheungPsy03A

    N. Cheung, Psy03-A: Structural repair, noise adaptation, and dynamical modulation in pruned networks: intervention budgets, classical certificates, and a separately defined quantum extension. Undated manuscript, Psy03-A.tex, supplied in full. Relevant records: def:budget, thm:evaluation, thm:process, and prop:dynamic.

    CheungPsy03B

    N. Cheung, Psy03-B: Irreversible structural memory and threshold-triggered feedback in pruned networks: longitudinal certificates and a quantum–classical extension. Undated manuscript, Psy03-B-v1.tex, version 1, supplied in full. Relevant records: thm:conditional, prop:normalization, and thm:operationalmemory. Its persistent register is explicitly classical.

    CheungPsy03C

    N. Cheung, Psy03-C: Recurrent stability and probe identifiability in scar-constrained networks: task geometry, temporal certificates, and a separate quantum extension. Undated manuscript, Psy03-C-v1.tex, version 1, supplied in full. Relevant records: cor:battery, prop:register, and thm:qpilot. Its delayed phase-label task is not a random-access task.

    CheungPsy03D

    N. Cheung, Psy03-D: Hidden-rule observability and intervention identifiability in modular recurrent networks: switching metrics, masked repair, and certified matching. Undated manuscript, supplied in the present conversation. Relevant records: ass:uncued, thm:observability, thm:sequencehoeffding, and cor:qobstruction. The present late-query memory task is independently specified.