All manuscripts

Manuscript Psy03-A@1 · Psy03-A.tex · b30eb6e9

Psy03-A Structural Repair, Noise Adaptation, and Dynamical Modulation in Pruned Networks: Intervention Budgets, Classical Certificates, and a Separately Defined Quantum Extension

Export Psy03-A.tex

Specifies version 1 of an intervention-budget framework for the supplied pruned-network computation and a separately defined finite quantum extension. thm:zerodose shows that a zero weight-displacement dose need not preserve logits or accuracy when damping or activation changes. prop:rescaling shows that a clean ReLU rescaling need not preserve the weight budget or the isotropic stress experiment. prop:samemask separates equal masks and equal clean logits from equal stressed accuracy. cor:stress and thm:stressaccuracy give a damped path bound and a margin certificate. Damping changes both the clean signal and the injected noise. prop:tanh records that noise added after tanh is not a bounded stressed activation. thm:descent is a signed sparse-gradient local guarantee that the source's magnitude-ranked random initialization does not inherit. thm:ranking and thm:evaluation repair matching tolerance, support, stage labels, and secondary pruning. thm:classicalboundary gives an exact classical Markov realization when the Hamiltonian vanishes, the input is diagonal, and the output is measured in the node basis. thm:phase, thm:nodepilot, and thm:gap give finite coherence-sensitive records. thm:equalop shows that equal operational channel distance need not fix task performance. prop:nontransfer separates the classical simulation from the quantum extension. thm:release is the analytical release. Psy01-A, Psy02-A, Psy02-B, 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 an antidepressant mechanism, not a clinical treatment recommendation, 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 122–155
    Open as its own page

    We develop a proof framework for the three computational interventions implemented in the supplied 068a_antidep_modes_v2.py: gradient-ranked connection regrowth, noise-scheduled adaptation, and activation modulation. We prove that weight-displacement norms do not control the implemented function when biases, damping, activation choice, or parameterization are allowed to change. A budget vector separates these controls from structural changes and training cost. For the actual post-activation-noise architecture, we establish damped path bounds, margin-based stress certificates, coupled parameter comparisons, and conditional ranking criteria. A signed sparse-gradient repair has an explicit local descent guarantee; the code's magnitude-ranked random initialization does not inherit it. Exact-count and random-stream repairs address matching tolerance, support gaps, endpoint regrowth, stage labeling, and secondary pruning. A separately specified finite quantum stochastic network has an exact classical Markov boundary, complete measurement records, and reference-stable intervention bounds. Two-level examples give exact phase-sensitive classification, coherence-to-population conversion, and a robust calibrated contrast. Equal operational channel distance nevertheless does not imply equal performance. The classical simulation, the quantum extension, and their pharmacological analogies are not identified. No newly executed numerical ranking, quantum computational advantage, antidepressant mechanism, or clinical treatment recommendation is asserted.

  • sectionFront matterFront matter · lines 155–161
    Open as its own page

    Keywords: computational interventions; magnitude pruning; sparse regrowth; hidden noise; intervention budgets; quantum stochastic walks; coherence; complete instruments; identifiability.

Question, contribution, and proof boundary

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

    The central question is:

    Under what declared intervention budgets do structural repair, noise adaptation, and dynamical modulation improve a specified computational outcome, and when does a separately supplied coherence resource change the comparison?

    Cheung's computational comparison supplies the direct motivation CheungModes. The earlier pruning study and pruning-cliff preprint concern related computational models CheungPruning,CheungCliff. The exact object audited here is the source supplied as 068a_antidep_modes_v2.py, not an unexamined repository revision Cheung068Code.

    The paper has two tracks.

    1. Classical track. We formalize the supplied feed-forward computation, prove conditional performance certificates and counterexamples, and repair the comparison protocol.

    2. Quantum track. We independently define a finite open-system network, prove its classical boundary, and construct phase-sensitive records. It is an extension by mathematical analogy, not a reinterpretation of the Python simulation as quantum.

    Psy01-A motivates the separation of masks, parameter geometry, margins, stress, and training schedules CheungPsy01A. Psy02-A motivates the separation of channels, coherence, instruments, and accessible records CheungPsy02A. Psy02-B supplies the corresponding complete-process and calibrated comparison architecture CheungPsy02B. Their roles are source records and methodological precedents. The independent statements used here have their hypotheses and proofs printed below.

    names of the interventions. In theorem statements we use:

    The source's “ketamine-like,” “SSRI-like,” and “neurosteroid-like” labels are retained only as declared biological analogies. They do not establish pharmacological correspondence.

    boundary. The Lipschitz, concentration, and channel tools are standard. The contribution is their source-aligned application, the budget-insufficiency and ranking counterexamples, the exact small quantum comparisons, and the repaired evidential protocol. No theorem characterizes the convergence of the source's Adam training runs.

    boundary. The source audit is static. No performance table is generated or independently reproduced here. The appended repair core is not reported as executed. The mathematical release does not depend on a passing script, successful compilation, or laboratory realization.

The actual classical computation

  • sectionArchitecture, data, and stochastic forward mapThe actual classical computation › Architecture, data, and stochastic forward map · Psy03-A@1#eq:forward · lines 235–303
    Open as its own page

    Let

    Write

    and .

    There are

    weight positions, totaling

    There are bias parameters, so the total trainable parameter count is .

    Fix , activation , input-noise intensity , and hidden-noise intensity . For independent standard Gaussians , define

    The smallest maximizing index resolves ties. The population accuracy is

    All accuracies in this paper are fractions, not percentages.

    The input law is

    with and

    Additional input noise of intensity gives conditional variance . The clean-center test is a different input law with .

    Equation (eq:forward) is the source's ordering: activation, additive noise, then multiplicative damping. The output is a logit vector. An explicit softmax is unnecessary for its argmax or the cross-entropy training interface.

  • sectionWeights, masks, and ambient gradientsThe actual classical computation › Weights, masks, and ambient gradients · lines 304–325
    Open as its own page

    In the supplied implementation, masked parameters are set to zero and masks are reapplied after optimizer steps. The forward pass uses ordinary dense linear modules. Thus its derivatives at inactive zero positions are derivatives of the ambient dense extension of the sparse network.

    This distinction matters. If a replacement implementation instead computes inside autograd while differentiating with respect to , inactive-position derivatives are multiplied by zero. That implementation cannot use those derivatives as the source's regrowth scores without another scoring interface.

    The method is unstructured weight pruning, despite the source manager's “structured pruning” description. Gradient-ranked changes of sparse topology have established precedents EvciRigL; the supplied algorithm is not identified with RigL.

  • definitionDefinition: Complete classical stateThe actual classical computation › The augmented intervention state · Psy03-A@1#def:state · lines 328–340
    Open as its own page

    A complete intervention state includes:

    Here is optimizer state when it is retained, contains the named stream states, identifies the training and held-out snapshots, and identifies the intervention stage.

  • sectionThe augmented intervention stateThe actual classical computation › The augmented intervention state · lines 340–354
    Open as its own page

    The source creates a fresh Adam optimizer in each training function. An exact description therefore includes these resets. A phase-boundary checkpoint can omit discarded optimizer moments; a checkpoint intended to resume a live optimizer cannot.

    Ordinary Python modulation attributes and masks held by a separate manager are not automatically included in a module's state_dict. Parameters and persistent buffers are included, and the returned dictionary must be cloned when an immutable snapshot is intended PyTorchModule.

  • definitionDefinition: Computational interventionsThe actual classical computation › Three intervention families · Psy03-A@1#def:interventions · lines 357–372
    Open as its own page

    For a fixed baseline checkpoint:

    1. Regrowth chooses inactive positions using specified scores, activates an exact integer count, initializes their weights, and applies a specified consolidation map.

    2. Noise-scheduled adaptation retains the mask and trains under a specified hidden-noise schedule, minibatch sequence, and optimizer-reset convention.

    3. Activation modulation changes and possibly , then applies specified consolidation while retaining the mask.

    Each map includes its exogenous random inputs.

  • sectionThree intervention familiesThe actual classical computation › Three intervention families · lines 372–377
    Open as its own page

    A fixed mask does not mean fixed weights or biases. A decreasing training-noise schedule does not, by itself, prove improved accuracy under a later fixed evaluation noise.

Intervention budgets and the failure of weight-only dose

  • sectionThe source metricsIntervention budgets and the failure of weight-only dose › The source metrics · lines 381–422
    Open as its own page

    When masked parameters have been enforced, the source's primary weight-displacement quantity is

    Its reported “L2 dose” is

    not the root-mean-square displacement

    Consequently,

    These identities follow from the finite-dimensional norm inequalities.

    The relative-change statistic

    is weight turnover, not structural turnover. At a baseline zero position its threshold is . It does not distinguish a mask birth from a change of an already active weight. Numerical zero counts and mask counts are different as well.

  • theoremTheorem: Zero weight dose does not control implementationIntervention budgets and the failure of weight-only dose › The source metrics · Psy03-A@1#thm:zerodose · proof attached · lines 423–455
    Open as its own page

    There exist pairs in the stated architecture with identical weights, biases, and masks, hence , but different clean logits and accuracies. This holds for a damping change alone, and also for an activation change alone.

    Proof. For damping, use one constant positive feature. Give its first hidden unit bias one and zero incoming weights. Relay that unit through one unit in each subsequent hidden layer using weight one and bias zero. Use ReLU and send the final feature to output class . Its clean logit is . Set the class- output bias to , where

    and the other logits to . For a test law with label , changing to changes accuracy from zero to one. No parameter or mask changes.

    For activation, isolate a third-layer unit with zero incoming weights and bias two, set , and send it to class . Let class have bias , and the other logits be . ReLU gives , whereas . The prediction again changes without a parameter change. Unused coordinates embed both examples in the specified widths.

  • remarkRemark: Unpriced biasesIntervention budgets and the failure of weight-only dose › The source metrics · lines 457–462
    Open as its own page

    Because the source metric excludes biases, changing only an output bias also gives with a changed decision. Theorem thm:zerodose is stronger: its first two examples do not even change biases.

  • propositionProposition: Clean rescaling does not preserve the budgetIntervention budgets and the failure of weight-only dose › Parameterization dependence · Psy03-A@1#prop:rescaling · proof attached · lines 466–502
    Open as its own page

    For a ReLU network and positive diagonal , set

    At fixed damping , clean logits are unchanged. With isotropic hidden noise in the new coordinates, the transformed computation corresponds to hidden noises in the old coordinates. Magnitude rankings and weight-displacement norms need not be preserved.

    There are pairs of distinct clean functions whose weight-displacement dose can be made arbitrarily small by applying the same such rescaling to both parameterizations.

    Proof. Positive homogeneity gives , and commutes with scalar damping. Induction proves the clean identity. For noise, factor at each layer.

    For the last assertion, use a constant final ReLU feature one and head weight one in the baseline, two in the intervention. The clean logit difference is one. Rescale that hidden feature by in both networks. The head weights become and , so their weight-displacement dose is . It tends to zero while both implemented clean functions remain unchanged.

  • sectionParameterization dependenceIntervention budgets and the failure of weight-only dose › Parameterization dependence · lines 502–507
    Open as its own page

    This is the damped counterpart of Psy01-A's rescaling record CheungPsy01A. It is not a statement that tanh has the same rescaling symmetry.

  • propositionProposition: Same clean function and mask, different stressIntervention budgets and the failure of weight-only dose › Parameterization dependence · Psy03-A@1#prop:samemask · proof attached · lines 508–525
    Open as its own page

    There are ReLU networks with the same masks and the same clean logits for every input but different stressed accuracies.

    Proof. Take , isolate a third-layer unit with bias , and give its class- output weight . Use competing logits . Clean logits are always . Under hidden noise, correctness for label is , giving

    Masks and nonzero-position counts are unchanged as varies.

  • sectionParameterization dependenceIntervention budgets and the failure of weight-only dose › Parameterization dependence · lines 525–529
    Open as its own page

    Thus neither equal density nor equal clean performance determines stress tolerance.

  • definitionDefinition: Declared intervention accountingIntervention budgets and the failure of weight-only dose › A budget vector · Psy03-A@1#def:budget · lines 532–559
    Open as its own page

    For a fixed parameterization, define

    where

    and

    The last entry identifies a separately chosen comparison of the training-noise schedules, on an explicitly aligned time or step domain.

    Training cost records at least optimizer steps, examples processed, gradient-scoring batches, and the computational implementation. A mask in a dense linear module does not imply sparse execution cost.

  • sectionA budget vectorIntervention budgets and the failure of weight-only dose › A budget vector · lines 559–569
    Open as its own page

    This vector is an accounting convention, not a universal invariant notion of intervention magnitude. A scalarization requires declared nonnegative weights, units, and resource interpretations.

    We use matched weight-displacement comparison for equality or tolerance matching of . We do not call that constraint mechanism-agnostic dose fairness.

Stress, margins, and complete perturbation budgets

  • lemmaLemma: Layerwise propagationStress, margins, and complete perturbation budgets › A general path lemma and the damped certificate · Psy03-A@1#lem:path · proof attached · lines 575–597
    Open as its own page

    Suppose two computations with the same matrices and activations have hidden differences satisfying

    Then

    Proof. Iterate the three scalar recurrences and multiply the final hidden difference by .

  • sectionA general path lemma and the damped certificateStress, margins, and complete perturbation budgets › A general path lemma and the damped certificate · lines 597–603
    Open as its own page

    Both ReLU and tanh are -Lipschitz and vanish at zero. The next result is the direct damped extension of the undamped path bound recorded in Psy01-A CheungPsy01A; the independent derivation requires only Lemma lem:path.

  • corollaryCorollary: Stress and input-noise path boundStress, margins, and complete perturbation budgets › A general path lemma and the damped certificate · Psy03-A@1#cor:stress, Psy03-A@1#eq:pathbound · proof attached · lines 604–627
    Open as its own page

    For the same network, damping, and activation, coupled with the same clean input,

    where

    Proof. At the input . Each hidden noise contributes . Apply the lemma.

  • sectionA general path lemma and the damped certificateStress, margins, and complete perturbation budgets › A general path lemma and the damped certificate · Psy03-A@1#eq:marginlip · lines 627–646
    Open as its own page

    The factor includes damping immediately after injection and damping at every subsequent hidden layer. Damping is not a pure noise-reduction operation: it also changes clean signals and margins.

    For logits and label , define

    Then

    This follows by applying the sup-norm bound to the true logit and the maximal competitor.

  • theoremTheorem: Global stress-accuracy certificateStress, margins, and complete perturbation budgets › A general path lemma and the damped certificate · Psy03-A@1#thm:stressaccuracy · proof attached · lines 647–678
    Open as its own page

    Let

    and put

    For the clean margin ,

    The right side may be truncated below at zero.

    Proof. The scalar Gaussian tail bound , followed by a union bound, shows that all noise coordinates have magnitude at most with probability at least . Equation (eq:pathbound) is then at most . The margin condition and (eq:marginlip) preserve correctness.

  • sectionA general path lemma and the damped certificateStress, margins, and complete perturbation budgets › A general path lemma and the damped certificate · lines 678–683
    Open as its own page

    Margin-based certification is standard Tsuzuku. The certificate is conservative, and it is not a theorem that every damping intervention improves actual accuracy.

  • propositionProposition: Bounded signal, unbounded stressed activationStress, margins, and complete perturbation budgets › Tanh does not bound the noisy hidden state · Psy03-A@1#prop:tanh · proof attached · lines 686–702
    Open as its own page

    For a tanh layer,

    If , each coordinate of , conditional on , has unbounded Gaussian support. Thus the complete stressed hidden state is not bounded.

    Proof. Use . Adding a nondegenerate Gaussian after tanh gives support equal to the whole real line in each coordinate.

  • sectionCoupled parameter comparisonsStress, margins, and complete perturbation budgets › Coupled parameter comparisons · lines 704–735
    Open as its own page

    Let a primed and an unprimed computation use the same . Their input-noise intensities may differ. Put

    and for hidden layers define

    Let

    and .

  • theoremTheorem: Full implemented-logit comparisonStress, margins, and complete perturbation budgets › Coupled parameter comparisons · Psy03-A@1#thm:param, Psy03-A@1#eq:fullparam · proof attached · lines 736–773
    Open as its own page

    The coupled outputs obey

    All displayed first moments are finite for fixed finite parameters and the stated Gaussian input law.

    If are common, the noise and modulation terms vanish, leaving only weight and bias perturbations.

    Proof. Subtract the hidden updates. Insert and . The Lipschitz property gives

    The head satisfies the analogous recurrence. Iterate.

    The activations satisfy . The difference between the two activations is at most . Finite Gaussian input and noise moments therefore imply finite hidden and residual first moments by recursion.

  • sectionCoupled parameter comparisonsStress, margins, and complete perturbation budgets › Coupled parameter comparisons · lines 773–780
    Open as its own page

    The cancellation under common noise is the typed parameter-stability interface recorded in Psy01-A. It must not be used when damping or the stress intensity differs: the residual term then contains .

  • theoremTheorem: Accuracy and smooth-score stabilityStress, margins, and complete perturbation budgets › Coupled parameter comparisons · Psy03-A@1#thm:accuracy, Psy03-A@1#eq:accuracy · proof attached · lines 781–812
    Open as its own page

    Let under a specified common coupling. For every ,

    If almost surely, the bound is instead

    For the margin ramp

    Proof. A change in correctness is possible only when ; ties are included in that event. Split at , then use Markov's inequality on . For the ramp, use its Lipschitz constant and (eq:marginlip).

  • sectionCoupled parameter comparisonsStress, margins, and complete perturbation budgets › Coupled parameter comparisons · lines 812–820
    Open as its own page

    Accuracy continuity needs a margin condition. For example, gives a modulus of order . A small logit upper bound alone does not establish a strict performance improvement.

What structural repair can and cannot guarantee

  • sectionExact counts and fixed-weight nestingWhat structural repair can and cannot guarantee › Exact counts and fixed-weight nesting · lines 824–829
    Open as its own page

    For each layer, rank eligible active weights by decreasing magnitude, breaking ties by increasing flattened index. Let retain the first eligible positions.

  • propositionProposition: Exact-count structureWhat structural repair can and cannot guarantee › Exact counts and fixed-weight nesting · Psy03-A@1#prop:counts · proof attached · lines 830–851
    Open as its own page

    At frozen weights and consistent tie breaking,

    Fixed parameter masks commute:

    A real fraction mapped to an integer retention count gives a piecewise-constant hard intervention with possible jumps. It need not define a continuous accuracy surface.

    Proof. The first positions are a subset of the first . Mask projections multiply coordinates by zeros and ones. A count changes at an integer threshold; deletion of a nonzero decision-relevant weight can change the logits and the predicted class abruptly.

  • sectionExact counts and fixed-weight nestingWhat structural repair can and cannot guarantee › Exact counts and fixed-weight nesting · Psy03-A@1#eq:regrowcount · lines 851–870
    Open as its own page

    These are the fixed-weight identities recorded in Psy01-A CheungPsy01A. Training between operations can change the ranking. For a frozen late-cutoff gap , a perturbation with preserves the selected support, because every cross-cutoff magnitude ordering is preserved.

    For corrected regrowth, we use

    This makes exactly the identity structural operation and restore all inactive positions. Integer discontinuities remain; repairing the zero endpoint does not make hard regrowth smooth.

  • theoremTheorem: Local loss descent under an explicit repair budgetWhat structural repair can and cannot guarantee › A signed sparse-gradient guarantee · Psy03-A@1#thm:descent, Psy03-A@1#eq:descent · proof attached · lines 873–911
    Open as its own page

    Let be differentiable on a neighborhood containing the update segment, and let its gradient be -Lipschitz there. Let be the inactive-coordinate set and . Among updates supported in , using at most coordinates and satisfying , the largest possible first-order loss decrease is

    where contains the largest , . If , the signed update

    satisfies

    Thus it strictly decreases loss when , for .

    Proof. For each support ,

    The top-magnitude support maximizes the squared gradient norm. The signed update attains the first-order bound. Integration of the Lipschitz gradient along the segment gives

    Substitute the selected update.

  • sectionA signed sparse-gradient guaranteeWhat structural repair can and cannot guarantee › A signed sparse-gradient guarantee · lines 911–919
    Open as its own page

    For a ReLU empirical loss, the smoothness hypothesis must be checked on the update segment, for example inside a fixed nonzero-gate region. It is not a global smoothness theorem for every ReLU checkpoint.

    This is a training-loss guarantee, not a generalization or stress-accuracy guarantee.

  • propositionProposition: The supplied regrowth rule lacks this guaranteeWhat structural repair can and cannot guarantee › A signed sparse-gradient guarantee · Psy03-A@1#prop:randominit · proof attached · lines 920–946
    Open as its own page

    Ranking coordinates by accumulated absolute minibatch gradients and initializing the chosen coordinates with independent centered Gaussians does not generally produce a signed first-order descent step.

    In particular, random initialization can increase expected loss even at a coordinate with nonzero gradient.

    Proof. Accumulated absolute gradients need not equal the absolute gradient of the averaged loss: gradients of opposite signs can cancel in the average but not in the score. Centered random initialization also has zero expected linear alignment with a fixed gradient.

    For an exact example, take , , , and initialize the selected coordinate by , with . The coordinate has nonzero gradient , but

    Subsequent training may change that result, but is a separate map.

  • sectionA signed sparse-gradient guaranteeWhat structural repair can and cannot guarantee › A signed sparse-gradient guarantee · lines 946–953
    Open as its own page

    The repaired implementation below preserves the source's random regrowth convention. It does not silently substitute the signed update of Theorem thm:descent. A study using that alternative must label it as a changed protocol.

Matched-budget comparisons and statistical certificates

  • sectionMatching on finite candidate supportMatched-budget comparisons and statistical certificates › Matching on finite candidate support · lines 957–961
    Open as its own page

    Let be a finite candidate set for intervention family , with realized displacement .

  • definitionDefinition: Tolerance-supported matchingMatched-budget comparisons and statistical certificates › Matching on finite candidate support · Psy03-A@1#def:matching, Psy03-A@1#eq:commonsupport · lines 962–976
    Open as its own page

    A target is admissible at tolerance if

    For each family choose a nearest eligible candidate, with a fixed tie rule. If any family has no eligible candidate, report the target as unmatched. Other budget restrictions are applied before this matching step.

  • sectionMatching on finite candidate supportMatched-budget comparisons and statistical certificates › Matching on finite candidate support · lines 976–986
    Open as its own page

    Overlap of the candidates' min–max intervals is only a necessary span condition for zero-tolerance common support. It is not sufficient for the discrete grids. Pooled percentiles do not repair a lack of common support.

    The same candidate can be nearest to several targets. Those repeated selections are not independent experimental replicates.

  • assumptionAssumption: Target-response calibrationMatched-budget comparisons and statistical certificates › A conditional exact-target ranking · Psy03-A@1#ass:target · lines 989–1000
    Open as its own page

    For each compared family, an independently justified reference response is defined near , and a selected candidate satisfies

    The constant includes any other permitted budget mismatch or implementation discrepancy.

  • sectionA conditional exact-target rankingMatched-budget comparisons and statistical certificates › A conditional exact-target ranking · lines 1000–1004
    Open as its own page

    This assumption is not implied by hard pruning, equal displacement, or a fitted smooth curve.

  • theoremTheorem: Conditional ranking certificateMatched-budget comparisons and statistical certificates › A conditional exact-target ranking · Psy03-A@1#thm:ranking, Psy03-A@1#eq:ranking · proof attached · lines 1005–1034
    Open as its own page

    Suppose selected candidates have estimates , with simultaneous error bounds

    Under Assumption ass:target and tolerance matching,

    A positive remainder certifies the oriented ranking.

    Without an exact-target response calibration, the simpler condition

    certifies the ranking of the two actual selected checkpoints, not a universal equal-dose curve.

    Proof. Apply the two estimate bounds and the two calibration bounds, then subtract.

  • sectionA conditional exact-target rankingMatched-budget comparisons and statistical certificates › A conditional exact-target ranking · lines 1034–1040
    Open as its own page

    For a checkpoint-specific stress ranking, one may alternatively compare a valid lower certificate for one accuracy with a valid upper certificate for the other. Comparing two lower bounds does not establish an ordering.

  • theoremTheorem: Simultaneous candidate and paired-contrast boundsMatched-budget comparisons and statistical certificates › Held-out uncertainty and repeated noise · Psy03-A@1#thm:evaluation, Psy03-A@1#eq:pairedradius · proof attached · lines 1043–1080
    Open as its own page

    Condition on candidate checkpoints independent of the held-out input sample. For independent held-out examples, possibly with repeated independent noise draws within each example, let be the average correctness. Then

    Thus

    is a simultaneous radius.

    For predeclared paired contrasts, where each example's contrast lies in , a simultaneous radius is

    Dependence between candidate evaluations on the same example is permitted. Independence is required between example blocks.

    Proof. Each example's mean correctness over its noise draws lies in , has the required expectation, and is independent of the other example blocks. Apply Hoeffding's inequality and a union bound Hoeffding. For contrasts the bounded interval has length two.

  • sectionHeld-out uncertainty and repeated noiseMatched-budget comparisons and statistical certificates › Held-out uncertainty and repeated noise · lines 1080–1092
    Open as its own page

    Repeated noise on fixed inputs can reduce Monte Carlo uncertainty conditional on those inputs. It does not turn them into independent population examples.

    The theorem permits selecting among the candidates after their simultaneous evaluation. It does not permit arbitrary additional test-driven retraining without expanding or changing the statistical analysis. Across-seed uncertainty requires independent training replicates and a seed-level analysis.

  • sectionChallenge degradation and modulation withdrawalMatched-budget comparisons and statistical certificates › Challenge degradation and modulation withdrawal · lines 1093–1122
    Open as its own page

    For a frozen acute checkpoint, let remove an exact fraction of active positions under a specified ranking. Define

    Use the same evaluation law and a declared noise coupling.

    A smaller degradation does not necessarily mean better post-challenge performance. For example, accuracies and have losses and , while the second checkpoint remains better. Both absolute post-challenge performance and degradation must therefore be reported.

    Removing the source's modulation switches both and , while retaining consolidated weights and biases. That is a specified computational intervention, not an experiment on pharmacological withdrawal. Its possible effect is not necessarily a reversal of the original treatment.

  • propositionProposition: Ratio sensitivityMatched-budget comparisons and statistical certificates › Efficiency has a denominator condition · Psy03-A@1#prop:efficiency · proof attached · lines 1125–1147
    Open as its own page

    Let be accuracy improvements and let . If

    then

    Proof. Insert , then use .

  • sectionEfficiency has a denominator conditionMatched-budget comparisons and statistical certificates › Efficiency has a denominator condition · lines 1147–1155
    Open as its own page

    At zero weight displacement, an improvement-per-weight-dose ratio is undefined. Adding to its denominator gives an arbitrary regularized statistic, not a repaired physical efficiency. Theorem thm:zerodose makes this issue particularly important for modulation.

Static audit of the supplied comparison pipeline

  • sectionStatic audit of the supplied comparison pipelineStatic audit of the supplied comparison pipeline · lines 1157–1230
    Open as its own page

    The findings below concern the supplied source, not an executed reproduction or an assumed later version.

    • Matching tolerance is ignored. find_iso_dose_match accepts a tolerance but returns the nearest candidate regardless of its distance.

    • The no-overlap fallback is not matching. Pooled percentiles do not establish the common support (eq:commonsupport). Even min–max overlap does not establish coverage of a discrete grid.

    • Regrowth at zero is nonzero. The expression max(1, int(regrow_fraction * num_pruned)) activates at least one position in each eligible layer at fraction zero. Equation (eq:regrowcount) repairs the endpoint.

    • Quantile and kth-value ties violate exact counts. Magnitude thresholding can retain or delete extra tied positions. Pruning at sparsity one can retain maximum-magnitude entries. The active-weight challenge can delete more than its requested count through the <= threshold rule.

    • Eligibility can be lost. The main magnitude-pruning method overwrites masks using all stored weights. If a threshold is zero, previously inactive zero positions may be marked active. A corrected deletion operation restricts eligibility to the current mask and prohibits implicit regrowth.

    • The allocation flag is ineffective. The accepted per_layer argument does not implement a global branch. An implementation should supply that branch or reject it explicitly.

    • Several configured controls do not govern the default matching pipeline. The primary metric remains L1 even when a norm-choice variable exists. The configured target-dose list is replaced by generated targets. The declared learning-rate grid is not passed to the default adaptation sweep, which uses one rate.

    • Sweep sparsity is stage-misaligned. The stored sparsity is obtained after secondary pruning, whereas the displacement metric and acute outcomes concern the pre-challenge checkpoint. Both stages must be named separately.

    • The two challenge procedures differ. The main experiment uses a capped overall target sparsity followed by layer-wise quantile pruning. The sweeps remove an active-weight fraction using kth-value thresholding. They need not implement the same integer intervention.

    • Bias, activation, and damping changes are unpriced. They can affect predictions without contributing to the weight metric. “No structural changes” should mean mask preservation, not absence of other implementation changes.

    • Tanh precedes noise. The deterministic signal is bounded; the stressed hidden state is not, by Proposition prop:tanh.

    • Ambient scoring is unsigned. The accumulated score is a sum of absolute minibatch derivatives. It is neither the signed gradient of the averaged loss nor the descent update of Theorem thm:descent.

  • sectionStatic audit of the supplied comparison pipelineStatic audit of the supplied comparison pipeline · lines 1230–1273
    Open as its own page

    • Pre-existing gradients are not cleared before the first scoring backward pass. Fresh clones normally begin with no gradients, but repeated uses of the interface can add an old gradient to the first score. Clear gradients before every scoring pass and restore state in a finally block.

    • Starting tensors do not specify complete state. Modulation attributes, masks, phase, optimizer conventions, and stream states must also be saved or reset explicitly.

    • Global randomness links branches to their execution order. Initialization, shuffling, gradient sampling, regrowth, and evaluation consume shared randomness. Additional evaluations can change later checkpoints. This invalidates a claimed paired replay, though shared randomness alone is not a theorem of biased population expectations.

    • Evaluation mutates the stress attribute. The source restores it to zero rather than restoring its incoming value. The two evaluation functions otherwise have the same computation; their difference is the retained model modulation.

    • Printed clinical conclusions are unconditional prose. The treatment-selection and combination tables are not consequences of validated comparison statistics. They are excluded from the repaired evidence output.

    • Durability and onset are not identified. Preset epoch counts are not biological times. One additional pruning challenge is not a longitudinal relapse model. Different training lengths and adaptation costs require explicit resource accounting.

    The official software documentation also distinguishes reproducibility within a controlled environment from guarantees across releases and platforms PyTorchRandom. Stable sorting provides the declared tie rule PyTorchArgsort. No software-documentation statement is a biological certificate.

A separately defined finite quantum stochastic network

  • sectionState space and generatorA separately defined finite quantum stochastic network › State space and generator · Psy03-A@1#eq:qgenerator · lines 1277–1312
    Open as its own page

    Let

    with a declared node basis. For real symmetric coupling data , a symmetric binary mask , and , define

    Its units are energy. For , let be the transition rate from to , and let . Write

    and define

    This is a finite quantum stochastic-network model, following the general coherent–incoherent architecture of quantum stochastic walks Whitfield. The model is not the –– classical network.

  • theoremTheorem: Physical finite evolutionA separately defined finite quantum stochastic network › State space and generator · Psy03-A@1#thm:physical · proof attached · lines 1313–1333
    Open as its own page

    For fixed coefficients, is a unique CPTP semigroup. The same physical conclusion holds for a finite piecewise-continuous time-dependent coefficient family with nonnegative rates and self-adjoint Hamiltonians.

    Proof. The jump operators are and . Equation (eq:qgenerator) has finite GKSL form, so the standard finite-dimensional generator theorem applies GKS,Lindblad. For time-dependent coefficients, approximate on compact intervals by piecewise-constant physical generators. Their channel products converge to the unique finite linear-ODE propagator; complete positivity and trace preservation are closed under this norm limit.

  • definitionDefinition: Quantum intervention counterpartsA separately defined finite quantum stochastic network › State space and generator · lines 1335–1343
    Open as its own page

    Pruning removes declared Hamiltonian edges or jump rates. Regrowth restores permitted couplings or jump operators. Noise adaptation optimizes a separately specified control under a declared noise schedule. Dynamical modulation introduces specified physical dissipative or coherent controls. A subsequent challenge changes the declared couplings or rates.

  • sectionState space and generatorA separately defined finite quantum stochastic network › State space and generator · lines 1343–1349
    Open as its own page

    No map from a classical modulation number to these quantum controls is inferred. Dissipation, like classical damping, does not universally improve a task.

  • propositionProposition: A normalized ReLU rule is not a channel on unknown statesA separately defined finite quantum stochastic network › Why a normalized activation is not a quantum channel · Psy03-A@1#prop:nonlinear · proof attached · lines 1352–1376
    Open as its own page

    Applying coordinatewise ReLU to amplitudes and normalizing does not define a well-defined quantum-state transformation on all input rays. More generally, an arbitrary nonlinear normalized state rule is not a quantum channel.

    Proof. The vectors

    represent the same physical ray. Normalized ReLU sends the first to and the second to , so the rule is not ray invariant.

    Channels are linear on density operators. For example, the nonlinear rule sends to , although it fixes the two endpoint pure states. It is therefore not affine on their mixture.

  • sectionWhy a normalized activation is not a quantum channelA separately defined finite quantum stochastic network › Why a normalized activation is not a quantum channel · lines 1376–1385
    Open as its own page

    Preparing a state from a known classical vector is a different, potentially valid encoding procedure. It does not implement a nonlinear transformation of an unknown quantum input. Physical quantum neural-network constructions use quantum maps and explicitly specified measurement interfaces Beer,Watrous.

The exact classical boundary

  • theoremTheorem: Classical Markov boundary of the quantum networkThe exact classical boundary · Psy03-A@1#thm:classicalboundary, Psy03-A@1#eq:markov · proof attached · lines 1389–1425
    Open as its own page

    If , the node populations obey, for every initial density operator,

    They do not depend on initial node coherence. Diagonal inputs remain diagonal. Node dephasing has no effect on these population trajectories.

    With diagonal preparations, node-basis readouts, and interventions specified by nonnegative substochastic matrices whose complete sum is stochastic, every allowed record history has an exact classical continuous-time Markov realization.

    Proof. For , the gain term contributes to population . Its anticommutator removes from population . Summing gives (eq:markov). The node-projector dissipators have zero diagonal contribution. At a diagonal state they generate no off-diagonal terms.

    An intervention matrix acts on diagonal populations by . Its branch probability is the sum of the resulting entries. Between interventions, the Markov propagator acts by a stochastic matrix. Products of these matrices give exactly the same unnormalized history populations and record probabilities as the quantum maps. Induction proves the complete-history claim.

  • sectionThe exact classical boundaryThe exact classical boundary · lines 1425–1443
    Open as its own page

    A diagonal Hamiltonian also preserves this boundary. The theorem does not include arbitrary coherent interventions or phase-sensitive readouts. Such operations can leave the specified classical observation class.

    For nonzero Hamiltonian,

    so coherence can influence populations. That fact motivates, but does not alone prove, a task improvement.

    Quantum notation, diagonal state variables, and dissipator symbols are therefore not by themselves a quantum resource certificate.

Complete instruments and operational intervention budgets

  • sectionComplete record semanticsComplete instruments and operational intervention budgets › Complete record semantics · Psy03-A@1#eq:history · lines 1447–1479
    Open as its own page

    A finite instrument is a family of CP trace-nonincreasing maps whose sum is trace preserving DaviesLewis. Its complete output is

    It retains both the record and the unnormalized residual state. Failure, preparation loss, and erasure are explicit branches.

    For a Markov sequence,

    Adaptive choices are functions of recorded history. For retained environmental memory, the joint state rather than a reset channel must be propagated.

    Equal effects need not mean equal instruments. For example,

    have equal record probabilities but different residual states.

  • theoremTheorem: Complete-process overlapComplete instruments and operational intervention budgets › Complete record semantics · Psy03-A@1#thm:process · proof attached · lines 1480–1503
    Open as its own page

    Two specified Markov models with the same initial accessible state, conditional interval channels after every allowed history and setting, and complete instruments have equal record laws for all allowed adaptive experiments, including untouched references.

    For equal laws, every randomized binary test satisfies . In general,

    Proof. Induction in (eq:history) gives equality of every unnormalized branch, also after tensoring with a reference identity. For a test ,

    Bound the expectation difference by total variation.

  • sectionComplete record semanticsComplete instruments and operational intervention budgets › Complete record semantics · lines 1503–1509
    Open as its own page

    This is the independent finite interface corresponding to Psy02-B's complete-process record CheungPsy02B. One-time channel agreement without these process assumptions is insufficient.

  • sectionReference-stable budgetsComplete instruments and operational intervention budgets › Reference-stable budgets · lines 1510–1524
    Open as its own page

    Use

    For a declared interval and common input/output spaces, define

    This is reference-assisted operational displacement, not drug dose.

  • propositionProposition: Generator-to-channel budgetComplete instruments and operational intervention budgets › Reference-stable budgets · Psy03-A@1#prop:dynamic, Psy03-A@1#eq:dynamic · proof attached · lines 1525–1567
    Open as its own page

    For bounded time-dependent generators with CPTP propagators,

    For generators (eq:qgenerator) in a common node basis,

    Either bound may be truncated at one.

    Proof. Variation of constants gives the difference as

    Composition with channels contracts the diamond norm Watrous. This is the same bounded-generator interface recorded in Psy02-B CheungPsy02B.

    For the component estimate,

    Each displayed jump or projector has operator norm one. Substitute in (eq:dynamic).

  • sectionReference-stable budgetsComplete instruments and operational intervention budgets › Reference-stable budgets · lines 1567–1572
    Open as its own page

    Adding a scalar identity to the Hamiltonian changes no generator. One can correspondingly minimize the Hamiltonian norm allowance over such scalar shifts.

  • propositionProposition: Finite matrix-unit certificationComplete instruments and operational intervention budgets › Reference-stable budgets · Psy03-A@1#prop:matrixunits · proof attached · lines 1573–1604
    Open as its own page

    For two channels on a -dimensional common input, if

    then

    For complete instruments, replace the norm by the sum of branch norms.

    Proof. For a referenced state , positivity gives , where . Hence

    The referenced output difference has trace norm at most . The channel-difference diamond norm can be optimized over referenced states Watrous. For instruments, use their block-diagonal complete output.

  • sectionReference-stable budgetsComplete instruments and operational intervention budgets › Reference-stable budgets · lines 1604–1612
    Open as its own page

    For multi-interval experiments, operational errors must be charged at every interval and complete instrument. A telescoping sum bounds the complete experiment error by the sum of these errors. An endpoint channel budget alone does not determine every intervention-dependent history.

Exact coherence-sensitive pilots

  • sectionPhase-sensitive classification under dephasingExact coherence-sensitive pilots › Phase-sensitive classification under dephasing · Psy03-A@1#eq:dephchannel · lines 1616–1648
    Open as its own page

    On , let

    Define

    Then

    For the equal-prior binary task, encode labels by

    and measure with the complete projective instrument

  • theoremTheorem: Exact phase-resource performanceExact coherence-sensitive pilots › Phase-sensitive classification under dephasing · Psy03-A@1#thm:phase · proof attached · lines 1649–1680
    Open as its own page

    The binary classification success is

    For the selected coherence comparison

    The trace-distance witness has the same value.

    Every diagonal preparation obtained by dephasing either task input is , and carries no information about the label. Consequently its optimal equal-prior task success is .

    Proof. Equation (eq:dephchannel) preserves populations and multiplies off-diagonal entries by . Thus the correct phase-projector probability is . The coherent-minus-dephased output is , with eigenvalues , proving both witness values. The two dephased task states are identical, so no output measurement can distinguish their labels.

  • sectionPhase-sensitive classification under dephasingExact coherence-sensitive pilots › Phase-sensitive classification under dephasing · lines 1680–1699
    Open as its own page

    This supplies a genuine phase-sensitive observable in the newly defined model. The exponential form resembles the independent pilot in Psy02-B; no carrier identification is inferred from that resemblance CheungPsy02A,CheungPsy02B.

    For this fixed task, reducing at fixed strictly improves success. The exact operational displacement is

    Indeed (eq:dephchannel) expresses the difference as a scalar multiple of , whose half-diamond norm is one. For , the success improvement equals this distance.

  • theoremTheorem: Operational-budget ranking counterexampleExact coherence-sensitive pilots › Equal operational distance is not equal utility · Psy03-A@1#thm:equalop · proof attached · lines 1702–1736
    Open as its own page

    For , let

    Both unitary channels have distance from identity:

    For the phase classification task of Theorem thm:phase, their successes are nevertheless

    Proof. For either Pauli ,

    Its modulus is at least , with equality at a state of zero -expectation. The same expression holds for the reduced state of a referenced pure input. The pure-output trace distance is the square root of one minus the squared overlap, giving exactly .

    The -eigenstates acquire only phases under . Under , the overlap with their correct -eigenstate has squared modulus .

  • sectionEqual operational distance is not equal utilityExact coherence-sensitive pilots › Equal operational distance is not equal utility · lines 1736–1742
    Open as its own page

    Operational displacement controls distinguishability, not its direction relative to the task. Neither equal nor equal establishes universal comparison fairness.

  • sectionCoherence converted to a node populationExact coherence-sensitive pilots › Coherence converted to a node population · lines 1743–1760
    Open as its own page

    A phase-sensitive output is not necessary when coherent evolution converts phase into populations. Take

    Prepare

    and use the node effect .

  • theoremTheorem: Exact node-record repair pilotExact coherence-sensitive pilots › Coherence converted to a node population · Psy03-A@1#thm:nodepilot, Psy03-A@1#eq:nodecontrast · proof attached · lines 1761–1810
    Open as its own page

    For , write

    The coherence-sensitive node contrast is

    It is positive for .

    For the equal-prior inputs , node readout with labels assigned to has success

    Removing the coupling, , gives success . Restoring a coupling in the stated positive interval therefore gives a strict task improvement.

    There is no global monotonicity in coupling strength or sensing time: the sine term can change sign.

    Proof. For the initial Bloch vector, its components satisfy

    Thus

    whose underdamped solution is . The reference remains fixed. The node contrast is . The opposite input gives the opposite , proving the binary success formula. At zero coupling the initial populations stay equal.

  • sectionCoherence converted to a node populationExact coherence-sensitive pilots › Coherence converted to a node population · Psy03-A@1#eq:nodecalibration · lines 1810–1835
    Open as its own page

    This is a small Hamiltonian-edge restoration example, not a pharmacological regrowth theorem.

    For a calibrated rectangle

    choose and put

    Then

    The bound follows from , the frequency interval, and the minimum of sine on a subinterval of .

  • propositionProposition: Referenced dephasing is not specified by its marginalExact coherence-sensitive pilots › A reference diagnostic that a single marginal misses · Psy03-A@1#prop:Bell · proof attached · lines 1838–1871
    Open as its own page

    For Bell input , the accessible one-qubit marginal under is for every . The joint state is

    Its partial-transpose spectrum is

    so its negativity is .

    The optimal deterministic recovery error is

    Proof. Partial trace and partial transpose give the stated matrices. For recovery, the two noisy -eigenstate outputs have trace distance . Any decoder of half-diamond error must satisfy , by contraction and the triangle inequality. Identity decoding attains using (eq:dephchannel).

  • sectionA reference diagnostic that a single marginal missesExact coherence-sensitive pilots › A reference diagnostic that a single marginal misses · lines 1871–1877
    Open as its own page

    The distinction agrees with the finite diagnostic records in Psy02-A and Em05-A CheungPsy02A,CheungEm05A. The referenced dephasing experiment is independently defined here; the signed extraction carrier of Em05-A is not imported.

Robust complete-record contrasts and identification

  • sectionA calibrated forward detectorRobust complete-record contrasts and identification › A calibrated forward detector · lines 1881–1896
    Open as its own page

    Use the complete phase-projective instrument, preparation success , independent observation probability , and symmetric assignment error . Record all failure and erasure outcomes. For the score,

    define

  • theoremTheorem: Exact calibrated score and robust gapRobust complete-record contrasts and identification › A calibrated forward detector · Psy03-A@1#thm:gap, Psy03-A@1#eq:interventiongap · proof attached · lines 1897–1940
    Open as its own page

    For successful coherent phase preparation and dephasing,

    For its population-matched dephased preparation, .

    For a rectangular coherent family

    the exact ideal oriented score gap from the dephased family is

    If the two actual complete attempted-run laws have uniform total-variation errors , then

    is a lower bound on their oriented expectation gap.

    For two rectangular coherent intervention families, a sufficient post-minus-pre gap is

    Proof. The ideal signed phase outcome has mean . Assignment multiplies it by ; preparation and observation multiply it by . Neutral scores have zero centered contribution. Take the worst-case rectangular endpoints. A -score expectation changes by at most total variation.

  • sectionA calibrated forward detectorRobust complete-record contrasts and identification › A calibrated forward detector · lines 1940–1951
    Open as its own page

    The node-record contrast (eq:nodecalibration) can be treated with the same complete detector, replacing the underlying contrast by that node contrast.

    The projector instrument has the mathematical dilation

    No engineering implementation in neural tissue is thereby supplied.

  • theoremTheorem: Shared-generator identification obstructionRobust complete-record contrasts and identification › Complete-process nuisance overlap · Psy03-A@1#thm:overlap · proof attached · lines 1954–1972
    Open as its own page

    Suppose two mechanism families have, after every allowed history and setting,

    where , , and apparatus and initial accessible states are common. If , the families contain a pair with identical complete records.

    Proof. Choose and . The conditional generators agree everywhere in the experiment. Theorem thm:process applies.

  • sectionComplete-process nuisance overlapRobust complete-record contrasts and identification › Complete-process nuisance overlap · lines 1972–1979
    Open as its own page

    This is the calibrated overlap logic recorded in En01-B and Psy02-B CheungEn01B,CheungPsy02B. Increasing sample size cannot distinguish an overlapping pair. The same nuisance coefficient must reproduce all settings; setting-by-setting refitting is a different family.

  • theoremTheorem: Bounded complete-record testRobust complete-record contrasts and identification › Sampling a retained gap · Psy03-A@1#thm:test · proof attached · lines 1982–2013
    Open as its own page

    If actual null scores have mean at most , alternative scores have mean at least , and , then independent attempted runs with a midpoint threshold have

    Thus

    controls each error by .

    The same bound holds for dependent runs if the corresponding mean bounds hold conditional on every past record. Unconditional mean bounds alone are insufficient.

    Proof. For independence, apply Hoeffding's inequality at distance Hoeffding. For dependence, the conditional bounded-variable exponential bound is

    Iterate and optimize. Repeating one common Bernoulli outcome shows the failure under arbitrary dependence.

  • sectionSampling a retained gapRobust complete-record contrasts and identification › Sampling a retained gap · lines 2013–2018
    Open as its own page

    For a bound on the sum of both errors, replace by . Calibration failure probability is added separately.

  • sectionThree distinct quantum conclusionsRobust complete-record contrasts and identification › Three distinct quantum conclusions · lines 2019–2042
    Open as its own page
    1. Resource sensitivity. A nonzero contrast certifies dependence on the specified node-basis coherence under the admitted controls and detector.

    2. Alternative-family separation. A positive robust gap separates only the declared accessible record families. A population-only alternative cannot reproduce the phase-label task, but an alternative carrying the label in an extra classical register may do so.

    3. Computational advantage. A speed, sample, memory, or query advantage needs a task family, input-access model, baseline class, and resource accounting. The two-level pilot proves none of these asymptotic claims.

    A coherence resource can also worsen an oriented score: replacing by reverses the sign of the contrast. A resource statement therefore needs an orientation and task, not just a nonzero absolute magnitude.

Random streams, causal claims, and non-transfer

  • sectionRandom streams, causal claims, and non-transferRandom streams, causal claims, and non-transfer · lines 2044–2053
    Open as its own page

    A controlled classical potential outcome can be written

    where is the training/scoring/random-initialization input and is the evaluation input. Paired interventions specify the coupling of these inputs.

  • propositionProposition: Evaluation isolation and paired replayRandom streams, causal claims, and non-transfer · Psy03-A@1#prop:rng · proof attached · lines 2054–2067
    Open as its own page

    Suppose training is a deterministic function of the complete starting state and its named stream . If evaluation uses separate streams and mutates no training state, inserting an evaluation cannot change a later training checkpoint. If two executions use the same starting state, algorithm, and stream realization, their checkpoints agree.

    Proof. The training function receives identical arguments. An isolated evaluation changes none of them.

  • sectionRandom streams, causal claims, and non-transferRandom streams, causal claims, and non-transfer · lines 2067–2093
    Open as its own page

    This is a within-model dependency statement, not a biological causal theorem. A pseudorandom seed is an implementation device, not a proof of mathematical independence. The intended stochastic law and the software realization must both be reported.

    Cheung's VII-J distinguishes scheduled support from actual influence and physical causal containment CheungVIIJ. For a finite tensor-factor endpoint channel, no influence from all local trace-preserving interventions on is equivalent to factorization

    The criterion follows by comparing identity with replacement of by its maximally mixed state. It does not follow from a program arrow alone.

    The quantum node basis is not itself a tensor decomposition into spatial subsystems. Graph connectivity does not supply a relativistic causal cone. A physical locality claim requires a separate embedding and appropriate support or propagation theorem.

  • propositionProposition: Non-transfer of the three modelsRandom streams, causal claims, and non-transfer · Psy03-A@1#prop:nontransfer · proof attached · lines 2094–2113
    Open as its own page

    The supplied classical intervention maps do not define the quantum generator (eq:qgenerator). The quantum phase or node contrast does not identify the classical mask, activation, damping, or optimizer schedule. Neither construction establishes an antidepressant mechanism.

    Proof. The classical objects are stochastic functions of real vectors and augmented training state. The quantum objects are linear CP maps on density operators with separately specified encodings and instruments. No correspondence map and error certificate identifying these domains or predictions has been supplied. A biological mechanism additionally requires empirical state, intervention, and observation correspondence absent from both definitions.

  • sectionRandom streams, causal claims, and non-transferRandom streams, causal claims, and non-transfer · lines 2113–2128
    Open as its own page

    Em04-A's vacuum-plus-single-excitation result is a useful architectural source record for a different dissipative carrier CheungEm04A. Em06-B's residual-state concentration and fluctuations concern a different scalar representation CheungEm06B. Neither is a hidden premise of the finite quantum network.

    No Wick-square contact class, Coulomb mass functional, inherited characteristic product, or gravitational Ward identity is used here. The I3/J2 construction and downstream admission boundary documented in Psy02-B are not opened by a finite quantum channel CheungPsy02B.

Discussion and mathematical release

  • sectionDiscussion and mathematical releaseDiscussion and mathematical release · lines 2130–2155
    Open as its own page

    The source's three operations are meaningful computational interventions, but their displacement metric omits important controls. The most defensible comparison records the complete budget vector, uses exact structural counts, matches only on supported targets, and distinguishes acute, challenged, and modulation-removed checkpoints.

    The positive classical results are conditional: a signed sparse update can decrease a smooth local loss; a margin can certify stress survival; a complete perturbation allowance can certify a ranking. They do not prove that the source's three default protocols have a universal order.

    The quantum extension gives exact additional mathematics. Its population-only restriction is classical. Its phase-sensitive task, node conversion, and Bell-reference diagnostics use genuinely noncommuting state and measurement structures. They remain finite mathematical experiments, not evidence of quantum processing in the supplied simulation or in a biological antidepressant mechanism.

  • theoremTheorem: Psy03-A releaseDiscussion and mathematical release · Psy03-A@1#thm:release · proof attached · lines 2156–2187
    Open as its own page

    For the objects and hypotheses printed here:

    1. weight-only dose is insufficient, and its representation dependence and omitted controls have explicit counterexamples;

    2. damped stress paths, margin certificates, full coupled parameter comparisons, and accuracy allowances hold;

    3. fixed-weight mask identities and the signed sparse-gradient descent theorem hold;

    4. matched-target and checkpoint rankings obey their stated support, calibration, and statistical conditions;

    5. the independently declared finite quantum network is physical and has the exact classical boundary;

    6. its operational budgets, complete instruments, phase task, node-conversion pilot, and reference diagnostics have the stated formulas;

    7. complete-process overlap obstructs identification, whereas a positive calibrated complete-record gap gives the stated test.

    No executed treatment ranking, quantum computational advantage, biological mechanism, clinical recommendation, or inherited analytic admission is established.

    Proof. The independent proofs appear in the preceding sections. The source audit identifies the deviations between the original pipeline and a valid matched-budget interpretation. The unconstructed correspondences and unrestricted rankings are not hypotheses of any positive theorem.

Declarations

  • sectionDeclarationsDeclarations · lines 2189–2219
    Open as its own page

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

    . The paper reports no new human or animal experiment.

    and code availability. The supplied source snapshot is identified in Cheung068Code. The analytic examples require no empirical dataset. The appended code is a compact proposed repair core, not an executed reproduction of the original experiment.

    provenance. The work contains analytic arguments, a static source audit, and unexecuted repair listings. Compilation, numerical regression, formal proof checking, and biological validation are separate activities. No artifact hash, executed pass flag, or reproduced performance table is invented.

    boundary. The paper does not advise selecting, combining, discontinuing, or timing antidepressant treatments. The source's drug-class names are limited analogies for computational operations, not treatment recommendations.

A compact CPU repair core

  • sectionA compact CPU repair coreA compact CPU repair core · lines 2221–2242
    Open as its own page

    The listing below is independently extractable Python. It reproduces the forward ordering and provides exact-count mask operations, explicit streams, phase-boundary checkpoints, and stage-separated evaluation. It is not a full rerun of all original sweeps.

    The code uses stored zero weights for ambient regrowth scoring. Normal training reapplies masks after every Adam step. The optimizer is fresh for each call, matching the source's reset convention. The returned optimizer and generator states support provenance; the phase checkpoint below is used only when a fresh optimizer will be created.

    Stable sorting implements flattened-index tie breaking PyTorchArgsort. The implementation is CPU-specific. Software version and environment remain part of a reproduction record PyTorchRandom.

  • listingListing: ListingA compact CPU repair core · lines 2243–2635
    Open as its own page
    import copy
    import math
    from fractions import Fraction
    import torch
    from torch import nn
    
    def fraction01(value):
        value = float(value)
        if not math.isfinite(value) or not 0.0 <= value <= 1.0:
            raise ValueError("fraction must be finite and in [0, 1]")
        return Fraction(str(value))
    
    def ceil_fraction(value):
        return (
            value.numerator + value.denominator - 1
        ) // value.denominator
    
    def generator(seed):
        return torch.Generator(device="cpu").manual_seed(int(seed))
    
    class CheckedNetwork(nn.Module):
        def __init__(self, widths=(512, 512, 256), seed=0):
            super().__init__()
            self.widths = tuple(widths)
            # Constructor does not advance the caller's global stream.
            with torch.random.fork_rng(devices=[]):
                torch.manual_seed(int(seed))
                self.fc1 = nn.Linear(2, widths[0])
                self.fc2 = nn.Linear(widths[0], widths[1])
                self.fc3 = nn.Linear(widths[1], widths[2])
                self.fc4 = nn.Linear(widths[2], 4)
            self.a = 1.0
            self.activation = "relu"
    
        def forward(self, x, sigma=0.0, noise_generator=None):
            if not 0.0 <= self.a <= 1.0:
                raise ValueError("damping outside [0, 1]")
            if sigma < 0 or not math.isfinite(float(sigma)):
                raise ValueError("invalid stress")
            if self.activation not in ("relu", "tanh"):
                raise ValueError("unsupported activation")
            phi = (
                torch.relu if self.activation == "relu"
                else torch.tanh
            )
            h = x
            for layer in (self.fc1, self.fc2, self.fc3):
                h = phi(layer(h))
                if sigma > 0:
                    if noise_generator is None:
                        raise ValueError("explicit noise generator required")
                    h = h + sigma * torch.randn(
                        h.shape, dtype=h.dtype,
                        generator=noise_generator
                    )
                h = self.a * h
            return self.fc4(h)
    
    class MaskLedger:
        def __init__(self, model, masks=None):
            self.model = model
            weights = {
                name: p for name, p in model.named_parameters()
                if name.endswith("weight")
            }
            if masks is not None and set(masks) != set(weights):
                raise ValueError("mask keys do not match weights")
            self.masks = {}
            for name, p in weights.items():
                if masks is None:
                    mask = torch.ones_like(p, dtype=torch.bool)
                else:
                    raw = masks[name]
                    if raw.shape != p.shape:
                        raise ValueError("mask shape mismatch")
                    if not bool(((raw == 0) | (raw == 1)).all()):
                        raise ValueError("nonbinary mask")
                    mask = raw.bool().clone()
                self.masks[name] = mask
            self.apply()
    
        @torch.no_grad()
        def apply(self):
            for name, mask in self.masks.items():
                p = self.model.get_parameter(name)
                p.mul_(mask.to(p.dtype))
    
        def density(self):
            kept = sum(int(m.sum()) for m in self.masks.values())
            total = sum(m.numel() for m in self.masks.values())
            return kept / total
    
        @torch.no_grad()
        def keep_counts(self, counts):
            # Validate every requested deletion before changing state.
            if set(counts) != set(self.masks):
                raise ValueError("incomplete count specification")
            for name, k in counts.items():
                p = self.model.get_parameter(name)
                active = int(self.masks[name].sum())
                if not isinstance(k, int) or not 0 <= k <= active:
                    raise ValueError("invalid count or implicit regrowth")
                if not bool(torch.isfinite(p).all()):
                    raise ValueError("non-finite weights")
    
            for name, k in counts.items():
                p = self.model.get_parameter(name)
                old = self.masks[name].reshape(-1)
                eligible = torch.nonzero(old).flatten()
                values = p.detach().reshape(-1)[eligible].abs()
                order = torch.argsort(
                    values, descending=True, stable=True
                )
                new = torch.zeros_like(old)
                new[eligible[order[:k]]] = True
                self.masks[name] = new.reshape_as(p)
                assert int(new.sum()) == k
                assert not bool((new & ~old).any())
            self.apply()
    
        def prune_to_density(self, density):
            d = fraction01(density)
            counts = {
                name: ceil_fraction(d * mask.numel())
                for name, mask in self.masks.items()
            }
            self.keep_counts(counts)
    
        def secondary_prune(self, fraction):
            f = fraction01(fraction)
            counts = {}
            for name, mask in self.masks.items():
                active = int(mask.sum())
                amount = f * active
                remove = amount.numerator // amount.denominator
                counts[name] = active - remove
            self.keep_counts(counts)
    
        @torch.no_grad()
        def regrow(self, fraction, scores, init_scale, seed):
            r = fraction01(fraction)
            if init_scale < 0 or not math.isfinite(init_scale):
                raise ValueError("invalid initialization scale")
            plan = {}
            for name, mask in self.masks.items():
                eligible = torch.nonzero(~mask.reshape(-1)).flatten()
                amount = r * len(eligible)
                k = amount.numerator // amount.denominator
                plan[name] = (eligible, k)
    
            # Zero regrowth changes neither parameters nor random streams.
            if not any(k for _, k in plan.values()):
                return {name: 0 for name in plan}
    
            for name, (eligible, k) in plan.items():
                score = scores[name]
                if score.shape != self.masks[name].shape:
                    raise ValueError("score shape mismatch")
                if not bool(torch.isfinite(score).all()):
                    raise ValueError("non-finite score")
    
            noise = generator(seed)
            result = {}
            for name, (eligible, k) in plan.items():
                p = self.model.get_parameter(name)
                values = scores[name].reshape(-1)[eligible]
                order = torch.argsort(
                    values, descending=True, stable=True
                )
                selected = eligible[order[:k]]
                self.masks[name].view(-1)[selected] = True
                p.view(-1)[selected] = init_scale * torch.randn(
                    (k,), dtype=p.dtype, generator=noise
                )
                result[name] = k
            self.apply()
            return result
    
    def gradient_scores(model, ledger, x, y, batch_size=128,
                        num_batches=30, order_seed=1000):
        if len(x) == 0 or len(x) != len(y):
            raise ValueError("invalid training sample")
        if batch_size <= 0 or num_batches <= 0:
            raise ValueError("positive batch controls required")
        scores = {
            name: torch.zeros_like(model.get_parameter(name))
            for name in ledger.masks
        }
        was_training = model.training
        order = torch.randperm(len(x), generator=generator(order_seed))
        used = 0
        try:
            ledger.apply()
            model.train()
            for start in range(0, len(x), batch_size):
                if used >= num_batches:
                    break
                idx = order[start:start + batch_size]
                model.zero_grad(set_to_none=True)
                # Stored inactive weights are zero; no mask multiplication
                # inside autograd blocks their ambient derivatives.
                logits = model(x[idx], sigma=0.0)
                nn.functional.cross_entropy(logits, y[idx]).backward()
                for name, mask in ledger.masks.items():
                    grad = model.get_parameter(name).grad
                    if grad is None:
                        raise ValueError("missing ambient gradient")
                    scores[name].add_(grad.detach().abs() * (~mask))
                used += 1
        finally:
            model.zero_grad(set_to_none=True)
            model.train(was_training)
        if used == 0:
            raise ValueError("no gradient batches")
        return {name: value / used for name, value in scores.items()}
    
    def fit(model, ledger, x, y, epochs, lr,
            initial_sigma=0.0, final_sigma=0.0,
            order_seed=2000, noise_seed=3000, batch_size=128):
        if not isinstance(epochs, int) or epochs < 0:
            raise ValueError("invalid epoch count")
        if len(x) == 0 or len(x) != len(y) or batch_size <= 0:
            raise ValueError("invalid training data")
        if lr <= 0 or not math.isfinite(lr):
            raise ValueError("invalid learning rate")
        if initial_sigma < 0 or final_sigma < 0:
            raise ValueError("invalid training-noise schedule")
        if epochs == 1 and initial_sigma != final_sigma:
            raise ValueError("one epoch cannot realize two endpoints")
    
        order_rng, noise_rng = generator(order_seed), generator(noise_seed)
        optimizer = torch.optim.Adam(model.parameters(), lr=lr)
        was_training = model.training
        losses, steps, examples = [], 0, 0
        try:
            for epoch in range(epochs):
                progress = epoch / (epochs - 1) if epochs > 1 else 0.0
                sigma = initial_sigma + progress * (
                    final_sigma - initial_sigma
                )
                order = torch.randperm(len(x), generator=order_rng)
                model.train()
                total_loss = 0.0
                for start in range(0, len(x), batch_size):
                    idx = order[start:start + batch_size]
                    optimizer.zero_grad(set_to_none=True)
                    logits = model(x[idx], sigma, noise_rng)
                    loss = nn.functional.cross_entropy(logits, y[idx])
                    loss.backward()
                    optimizer.step()
                    ledger.apply()
                    total_loss += float(loss.detach()) * len(idx)
                    steps += 1
                    examples += len(idx)
                losses.append(total_loss / len(x))
        finally:
            model.zero_grad(set_to_none=True)
            model.train(was_training)
    
        return {
            "losses": losses,
            "optimizer_steps": steps,
            "examples_processed": examples,
            "optimizer_state": copy.deepcopy(optimizer.state_dict()),
            "order_rng_state": order_rng.get_state().clone(),
            "noise_rng_state": noise_rng.get_state().clone(),
            "schedule": (initial_sigma, final_sigma, epochs),
            "optimizer_reset": True,
        }
    
    def phase_snapshot(model, ledger):
        # Valid at a boundary where a later fit creates a fresh optimizer.
        return {
            "weights_biases": {
                key: value.detach().clone()
                for key, value in model.state_dict().items()
            },
            "masks": {
                key: value.clone() for key, value in ledger.masks.items()
            },
            "a": model.a,
            "activation": model.activation,
            "widths": model.widths,
            "training": model.training,
        }
    
    def clone_phase(snapshot):
        model = CheckedNetwork(snapshot["widths"], seed=0)
        model.load_state_dict(snapshot["weights_biases"])
        model.a = snapshot["a"]
        model.activation = snapshot["activation"]
        model.train(snapshot["training"])
        ledger = MaskLedger(model, snapshot["masks"])
        return model, ledger
    
    @torch.no_grad()
    def budget(pre, model, ledger):
        state = model.state_dict()
        dw1 = dw2 = db1 = 0.0
        nw = nb = flips = 0
        for name, old in pre["weights_biases"].items():
            delta = (state[name] - old).double()
            if name.endswith("weight"):
                dw1 += float(delta.abs().sum())
                dw2 += float(delta.square().sum())
                nw += delta.numel()
                flips += int(
                    (ledger.masks[name] != pre["masks"][name]).sum()
                )
            elif name.endswith("bias"):
                db1 += float(delta.abs().sum())
                nb += delta.numel()
        return {
            "d_w": dw1 / nw,
            "d_2_code": math.sqrt(dw2) / nw,
            "d_2_rms": math.sqrt(dw2 / nw),
            "d_b": db1 / nb,
            "d_mask": flips / nw,
            "d_a": abs(model.a - pre["a"]),
            "activation_changed": (
                model.activation != pre["activation"]
            ),
        }
    
    @torch.no_grad()
    def assess(model, x, y, input_noise, stress, seeds,
               batch_size=1000):
        if len(x) == 0 or len(x) != len(y) or not seeds:
            raise ValueError("nonempty sample and seed bank required")
        if input_noise < 0 or stress < 0 or batch_size <= 0:
            raise ValueError("invalid evaluation controls")
        was_training = model.training
        all_correct = []
        try:
            model.eval()
            for seed in seeds:
                input_rng = generator(2 * int(seed))
                hidden_rng = generator(2 * int(seed) + 1)
                correct = []
                for start in range(0, len(x), batch_size):
                    xb = x[start:start + batch_size]
                    yb = y[start:start + batch_size]
                    if input_noise > 0:
                        xb = xb + input_noise * torch.randn(
                            xb.shape, dtype=xb.dtype, generator=input_rng
                        )
                    pred = model(xb, stress, hidden_rng).argmax(dim=1)
                    correct.append((pred == yb).double())
                all_correct.append(torch.cat(correct))
        finally:
            model.train(was_training)
        values = torch.stack(all_correct)
        return {
            "accuracy": float(values.mean()),
            "per_example_mean": values.mean(dim=0),
            "correctness": values,
            "seeds": tuple(seeds),
        }
    
    def evaluate_acute_and_challenge(
        model, ledger, pre, x, y, seeds,
        input_noise=1.0, stress=0.5, challenge_fraction=0.4
    ):
        ledger.apply()
        displacement = budget(pre, model, ledger)
        acute_density = ledger.density()
        acute = assess(
            model, x, y, input_noise, stress, seeds
        )
    
        challenged_model, challenged_ledger = clone_phase(
            phase_snapshot(model, ledger)
        )
        challenged_ledger.secondary_prune(challenge_fraction)
        challenged = assess(
            challenged_model, x, y, input_noise, stress, seeds
        )
    
        # The acute checkpoint is not mutated by the challenge.
        return {
            "budget_acute": displacement,
            "density_acute": acute_density,
            "density_challenged": challenged_ledger.density(),
            "accuracy_acute": acute["accuracy"],
            "accuracy_challenged": challenged["accuracy"],
            "challenge_drop": acute["accuracy"] - challenged["accuracy"],
            "paired_per_example_drop": (
                acute["per_example_mean"]
                - challenged["per_example_mean"]
            ),
        }
  • sectionA compact CPU repair coreA compact CPU repair core · lines 2635–2645
    Open as its own page

    The same evaluation seeds couple the raw Gaussian draws only when architecture, batching, and draw order agree. The code preserves those controls. No favorable variance reduction is assumed merely from pairing.

    For modulation removal, clone the acute checkpoint, set a=1.0 and activation="relu", and evaluate the clone. Record this as modulation removal, retaining its learned parameters.

Matching, reporting, and endpoint tests

  • sectionMatching, reporting, and endpoint testsMatching, reporting, and endpoint tests · lines 2647–2653
    Open as its own page

    The following continuation enforces the matching tolerance, uses explicit target values, and does not invent a pooled fallback. The caller supplies already budget-eligible candidate rows. A missing family leaves the comparison unmatched.

  • listingListing: ListingMatching, reporting, and endpoint tests · lines 2654–2751
    Open as its own page
    def choose_match(rows, target, tolerance, key="d_w"):
        if not math.isfinite(target) or target < 0:
            raise ValueError("invalid target")
        if not math.isfinite(tolerance) or tolerance < 0:
            raise ValueError("invalid tolerance")
        eligible = []
        for row in rows:
            value = float(row["budget_acute"][key])
            if not math.isfinite(value) or value < 0:
                raise ValueError("invalid displacement")
            distance = abs(value - target)
            if distance <= tolerance:
                eligible.append((distance, str(row["candidate_id"]), row))
        if not eligible:
            return None
        return min(eligible, key=lambda item: (item[0], item[1]))[2]
    
    def matched_comparisons(sweeps, targets, tolerance, key="d_w"):
        reports = []
        for target in targets:
            matches = {
                family: choose_match(rows, target, tolerance, key)
                for family, rows in sweeps.items()
            }
            reports.append({
                "target": float(target),
                "metric": key,
                "tolerance": tolerance,
                "status": (
                    "matched" if all(row is not None
                                     for row in matches.values())
                    else "unmatched"
                ),
                "matches": matches,
            })
        return reports
    
    def displacement_efficiency(improvement_fraction, displacement,
                                minimum_displacement=1e-6):
        if minimum_displacement <= 0:
            raise ValueError("positive denominator guard required")
        if not math.isfinite(displacement) or displacement < 0:
            raise ValueError("invalid displacement")
        if displacement < minimum_displacement:
            return None
        return improvement_fraction / displacement
    
    def endpoint_tests():
        # These tests are included but are not reported as executed.
        model = CheckedNetwork(widths=(2, 2, 2), seed=7)
        ledger = MaskLedger(model)
        ledger.prune_to_density(0.5)
        pre = phase_snapshot(model, ledger)
    
        zero_scores = {
            name: torch.zeros_like(model.get_parameter(name))
            for name in ledger.masks
        }
        before_global = torch.random.get_rng_state().clone()
        regrown = ledger.regrow(0.0, zero_scores, 0.03, seed=99)
        assert all(value == 0 for value in regrown.values())
        assert torch.equal(before_global, torch.random.get_rng_state())
        for name, tensor in pre["weights_biases"].items():
            assert torch.equal(model.state_dict()[name], tensor)
        for name, mask in pre["masks"].items():
            assert torch.equal(ledger.masks[name], mask)
    
        # Modulation can have zero weight displacement.
        model.a = 0.7
        changed = budget(pre, model, ledger)
        assert changed["d_w"] == 0.0
        assert changed["d_a"] > 0.0
    
        row = {
            "candidate_id": "candidate-0",
            "budget_acute": {"d_w": 0.02},
        }
        assert choose_match([row], 0.01, 0.001) is None
        assert choose_match([row], 0.02, 0.001) is row
    
        # Delete all active positions exactly.
        ledger.secondary_prune(1.0)
        assert ledger.density() == 0.0
        for name in ledger.masks:
            assert int(torch.count_nonzero(
                model.get_parameter(name)
            )) == 0
    
        # Restore all inactive positions, not "at least one".
        scores = {
            name: torch.zeros_like(model.get_parameter(name))
            for name in ledger.masks
        }
        ledger.regrow(1.0, scores, 0.0, seed=1)
        assert ledger.density() == 1.0
        # Structural activity may coexist with numerically zero weights.
  • sectionMatching, reporting, and endpoint testsMatching, reporting, and endpoint tests · lines 2751–2764
    Open as its own page

    The tests exercise exact mask endpoints, no random-stream consumption at zero regrowth, unpriced modulation, and matching rejection. They are not a numerical regression certificate.

    The repaired experiment should explicitly pass the configured learning-rate grid, metric, and targets. For the source's listed grids, the default one-rate adaptation sweep contains candidates across the three families. Using all five declared adaptation learning rates gives . These are candidate counts, not independent training-seed counts.

Submission-level experiment protocol

  • sectionSubmission-level experiment protocolSubmission-level experiment protocol · lines 2766–2806
    Open as its own page

    A computational application of the theorems should retain:

    1. the supplied source snapshot and immutable baseline artifact;

    2. data snapshots, labels, architecture, numerical precision, software versions, hardware, and determinism settings;

    3. complete phase state, masks, activation, damping, and optimizer-reset policy;

    4. named training-order, scoring, regrowth, input-noise, and hidden-noise streams;

    5. layerwise integer deletion and regrowth counts, with a declared tie rule;

    6. the complete intervention budget vector and separate training cost ledger;

    7. all candidate configurations, including failed and unmatched ones, rather than only favorable matches;

    8. acute, challenged, and modulation-removed checkpoints, with separate displacement and density labels;

    9. an independent validation or simultaneous-selection procedure;

    10. absolute post-challenge outcomes and paired degradation estimates;

    11. repeated training seeds if claims concern training-procedure averages;

    12. margins, operator norms, and implementation errors required by the claimed certificate.

    A quantum application additionally requires:

    1. a specified encoding and preparation class;

    2. Hamiltonian and dissipator normalization, time interval, and accessible control class;

    3. complete instruments and failure branches;

    4. referenced channel or matrix-unit implementation certificates;

    5. calibrated nuisance alternatives;

    6. an explicit task and resource model before any advantage claim.

    No complete biological correspondence dossier is supplied by the analytic construction.

Claim and source ledger

  • sectionClaim and source ledgerClaim and source ledger · lines 2808–2866
    Open as its own page
    of the main conclusions.
    ClaimStatusExact scope
    ClaimStatusExact scope
    Weight displacement is mechanism-agnostic intervention doseExcludedZero-dose and rescaling counterexamples; budget convention required.
    Damping necessarily improves stress accuracyNot establishedDamped noise bound is proved; clean margins also change.
    Tanh bounds the noisy hidden stateFalse for the source orderingNoise is added after tanh.
    Gradient-ranked random regrowth guarantees improvementNot establishedA different signed update has a conditional local-loss guarantee.
    Nearest candidate is an iso-dose matchFalse without tolerance supportMatching is rejected outside the declared tolerance.
    A default computational treatment ranking is provedNot assertedActual candidate outcomes were not executed here.
    Quantum stochastic-network evolution is physicalProved finite modelNonnegative rates and a specified self-adjoint Hamiltonian.
    Population-only quantum notation requires a quantum explanationExcluded in the stated submodelExact classical Markov and instrument realization.
    Input coherence changes a specified recordProved finite pilotsPhase readout and coherent population conversion.
    Equal operational budget fixes utilityFalseEqual-distance unitary channels have different task performance.
    Positive contrast excludes every classical modelNot assertedSeparation is relative to the supplied encoding and alternative class.
    Quantum computational advantageOpenRequires scalable task and resource definitions.
    Drug mechanism or clinical rankingNot establishedComputational analogy does not supply biological correspondence.
    Inherited characteristic coefficient admissionOutside scopeNo I3/J2 operation or downstream analytic gate is constructed.

Mathematical debugging ledger

  • sectionMathematical debugging ledgerMathematical debugging ledger · lines 2868–2931
    Open as its own page
    1. Damping order. The noise term is multiplied immediately by , giving , not .

    2. Common noise cancellation. It applies only when the noise coefficient is common. Different damping gives a residual even at common .

    3. L2 normalization. Norm divided by is not RMS.

    4. Loss versus accuracy. A smooth loss descent theorem does not establish a held-out classification or stress ranking.

    5. Gradient type. Ambient inactive-coordinate derivatives differ from derivatives blocked by an in-forward mask.

    6. Zero regrowth. The repaired endpoint is exactly zero; hard count discontinuities elsewhere remain.

    7. Density stage. Acute displacement is not paired with a post-challenge mask count.

    8. Matching support. A span overlap or a pooled percentile is not finite-grid support.

    9. Statistical units. Repeated noise draws do not multiply the number of independent population inputs.

    10. Dephasing normalization. The generator gives off-diagonal decay .

    11. Markov-rate orientation. is the rate from to , fixing both terms in (eq:markov).

    12. Operational budget. A generator integral controls a specified interval channel. Complete histories need all interval and instrument errors.

    13. Coherence and utility. The contrast is oriented and task-specific; its sign can reverse.

    14. Graph versus subsystems. Node labels do not automatically define tensor-local interventions or a spacetime causal cone.

    15. Source relations. Landmark comparisons are not carrier identifications or automatic premises.

    16. Verification. Proof, compilation, numerical execution, regression, and clinical validation are distinct evidence types.

  • bibliographyReferencesMathematical debugging ledger · lines 2932–3151
    Open as its own page

    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; no clinical ranking is imported as a theorem.

    Cheung068Code

    N. Cheung, 068a_antidep_modes_v2.py. Version 2.0 source supplied in full for the present analysis, undated. The supplied snapshot defines the static audit. No executed reproduction or unexamined repository revision is asserted.

    CheungPruning

    N. Cheung, Phased pruning in neural networks recapitulates selectivity–fragility trade-offs in brain development. Scientific Reports (2026). Published online 13 July 2026. https://doi.org/10.1038/s41598-026-62244-5.

    CheungCliff

    N. Cheung, The synaptic pruning cliff: threshold-like network fragility under internal stress and efficient recovery in a computational model of depression. Preprints.org, version 1, posted 13 January 2026. Not peer reviewed. https://doi.org/10.20944/preprints202601.0805.v1.

    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 source records: thm:globalstress, thm:parameterstability, prop:rescaling, prop:equaldensity, thm:nesting, and prop:harddiscontinuity. No model identity with the present architecture is presumed.

    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 source records: prop:dephasing, prop:Bell, prop:instrument, and thm:nonidentifiable. The scalar and reduction carriers are not imported here.

    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, thm:overlap, prop:dynamic, thm:matrixunits, thm:gap, and prop:nontransfer. The inherited I3/J2 boundary remains outside this paper.

    CheungEm04A

    N. Cheung, Manuscript Em04-A. Em04-A-v2.tex, version 2, undated. Supplied exact vacuum-plus-single-excitation reduction, thm:reduction, lines 345–381; instrument consistency and analytical release excerpts. Enter Calculus Companion; documentary source record. A different zero-temperature XY-chain carrier.

    CheungEm06B

    N. Cheung, Manuscript Em06-B. Em06-B-v1.tex, version 1, undated. Supplied concentration criterion, thm:states, lines 739–806, and fluctuation and input-control records. Enter Calculus Companion; documentary source record. No scalar-to-network correspondence is asserted.

    CheungVIIJ

    N. Cheung, Manuscript VII-J. VII-J.tex, version 1, undated. Supplied exact no-signalling criterion, thm:nosignal, lines 373–417, and scheduled-support records. Enter Calculus Companion; documentary source record.

    CheungEn01B

    N. Cheung, Manuscript En01-B. En01-B-v2.tex, version 2, undated. Supplied calibrated overlap and oriented contrast records, thm:width, lines 1215–1266, and thm:contrast, lines 1518–1562. The nuisance class must be re-established for the selected experiment.

    CheungEm05A

    N. Cheung, Manuscript Em05-A. Em05-A-v1.tex, version 1, undated. Supplied full-transfer dephasing comparison, thm:fullNoise, lines 966–1052, and diagnostic separation, lines 1257–1298. The signed extraction channel is not identified with the present node model.

    EvciRigL

    U. Evci, T. Gale, J. Menick, P. S. Castro, and E. Elsen, Rigging the lottery: making all tickets winners. In Proceedings of the 37th International Conference on Machine Learning, Proceedings of Machine Learning Research 119 (2020), 2943–2952. https://proceedings.mlr.press/v119/evci20a.html.

    Tsuzuku

    Y. Tsuzuku, I. Sato, and M. Sugiyama, Lipschitz-margin training: scalable certification of perturbation invariance for deep neural networks. Advances in Neural Information Processing Systems 31 (2018). https://arxiv.org/abs/1802.04034.

    Whitfield

    J. D. Whitfield, C. A. Rodríguez-Rosario, and A. Aspuru-Guzik, Quantum stochastic walks: a generalization of classical random walks and quantum walks. Physical Review A 81 (2010), 022323. https://doi.org/10.1103/PhysRevA.81.022323. https://arxiv.org/abs/0905.2942. The published article's author order is used.

    Beer

    K. Beer, D. Bondarenko, T. Farrelly, T. J. Osborne, R. Salzmann, D. Scheiermann, and R. Wolf, Training deep quantum neural networks. Nature Communications 11 (2020), 808. https://doi.org/10.1038/s41467-020-14454-2. The earlier author manuscript is arXiv:1902.10445.

    GKS

    V. Gorini, A. Kossakowski, and E. C. G. Sudarshan, Completely positive dynamical semigroups of -level systems. Journal of Mathematical Physics 17 (1976), 821–825. https://doi.org/10.1063/1.522979.

    Lindblad

    G. Lindblad, On the generators of quantum dynamical semigroups. Communications in Mathematical Physics 48 (1976), 119–130. https://doi.org/10.1007/BF01608499.

    Watrous

    J. Watrous, The Theory of Quantum Information. Cambridge University Press, 2018. Author's manuscript: https://cs.uwaterloo.ca/ watrous/TQI/.

    DaviesLewis

    E. B. Davies and J. T. Lewis, An operational approach to quantum probability. Communications in Mathematical Physics 17 (1970), 239–260. https://doi.org/10.1007/BF01647093.

    Hoeffding

    W. Hoeffding, Probability inequalities for sums of bounded random variables. Journal of the American Statistical Association 58 (1963), 13–30. https://doi.org/10.1080/01621459.1963.10500830.

    PyTorchRandom

    PyTorch Contributors, Reproducibility. Official PyTorch documentation. https://docs.pytorch.org/docs/main/notes/randomness.html. Environment- and version-specific software guidance.

    PyTorchArgsort

    PyTorch Contributors, torch.argsort. Official PyTorch documentation. https://docs.pytorch.org/docs/main/generated/torch.argsort.html. Stable sorting preserves the input order of equal values.

    PyTorchModule

    PyTorch Contributors, torch.nn.Module: state_dict and load_state_dict. Official PyTorch documentation. https://docs.pytorch.org/docs/main/generated/torch.nn.Module.html. Parameters and persistent buffers are distinct from unregistered Python attributes and external manager state.