All manuscripts

Manuscript Psy03-D@1 · Psy03-D-v1.tex · 3e18951d

Psy03-D Hidden-Rule Observability and Intervention Identifiability in Modular Recurrent Networks: Switching Metrics, Masked Repair, and Certified Matching

Export Psy03-D-v1.tex

Specifies version 1 of a hidden-rule observability and intervention-identifiability framework for a modular recurrent rule-switching task and a separately defined finite quantum cue pilot. lem:uniform and thm:observability prove that point history does not reveal a stationary uncued rule. prop:duplicates records that two rule IDs implement the same label function. thm:ceiling gives the exact population optimum three quarters, attained by a memoryless classifier; oracle rule access gives accuracy one. thm:switchfrequencies separates rule-ID changes, label-function changes, and informative disagreements. prop:cues, thm:noisycues, and thm:feedback declare cued, delayed-cue, erased-cue, and causally ordered feedback protocols. def:oldfraction and prop:metriccounterexamples separate old-function responses from repeated responses. thm:sequencehoeffding, thm:ratio, and thm:recovery give sequence-level certificates; a zero denominator leaves a ratio unresolved. thm:maskedgradient explains zero stored derivatives at inactive linear weights. prop:reference separates mask reopening from recovery of a pre-pruning parameter. thm:cancel and prop:division give recurrent-protection counterexamples. def:statuses, thm:interpolation, and thm:isoacute distinguish executed matches, bracketed surrogates, and unsupported targets. cor:qobstruction and thm:qpilot keep the quantum cue pilot subordinate to the observation obstruction. thm:release is the analytical release. Psy01-A, Psy02-A, Psy02-B, Psy03-A, Psy03-B, Psy03-C, Em06-B, Em04-A, Em05-A, VII-J, and En01-B are documentary source records and are not premises. No newly executed numerical ranking is asserted. This is not a derivation of a cognitive construct, not a biological treatment mechanism, not neuronal quantum viability, and not conscious experience. This is not metric reconstruction, not Einstein dynamics, not holographic identification, not a Page curve, and not spacetime emergence. The inherited full characteristic map is not constructed. It does not repair XI-G. It does not close O.1. O.1 stays NOT_CLOSED. The series Route B is not discharged. XVI-N is not discharged. XV-B is not opened. XVI-P is registered and is not a premise. H2, I3, and J2 stay unresolved. Full spacetime emergence is not constructed. No quantum coefficient is admitted. No compilation is asserted. Numerical execution is not asserted. Independent execution is not asserted.

Front matter

  • abstractAbstractFront matter · lines 122–163
    Open as its own page

    We study whether a modular recurrent classifier receives the information required to identify a changing decision rule, and whether its reported switching statistics distinguish old-rule responses from generic response repetition. For an explicitly specified uncued task, the point sequence is independent of a stationary four-ID rule process. We prove that neither recurrent history nor any other rule-independent processing reveals the active rule. Two rule IDs implement the same label function. The resulting population classification optimum is exactly three quarters and is attained by a memoryless classifier; oracle rule access instead gives accuracy one. We calculate the distinction between rule-ID changes, label-function changes, and informative disagreements. Cued, delayed-cue, erased-cue, and causally ordered feedback tasks are separately declared protocols. A feedback elimination argument identifies effective rule functions while retaining the indistinguishability of duplicate IDs. Old-function response fractions, repeated-response fractions, flexibility ratios, and censored recovery-pattern summaries receive distinct definitions and sequence-level certificates. For structural repair, the masked-gradient identity explains why stored derivatives can be zero at inactive linear weights while effective-weight derivatives remain available. Reference-preserving restoration and score-allocation propositions separate mask reopening from recovery of a pre-pruning parameter. Executed matching, bracketed surrogate estimates, and unsupported targets are distinguished, with conditional interpolation and isoacute calibration bounds. A subordinate finite quantum cue pilot demonstrates retention and conditional rule execution without overcoming an absent observation channel. The supplied development brief and public implementation record are separated from independently proved objects and from unexecuted numerical claims. No cognitive-construct validation, treatment ranking, biological mechanism, quantum advantage, or inherited analytic admission is asserted.

  • sectionFront matterFront matter · lines 163–169
    Open as its own page

    Keywords: hidden rules; observability; recurrent networks; response repetition; masked gradients; structural repair; ratio certification; interpolation; computational psychiatry.

Question, contribution, and evidence boundary

  • sectionQuestion, contribution, and evidence boundaryQuestion, contribution, and evidence boundary · lines 171–245
    Open as its own page

    The central question is:

    Can the network infer the changing rule from the information it actually receives, and do the reported metrics measure rule persistence rather than generic repetition?

    Cheung's modular recurrent OCD model supplies the direct computational motivation CheungOCD. His pruning and intervention studies provide related structural-intervention precedents CheungPruning,CheungModes. These are computational studies, not premises identifying the present variables with clinical symptoms or treatment effects.

    The OCD article already acknowledges that two rule labels implement one function and that its immediate response-repetition metric does not prove persistence of the previous latent rule CheungOCD. The present contribution is an explicit observability theorem, the exact task reference, and independently specified interfaces for metrics, repair, and matching.

    Psy01-A separates cue information, masks, parameter geometry, margins, and observation semantics CheungPsy01A. Psy03-A separates intervention budgets and implemented functions CheungPsy03A. Psy03-B separates permanent structural restrictions from performance effects CheungPsy03B. Psy03-C separates recurrent dynamics, task information, and probe interpretation CheungPsy03C. Psy02-A and Psy02-B supply documentary precedents for complete records and mechanism-identification boundaries CheungPsy02A,CheungPsy02B. They are cited as source records and methodological precedents, not as unexplained premises. All positive results used here have printed objects and proofs.

    provenance. The development brief supplied for Psy03-D describes a modular rule-switching implementation DevelopmentBrief. The complete modular source was not included as an attachment in that supplied package. The public project file 069av2.py supplies the fourth rule and corresponding task generator CheungPublicCode. It is a mutable public record, not a certified byte-identical substitute for an unprovided attachment.

    The mathematical task below is completely specified. Its theorems do not depend on reconstructing an unavailable training run. Implementation observations are classified separately as reported source patterns, public-record checks, and independently proved consequences of those patterns.

    claim levels.

    1. Information limitation: what can be predicted from the admitted observations.

    2. Computational intervention effect: what changes under a specified implementation or training policy.

    3. Cognitive or biological interpretation: what a computational variable corresponds to outside the model.

    The first two require different certificates. The third requires an additional empirical correspondence.

    . We use rule-ID change, label-function change, informative disagreement, old-function response, repeated response, and recovery pattern. The source's clinical and pharmacological names are retained only as documentary labels.

  • sectionQuestion, contribution, and evidence boundaryQuestion, contribution, and evidence boundary · lines 245–252
    Open as its own page

    boundary. This is an analytic manuscript with a static source-pattern audit. No numerical ranking is generated or independently reproduced. No successful compilation, executed regression, machine proof, or clinical validation is represented as completed.

An explicitly specified hidden-rule task

  • sectionPoints, rules, and observationsAn explicitly specified hidden-rule task › Points, rules, and observations · Psy03-D@1#eq:ruleprocess, Psy03-D@1#eq:rules · lines 256–312
    Open as its own page

    Let

    At each step,

    where is uniform on , , and the point draws are independent. The public task uses , CheungPublicCode. The calculations below apply to every .

    Let be a switch schedule. It can be deterministic or random, but is independent of the point draws and of the initial rule. Let

    At a switch, add an independent uniform increment from modulo four:

    For , define

    These are the task mappings aligned with the public apply_rule record CheungPublicCode. The target is

    Optional ritual overwriting is disabled.

    The evaluator may retain for scoring. The predictor receives the point sequence, not these annotations.

  • assumptionAssumption: Uncued assessment interfaceAn explicitly specified hidden-rule task › Points, rules, and observations · Psy03-D@1#ass:uncued · lines 313–327
    Open as its own page

    The assessed checkpoint and its initial state are independent of the fresh assessment rule process. During an assessment sequence, the predictor receives no rule cue, target, correctness feedback, reward, or label-dependent parameter update. Its internal randomness is independent of the rule process.

    Predictions may depend on all points , the switch schedule if revealed, the fixed checkpoint, and independent randomness. Allowing the entire point sequence is more permissive than the causal recurrent implementation.

  • sectionPoints, rules, and observationsAn explicitly specified hidden-rule task › Points, rules, and observations · lines 327–333
    Open as its own page

    Training targets can affect a trained checkpoint. Assumption ass:uncued concerns a new assessment sequence. It does not hold if that sequence's labels were used to fit the checkpoint or update it online.

  • lemmaLemma: Uniform rule marginalsAn explicitly specified hidden-rule task › Stationarity and the observation obstruction · Psy03-D@1#lem:uniform · proof attached · lines 336–354
    Open as its own page

    Conditional on any admitted switch schedule,

    for every . The complete rule process is independent of the point sequence.

    Proof. At a switch the transition matrix has zero diagonal and off-diagonal entries . It is doubly stochastic and preserves the uniform distribution. At other steps the transition is the identity. Induct from the uniform initial rule. All variables constructing the rule process are independent of the point-generating variables.

  • theoremTheorem: Hidden-rule observation obstructionAn explicitly specified hidden-rule task › Stationarity and the observation obstruction · Psy03-D@1#thm:observability, Psy03-D@1#eq:labelposterior, Psy03-D@1#eq:generalbayes · proof attached · lines 356–393
    Open as its own page

    Under Assumption ass:uncued,

    where denotes the fixed assessed checkpoint. Consequently,

    The optimal accuracy at step is

    No function of the input history can improve on this reference. Knowing switch times does not reveal the new rule identity.

    Proof. Lemma lem:uniform and assessment independence give the rule posterior. The target is a deterministic function of , giving (eq:labelposterior). Conditional randomized classification is a convex combination of the four possible label probabilities and cannot exceed their maximum. Selecting a maximizing label attains that maximum.

  • sectionStationarity and the observation obstructionAn explicitly specified hidden-rule task › Stationarity and the observation obstruction · lines 393–400
    Open as its own page

    This is an information limitation, not a failure of a particular optimizer. It is the hidden-rule counterpart of the cue and observation boundaries recorded in Psy01-A and Psy03-C CheungPsy01A,CheungPsy03C.

  • remarkRemark: Nonuniform initial rulesAn explicitly specified hidden-rule task › Stationarity and the observation obstruction · lines 401–409
    Open as its own page

    If the initial rule is nonuniform, clock information can change the known prior through the transition matrix. Point history still does not supply rule evidence. Replace in (eq:labelposterior) by the appropriate time-dependent prior. Uniformity is therefore a stated hypothesis, not a universal property of hidden-rule tasks.

Duplicate functions and the exact population reference

  • propositionProposition: Three functions, four IDsDuplicate functions and the exact population reference · Psy03-D@1#prop:duplicates · proof attached · lines 414–432
    Open as its own page

    The functions are identical:

    The other functions are distinct on positive-probability sets. Neither nor is a binary sign classification: both take all four label values.

    Proof. The two displayed expressions differ only in the order of addition. All four sign combinations have positive probability under the continuous Gaussian mixture. Inspection of (eq:rules) distinguishes the remaining functions on open regions.

  • sectionDuplicate functions and the exact population referenceDuplicate functions and the exact population reference · lines 432–446
    Open as its own page

    Write

    The effective function prior is

    Uniform rule-ID sampling is not uniform sampling of distinct label functions.

  • theoremTheorem: Exact uncued accuracy and a memoryless optimizerDuplicate functions and the exact population reference · Psy03-D@1#thm:ceiling · proof attached · lines 447–499
    Open as its own page

    For the task in Section sec:task,

    at every assessment step. The memoryless predictor

    attains this optimum.

    Conditional quadrant reference accuracies are

    for the positive-positive, negative-negative, positive-negative, and negative-positive quadrants, respectively. Oracle rule access gives accuracy one.

    Proof. Outside the null boundaries , the mixture is invariant under coordinate sign changes and exchange. Each quadrant has probability , and its two diagonal subregions have equal probability.

    In a same-sign quadrant, . Three rule IDs therefore vote for . On one half of that quadrant, , giving posterior correctness one; on the other half it gives . The conditional average is .

    In an opposite-sign quadrant, , and two IDs vote for . On one half, , giving correctness . On the other half, differs from both and , so the largest label probability is , again attained by . The conditional average is .

    Hence is a maximizing rule at every nonboundary point, and

    The target is deterministic when are both known, so the oracle accuracy is one.

  • sectionDuplicate functions and the exact population referenceDuplicate functions and the exact population reference · Psy03-D@1#tab:quadrants · lines 499–523
    Open as its own page

    {Information reference for the uncued task. Each listed diagonal half has conditional probability within its quadrant.}

    QuadrantRelationVotes for Optimal accuracy
    4
    3
    4
    3
    3
    2
    3
    2
  • corollaryCorollary: An optimal predictor need not adapt at switchesDuplicate functions and the exact population reference · Psy03-D@1#cor:noadapt · proof attached · lines 524–540
    Open as its own page

    The memoryless predictor has expected accuracy at all times, including windows selected solely from an independent switch schedule. For nonempty early and stable windows with this selection rule, its population early-to-stable accuracy ratio is one.

    High accuracy and a ratio near one therefore do not establish inference of the active rule or successful rule updating.

    Proof. Theorem thm:ceiling applies conditional on each admitted schedule and at every selected time. The predictor does not use a hidden state or switch history.

  • remarkRemark: Population reference, not sample capDuplicate functions and the exact population reference · lines 542–554
    Open as its own page

    A finite-sample accuracy can exceed . Assessment sequences share temporally correlated rule states, and sampling variation remains. The theorem bounds population accuracy under its hypotheses, not every realized empirical value.

    The reference also does not apply unchanged to ritual-overwritten labels, a nonuniform rule prior, an informative cue, feedback, or a checkpoint fitted to the assessment labels. At zero stimulus noise, diagonal boundaries can have positive mass; that is a different law requiring separate calculation.

  • propositionProposition: Deduplication changes the reference taskDuplicate functions and the exact population reference · Psy03-D@1#prop:dedup · proof attached · lines 556–574
    Open as its own page

    If the three distinct functions are instead sampled with equal marginal probabilities, while remaining hidden and independent of the points, the population optimum is

    Thus removing the duplicated ID and balancing the remaining functions is a protocol change.

    Proof. In each same-sign quadrant, the conditional optimum is the average of and , namely . In each opposite-sign quadrant it is the average of and , namely . Average the four quadrant values.

Rule changes and informative switches

  • sectionRule changes and informative switchesRule changes and informative switches · lines 577–587
    Open as its own page

    Define function equivalence by . A switch has three distinct descriptions:

    1. : rule-ID change;

    2. : label-function change;

    3. : an informative disagreement at that point.

  • theoremTheorem: Exact switch and disagreement frequenciesRule changes and informative switches · Psy03-D@1#thm:switchfrequencies, Psy03-D@1#eq:disagreementmatrix · proof attached · lines 588–641
    Open as its own page

    At a stationary rule-ID switch, the ordered pair of old and new IDs is uniform over the twelve distinct ordered pairs. The probability of a change between identical functions is

    Let

    For the point law in Section sec:task,

    For a fresh point after a stationary ID switch, informative disagreement probability is

    Conditional on a genuine label-function change, it is

    Proof. Uniform stationarity and the uniform nonzero increment give probability to each ordered pair. Only and change IDs without changing the function.

    Functions disagree exactly in opposite-sign quadrants, giving . Functions disagree on half of each same-sign quadrant and all of each opposite-sign quadrant, giving . Functions disagree on half of every quadrant, giving . Duplication supplies the other entries.

    The sum over the six unordered off-diagonal pairs is . Therefore the mean over twelve ordered pairs is . Divide by the genuine-switch probability to obtain .

  • sectionRule changes and informative switchesRule changes and informative switches · lines 641–647
    Open as its own page

    A trial can be uninformative even after a genuine function change. An evaluator that treats every rule-ID transition as a behavioral switch combines these different events.

Observable task designs are new protocols

  • propositionProposition: Full and delayed rule cuesObservable task designs are new protocols › Explicit and delayed cues · Psy03-D@1#prop:cues · proof attached · lines 653–668
    Open as its own page

    Supplying alongside gives Bayes accuracy one.

    If a rule is fixed within a segment and its ID is supplied only at the first segment trial, an ideal predictor with memory of that cue also has accuracy one throughout the segment. The later trials then test retention and execution of an observed rule, rather than discovery of an unobserved rule.

    Proof. Evaluate . In the delayed-cue case, retain the supplied ID until the next segment cue.

  • sectionExplicit and delayed cuesObservable task designs are new protocols › Explicit and delayed cues · lines 668–672
    Open as its own page

    These are information statements, not claims that a finite trained GRU attains the oracle.

  • sectionPartially informative cuesObservable task designs are new protocols › Partially informative cues · lines 673–680
    Open as its own page

    Let a cue have a declared channel

    independent of the point given the rule.

  • theoremTheorem: Cue-conditioned classification referenceObservable task designs are new protocols › Partially informative cues · Psy03-D@1#thm:noisycues, Psy03-D@1#eq:cuebayes · proof attached · lines 681–717
    Open as its own page

    For a uniform rule prior, the Bayes accuracy with the current cue is

    If the cue reveals the rule with probability and otherwise reports a recognizable erasure,

    Further rule-independent processing of a cue cannot improve its Bayes accuracy.

    Proof. The inner sum is the joint conditional probability of cue and label at a fixed point. Optimize the prediction separately for every cue.

    A nonerased cue gives accuracy one. An erased cue leaves the uncued reference . Average these two cases.

    A predictor receiving a degraded cue can be simulated by a predictor receiving the original cue and applying the degrading channel before its decision.

  • sectionPartially informative cuesObservable task designs are new protocols › Partially informative cues · lines 717–722
    Open as its own page

    Cue accuracy and task accuracy need not coincide. A mistaken ID can still prescribe the correct current label, especially for duplicate functions or uninformative points.

  • sectionCausally ordered feedbackObservable task designs are new protocols › Causally ordered feedback · Psy03-D@1#eq:feedback · lines 723–748
    Open as its own page

    Let be the rule belief immediately before prediction at time . After predicting, reveal the target for use on later trials. For noiseless full-label feedback,

    whenever the denominator is positive. For a known transition matrix ,

    Current prediction uses

    not . A known noisy feedback channel replaces the indicator likelihood by its declared likelihood.

  • theoremTheorem: Effective-function identification from feedbackObservable task designs are new protocols › Causally ordered feedback · Psy03-D@1#thm:feedback · proof attached · lines 749–775
    Open as its own page

    Suppose one of is fixed for independent point trials and noiseless target feedback is received after each prediction. Retain all functions consistent with the observed point-label pairs. The probability that any incorrect distinct function remains after feedback trials is at most

    The duplicate IDs 1 and 2 remain observationally identical within that fixed-rule experiment.

    Proof. An incorrect function survives each fresh trial with probability . For all distinct effective function pairs, (eq:disagreementmatrix) gives . Independence makes its survival probability at most . Union bound over the two incorrect functions.

    IDs 1 and 2 prescribe identical labels for every point, so their point-label laws are identical.

  • sectionCausally ordered feedbackObservable task designs are new protocols › Causally ordered feedback · lines 775–786
    Open as its own page

    A stable-segment assumption is essential. If a switch occurs during the elimination window, a fixed-rule consistency set is no longer the correct filter.

    Correctness-only feedback also supplies information: its likelihood is determined by whether a candidate rule would make the chosen response correct. It can be less informative than full target feedback. The action policy and feedback timing must be part of that task.

  • propositionProposition: Observation-law perturbation allowanceObservable task designs are new protocols › An allowance for imperfect source alignment · Psy03-D@1#prop:leakage · proof attached · lines 789–820
    Open as its own page

    Let be the ideal joint law of the rule, points, and admitted auxiliary observations in the uncued task. Let be another law on the same spaces with , and retain the target . Every predictor has accuracy under at most

    truncated at one.

    More generally, for a conditional rule posterior and a reference posterior , the difference between their optimal current-label probabilities is at most

    when the same point and label functions are used.

    Proof. Mapping the joint law to target and prediction cannot increase total variation. The expectation of a correctness indicator changes by at most . For the conditional statement, each candidate-label probability is the posterior mass of a subset of rule IDs. Its change is at most total variation; taking a maximum preserves that allowance.

  • sectionAn allowance for imperfect source alignmentObservable task designs are new protocols › An allowance for imperfect source alignment · lines 820–825
    Open as its own page

    The proposition is not an assertion that a particular script has only a small observation-law discrepancy. That discrepancy must be certified.

What the modular computation does and does not expose

  • sectionWhat the modular computation does and does not exposeWhat the modular computation does and does not expose · Psy03-D@1#eq:modular · lines 827–870
    Open as its own page

    A declared modular template is

    Here is identity or external tanh. The gate is scalar at each trial. For a nonmodular variant set .

    This template records the distinction between recurrent state and a pointwise readout branch. The symbols “cortical,” “striatal,” and “thalamic” can name computational motifs without constituting an anatomical identification.

    The PyTorch candidate convention is

    followed by

    Dropout in a multilayer nn.GRU is placed between recurrent layers, not after the final recurrent layer PyTorchGRU.

    The GRU can retain information about past inputs. It cannot turn past rule-independent points into evidence about the hidden rule in Theorem thm:observability. Post-RNN readout noise and a pointwise branch also do not provide missing feedback.

  • propositionProposition: A pointwise branch is not an additional state loopWhat the modular computation does and does not expose · Psy03-D@1#prop:topology · proof attached · lines 871–885
    Open as its own page

    In (eq:modular), if are not fed into the next recurrent update and have no separately persistent state, their branch introduces no additional recurrent state. Their influence on future predictions can occur only through an explicitly added feedback or training operation.

    Proof. The next recurrent state is computed from the GRU state and next input. The displayed pointwise branch does not appear among those arguments.

  • remarkRemark: No transfer of Psy03-C's external-activation invariantWhat the modular computation does and does not expose · lines 887–895
    Open as its own page

    Psy03-C's ordinary-ReLU invariant concerns an external activation applied to the state that is fed into the next cell CheungPsy03C. In a template such as (eq:modular), scaling and activation after the sequence GRU modify its readout, not automatically its internal recurrent state. The two implementations must not be identified.

Response metrics and old-function persistence

  • sectionDisjoint post-switch windowsResponse metrics and old-function persistence › Disjoint post-switch windows · Psy03-D@1#eq:windows · lines 900–935
    Open as its own page

    Let rule-ID switches occur at

    For each switch, set and define

    These windows stop at the next ID switch and do not overlap. The old and new IDs are

    For , define

    and

    Then are disjoint indicators and

  • definitionDefinition: Old-function response fractionResponse metrics and old-function persistence › Disjoint post-switch windows · Psy03-D@1#def:oldfraction · lines 936–946
    Open as its own page

    For a finite record with , define

    Report the denominator, new-function response fraction, and other-error fraction alongside it. If the denominator is zero, report undefined, not zero.

  • sectionDisjoint post-switch windowsResponse metrics and old-function persistence › Disjoint post-switch windows · lines 946–952
    Open as its own page

    The metric states what response was made on points where the functions disagree. It does not by itself establish an internal representation of the old rule.

  • sectionThe original repetition statisticResponse metrics and old-function persistence › The original repetition statistic · Psy03-D@1#eq:repeatmetric · lines 953–973
    Open as its own page

    Let

    A distinct statistic is

    when its denominator is positive.

    We call this repeated-response fraction among post-switch errors. It is not renamed as old-rule persistence.

  • propositionProposition: Repetition and old-function responses can divergeResponse metrics and old-function persistence › The original repetition statistic · Psy03-D@1#prop:metriccounterexamples · proof attached · lines 974–1005
    Open as its own page

    The two fractions in Definitions def:oldfraction and (eq:repeatmetric) do not determine one another.

    In particular:

    1. an old-function strategy can make every informative post-switch response an error while never repeating its immediately preceding response;

    2. a constant classifier can repeat every erroneous response without implementing the old function;

    3. a memoryless classifier can have old-function response fraction one for a selected old/new pair.

    Proof. Use a switch from to , with alternating points in the two opposite-sign quadrants. A predictor using produces alternating labels 1 and 2. Every post-switch point is informative and every response is the old-function response, but adjacent responses differ.

    On the same post-switch points, a constant response 0 is always wrong, always repeated, and is not the old-function response.

    Finally, the memoryless predictor makes the old-function response on every informative trial whenever the old function is and the new function is . No stored rule ID is needed.

  • sectionThe original repetition statisticResponse metrics and old-function persistence › The original repetition statistic · lines 1005–1010
    Open as its own page

    A change in either metric is an observation-level contrast. Interpretation as cognitive rigidity needs additional task and construct evidence.

  • sectionOutput entropy is not temporal repetition entropyResponse metrics and old-function persistence › Output entropy is not temporal repetition entropy · lines 1011–1023
    Open as its own page

    For marginal response frequencies , define

    This is marginal label entropy. A temporal conditional entropy is instead

    under a declared process law or estimator.

  • propositionProposition: Equal marginal entropy, different temporal patternsResponse metrics and old-function persistence › Output entropy is not temporal repetition entropy · Psy03-D@1#prop:entropy · proof attached · lines 1024–1037
    Open as its own page

    An independent uniform four-label process and the deterministic cycle , with a uniform initial phase, both have marginal entropy . Their one-step conditional entropies are and zero, respectively.

    Proof. Both have uniform marginals. The independent process retains uniform conditional law. In the cycle, the next label is determined by the current one.

  • sectionOutput entropy is not temporal repetition entropyResponse metrics and old-function persistence › Output entropy is not temporal repetition entropy · lines 1037–1041
    Open as its own page

    Normalizing marginal entropy by does not convert it into a temporal measure.

Sequence-level statistical certificates

  • sectionThe sampling unitSequence-level statistical certificates › The sampling unit · lines 1045–1056
    Open as its own page

    A sequence contains correlated rule states, overlapping recurrent computations, and outcome-dependent denominators. It is generally not valid to count its trials as independent population observations.

    For each independent assessment sequence , let be a predeclared summary. Examples include total accuracy, a normalized count, or a within-sequence mean over a predetermined nonempty window.

  • theoremTheorem: Simultaneous sequence-mean certificateSequence-level statistical certificates › The sampling unit · Psy03-D@1#thm:sequencehoeffding · proof attached · lines 1057–1084
    Open as its own page

    Condition on fixed checkpoints independent of the fresh assessment sequences. For bounded summaries, each averaged over independent sequence blocks,

    is a simultaneous mean radius at confidence at least .

    Within-sequence dependence and within-sequence pairing between checkpoints are allowed. A paired sequence contrast in an interval of length has radius

    Proof. For one bounded mean, Hoeffding's inequality gives Hoeffding. Union bound over summaries. Rescale an interval of length to . The independence is between sequence blocks, not their steps.

  • sectionThe sampling unitSequence-level statistical certificates › The sampling unit · lines 1084–1089
    Open as its own page

    This is the sequence-unit specialization of the evaluation interfaces recorded in Psy03-A and Psy03-C CheungPsy03A,CheungPsy03C.

  • sectionRatios of population meansSequence-level statistical certificates › Ratios of population means · Psy03-D@1#eq:ratiotarget · lines 1090–1107
    Open as its own page

    For disjoint windows, define sequence summaries

    They satisfy . The population estimand is

    Its plug-in estimate is the pooled count ratio. It is not generally the average of per-sequence ratios.

  • theoremTheorem: Certified ratio intervalSequence-level statistical certificates › Ratios of population means · Psy03-D@1#thm:ratio, Psy03-D@1#eq:ratiointerval · proof attached · lines 1108–1137
    Open as its own page

    Suppose simultaneous intervals satisfy

    with nonnegative endpoints. If , then

    If , this construction does not certify a positive population denominator and the ratio is unresolved.

    The same statement applies to using its normalized numerator and error count.

    Proof. Division is increasing in a nonnegative numerator and decreasing in a positive denominator. Use for truncation at one.

  • sectionRatios of population meansSequence-level statistical certificates › Ratios of population means · lines 1137–1151
    Open as its own page

    An unresolved denominator is not evidence that the fraction equals zero. A clinically interpreted percentage cannot be inferred from this computational ratio.

    For two certified ratio intervals and , their difference lies in

    A positive lower endpoint certifies the oriented comparison of those ratio estimands.

  • sectionFlexibility ratiosSequence-level statistical certificates › Flexibility ratios · lines 1152–1181
    Open as its own page

    One possible predeclared definition uses, on each sequence, nonempty early and stable windows with mean accuracies . Define

    Theorem thm:ratio applies without upper truncation at one:

    The ratio can exceed one.

    A pooled-trial definition is a different estimand. If its early and stable correctness and exposure summaries have means , then

    Certify all four means and the required denominator positivity before forming that ratio.

    Adding to a denominator produces a regularized statistic, not a proof that the original ratio exists.

  • corollaryCorollary: Fresh sequences after adaptive historySequence-level statistical certificates › History-conditional assessment · Psy03-D@1#cor:conditional · proof attached · lines 1184–1204
    Open as its own page

    Before assessment block , condition on the complete training, intervention, and calibration history. Choose the checkpoint, sample size, summary definitions, and confidence allocation before viewing the block. If its sequences are conditionally fresh and independent, the sequence-mean and ratio certificates hold conditionally.

    Predictable allocations with total at most give simultaneous confidence at least across completed blocks.

    Proof. Apply Theorem thm:sequencehoeffding conditional on the past. Average the conditional failure probabilities and sum them. This is the conditional-block argument recorded in Psy03-B CheungPsy03B.

  • sectionHistory-conditional assessmentSequence-level statistical certificates › History-conditional assessment · lines 1204–1212
    Open as its own page

    Reusing assessment sequences to select, train, or adapt later checkpoints invalidates the ordinary independent-assessment hypothesis. Fresh noise on reused sequences controls a finite-design noise average, not automatically a fresh-sequence population target.

Recovery patterns and censoring

  • sectionRecovery patterns and censoringRecovery patterns and censoring · lines 1214–1220
    Open as its own page

    For a genuine function switch, select a horizon that does not extend beyond the next switch. Let be post-switch correctness indicators, indexed starting at one.

  • definitionDefinition: First recovery-pattern completionRecovery patterns and censoring · Psy03-D@1#def:recovery · lines 1221–1242
    Open as its own page

    For a five-trial, four-correct criterion, define

    with if the set is empty.

    Record:

    The completion time differs by four trials from the start index of its qualifying window. A record without an observed event is administratively right-censored at .

  • theoremTheorem: Restricted pattern summariesRecovery patterns and censoring · Psy03-D@1#thm:recovery · proof attached · lines 1244–1266
    Open as its own page

    For a common fixed horizon , the event indicator , the normalized restricted time , and each indicator , , are bounded sequence-level summaries. Their population means therefore admit Theorem thm:sequencehoeffding.

    If a sequence contains several eligible switches, first use a predeclared bounded within-sequence aggregation. Those switches are not automatically independent replicates.

    A censored record and an event completing exactly at have the same , but different . The censoring indicator must therefore be retained.

    Proof. Each indicator is in , and . Apply the sequence-level theorem. The last statement follows directly from the definition.

  • sectionRecovery patterns and censoringRecovery patterns and censoring · lines 1266–1273
    Open as its own page

    This certifies a specified correctness pattern, not recovery of a latent cognitive state. A numerical sentinel such as 50 cannot distinguish late recovery from no observed recovery unless event and censoring metadata are supplied.

  • propositionProposition: A chance pattern is possibleRecovery patterns and censoring · Psy03-D@1#prop:chancepattern · proof attached · lines 1274–1296
    Open as its own page

    For an independent Bernoulli correctness process with success probability , one five-trial window satisfies the criterion with probability

    At , this is . At , it is .

    For , the probability of at least one qualifying window is at most

    Proof. Sum the probabilities of exactly four and five successes. Use a union bound over windows. Their overlap does not affect the validity of that upper bound.

  • sectionRecovery patterns and censoringRecovery patterns and censoring · lines 1296–1302
    Open as its own page

    The independent Bernoulli process is an illustrative comparison, not the hidden-rule sequence law. The calculation nevertheless shows why a short success pattern does not alone identify rule recovery.

Masked gradients and reference-preserving repair

  • sectionStored and effective parametersMasked gradients and reference-preserving repair › Stored and effective parameters · lines 1306–1311
    Open as its own page

    Let be a stored weight tensor, a fixed binary mask, and the tensor used in the forward computation. Assume the loss depends on only through .

  • theoremTheorem: Masked-gradient obstructionMasked gradients and reference-preserving repair › Stored and effective parameters · Psy03-D@1#thm:maskedgradient, Psy03-D@1#eq:maskedgradient · proof attached · lines 1312–1335
    Open as its own page

    At every differentiability point,

    Therefore every inactive coordinate has zero stored-weight loss derivative.

    If a regrowth routine scores inactive coordinates using only accumulated absolute stored-weight derivatives and selects only strictly positive scores, it cannot select those coordinates through this interface.

    Proof. The differential is

    Apply the chain rule coordinatewise. Accumulating absolute zero derivatives still gives zero.

  • sectionStored and effective parametersMasked gradients and reference-preserving repair › Stored and effective parameters · lines 1335–1346
    Open as its own page

    The hypothesis excludes a direct regularizer on , a surrogate derivative, stale gradients, or an independent score. Those are different scoring interfaces.

    PyTorch's pruning reparameterization distinguishes an original parameter, a mask buffer, and the effective masked tensor PyTorchPruning. That bookkeeping does not make their derivatives interchangeable.

  • propositionProposition: Ambient effective-weight scores remain availableMasked gradients and reference-preserving repair › Stored and effective parameters · Psy03-D@1#prop:ambient · proof attached · lines 1347–1372
    Open as its own page

    Let be the same computational loss viewed as a function of the effective tensor. Its derivative at can be nonzero at an inactive coordinate, even though the derivative with respect to is zero there.

    Recording the effective tensor's autograd derivative computes this ambient derivative. It does not apply a signed update or guarantee a loss decrease.

    Proof. For

    the effective derivative is

    It can be nonzero at any coordinate with nonzero . Equation (eq:maskedgradient) then zeros the corresponding stored derivative when .

  • sectionStored and effective parametersMasked gradients and reference-preserving repair › Stored and effective parameters · lines 1372–1390
    Open as its own page

    Gradient-based topology updates have established precedents, including RigL EvciRigL. The present score distinction is not an identification of the reported repair algorithm with RigL.

    Recurrent tensors that are zeroed only after optimizer steps, but used without an in-forward mask, have a different derivative interface. The same scoring code can therefore have different eligibility consequences for linear and recurrent modules.

    Psy03-A's signed sparse-gradient descent result has an explicit signed update and local smoothness hypothesis CheungPsy03A. It is not imported as a guarantee for unsigned scoring, positive-score filtering, or random initialization.

  • sectionReference preservationMasked gradients and reference-preserving repair › Reference preservation · lines 1391–1399
    Open as its own page

    Let be an immutable pre-pruning reference. A declared scaled restoration writes

    at reopened coordinates.

  • propositionProposition: A pruned clone is not a healthy referenceMasked gradients and reference-preserving repair › Reference preservation · Psy03-D@1#prop:reference · proof attached · lines 1400–1422
    Open as its own page

    If the reference is captured after deleted coordinates have been zeroed, then

    at those coordinates. Reopening their masks and applying the scaled-restoration rule initializes them to zero for every finite .

    If all other effective parameters and controls are unchanged, this operation leaves the immediate forward function unchanged, even though the active mask changes. Subsequent learning can differ because eligibility changes.

    Proof. Multiply zero by . The effective coordinate before and immediately after reopening is zero. The mask change can allow a later stored derivative or update.

  • sectionReference preservationMasked gradients and reference-preserving repair › Reference preservation · lines 1422–1428
    Open as its own page

    A restoration reference must therefore be saved independently of current weights and copied into each branch. A training parameter called weight_orig is not automatically an immutable healthy-checkpoint reference.

  • propositionProposition: Numerical permanence does not prohibit future regrowthMasked gradients and reference-preserving repair › Zeroing is not permanent eligibility exclusion · Psy03-D@1#prop:remove · proof attached · lines 1431–1447
    Open as its own page

    Removing a masking reparameterization while retaining its current zeroed tensor does not by itself impose a permanent zero constraint under later optimization. There are losses for which a zeroed coordinate immediately becomes nonzero under a subsequent gradient step.

    Proof. After mask removal, take a scalar zero parameter and loss

    A gradient step of size gives .

  • sectionZeroing is not permanent eligibility exclusionMasked gradients and reference-preserving repair › Zeroing is not permanent eligibility exclusion · lines 1447–1456
    Open as its own page

    The pruning tutorial's removal operation preserves the current pruned values and removes the mask reparameterization PyTorchPruning. It must not be identified with Psy03-B's permanent scar eligibility rule CheungPsy03B. No permanent scar register is assumed in the modular source patterns studied here.

  • sectionAn admissible repair recordMasked gradients and reference-preserving repair › An admissible repair record · lines 1457–1475
    Open as its own page

    A complete repair record should retain:

    1. current stored and effective weights;

    2. active masks and any separately declared forbidden set;

    3. immutable pre-pruning reference weights;

    4. score type: stored derivative, effective derivative, activation statistic, or another declared score;

    5. exact integer counts, eligibility, and tie convention;

    6. initialization type and scale;

    7. optimizer reset or retained-state policy;

    8. consolidation data, schedule, and random streams.

    If all scores are zero, the routine must explicitly reject, return zero repairs, or invoke a declared fallback. Those decisions are different algorithms.

Score allocation and recurrent-protection counterexamples

  • theoremTheorem: Per-tensor multiplier cancellationScore allocation and recurrent-protection counterexamples · Psy03-D@1#thm:cancel · proof attached · lines 1479–1498
    Open as its own page

    Let be scores in one tensor, let be its -th ascending order statistic, and let . Then

    The same retained support is obtained by a consistent exact-count ranking.

    Consequently a positive multiplier common to every score in a tensor does not protect that tensor through a fixed per-tensor pruning allocation.

    Proof. Positive multiplication preserves inequalities, ties, and ordering.

  • sectionScore allocation and recurrent-protection counterexamplesScore allocation and recurrent-protection counterexamples · lines 1498–1503
    Open as its own page

    The statement is exact in real arithmetic. Numerical underflow or overflow is not a protection mechanism and requires separate implementation handling.

  • propositionProposition: Division reverses global magnitude protectionScore allocation and recurrent-protection counterexamples · Psy03-D@1#prop:division · proof attached · lines 1504–1525
    Open as its own page

    Suppose a global exact-count rule removes the lowest scores and divides a designated recurrent group's magnitudes by , leaving other scores fixed. The number of retained coordinates in that group cannot increase solely because of this division.

    It can decrease strictly.

    Proof. Every designated score weakly decreases relative to unchanged scores. With fixed deterministic tie breaking, its group cannot gain positions in the top-retained ranking.

    For a strict example, take one recurrent magnitude 2 and one other magnitude , and delete one coordinate. Without division the other coordinate is deleted. At , the recurrent score is 1 and is deleted instead.

  • sectionScore allocation and recurrent-protection counterexamplesScore allocation and recurrent-protection counterexamples · lines 1525–1541
    Open as its own page

    A protective global convention could multiply the designated group's scores by , or could assign it a separate retention budget. Such a changed convention still does not prove a favorable task effect. Density and score allocation remain insufficient statistics for implemented performance, as in Psy01-A CheungPsy01A.

    A named parameter that is not read by the update has no within-program effect. Likewise, classifying a pointwise striatal tensor as “recurrent” in a pruning-name predicate does not change the network topology of Proposition prop:topology.

Intervention accounting and certified matching

  • sectionThe matching objectIntervention accounting and certified matching › The matching object · Psy03-D@1#eq:matching · lines 1545–1575
    Open as its own page

    For a fixed parameterization, a complete accounting vector may include

    Here must state whether it compares stored parameters or effective masked tensors.

    Weight-only displacement does not price bias changes, mask reopening at zero, activation changes, or computational cost. The budget counterexamples and conventions in Psy03-A remain methodological records CheungPsy03A.

    Let family have executed candidates , with displacement . For a target and tolerance , common executed support is

    A pooled range across families does not establish this intersection.

  • definitionDefinition: Three reporting statusesIntervention accounting and certified matching › The matching object · Psy03-D@1#def:statuses · lines 1576–1591
    Open as its own page
    1. Executed match within tolerance: an actually run candidate has , and its complete identity is retained.

    2. Bracketed surrogate estimate: two executed points bracket the target, but the reported target outcome is an estimate under a separately declared response model.

    3. Unsupported target: there is neither an eligible executed match nor a justified surrogate bracket for the claimed target response.

    An interpolated parameter is not an executed checkpoint.

  • sectionThe matching objectIntervention accounting and certified matching › The matching object · lines 1591–1596
    Open as its own page

    Integer epochs, categorical architecture switches, and hard mask changes do not become valid fractional operations through interpolation.

  • theoremTheorem: Interpolation with a genuine response certificateIntervention accounting and certified matching › Conditional interpolation · Psy03-D@1#thm:interpolation, Psy03-D@1#eq:interpolationerror · proof attached · lines 1599–1638
    Open as its own page

    Suppose a declared scalar path has response on , with , and

    Let be the affine interpolant of the exact endpoint responses. Then

    If the endpoint estimates have simultaneous errors at most , their estimated interpolant has allowance

    where

    Proof. The interpolation error formula follows from the repeated Rolle theorem applied to the function after subtracting its interpolant and a suitable multiple of . Its absolute value is bounded by the displayed curvature allowance. The product is maximized at the midpoint. Endpoint estimation errors propagate with nonnegative weights summing to one.

  • sectionConditional interpolationIntervention accounting and certified matching › Conditional interpolation · lines 1638–1650
    Open as its own page

    The hypotheses include a single-valued response on an admitted scalar path. Dose-sorted candidates from different schedules or architectures do not supply that path automatically. Two points do not establish a curvature bound.

    Interpolating a ratio also needs a ratio-response certificate, or separate numerator and denominator certificates. Interpolating numerator and denominator and then dividing is not generally the same as interpolating their ratio.

  • propositionProposition: Executed candidate rankings and target rankings differIntervention accounting and certified matching › Conditional interpolation · Psy03-D@1#prop:targetranking · proof attached · lines 1651–1678
    Open as its own page

    Suppose executed candidate accuracies have simultaneous allowances . Then

    certifies their executed-checkpoint ranking.

    To claim an exact-target ranking, additionally suppose

    For matches within ,

    Proof. Subtract the simultaneous estimate allowances and the declared target-response allowances.

  • sectionConditional interpolationIntervention accounting and certified matching › Conditional interpolation · lines 1678–1682
    Open as its own page

    The certificates do not follow from nearest-neighbor selection or a plotted smooth curve.

  • definitionDefinition: Calibrated isoacute designIntervention accounting and certified matching › Isoacute comparison · lines 1685–1695
    Open as its own page

    Choose a predeclared acute endpoint , target , and tolerance . Select candidates using calibration data only. Then evaluate a distinct durability or challenge endpoint on fresh assessment sequences.

    The target can be an accuracy, a bounded summary, or a ratio with a certified positive denominator. The endpoint and orientation are part of the design.

  • theoremTheorem: Certified isoacute eligibilityIntervention accounting and certified matching › Isoacute comparison · Psy03-D@1#thm:isoacute · proof attached · lines 1697–1721
    Open as its own page

    If a calibration estimate has simultaneous error radius , then

    certifies acute eligibility.

    If each of two selected candidates is eligible, their actual acute endpoints differ by at most . Conditionally fresh post-selection assessment supports Theorem thm:sequencehoeffding for their secondary outcomes.

    For a ratio endpoint, replace the scalar-radius criterion by containment of its certified ratio interval in the target tolerance interval.

    Proof. Use the triangle inequality. For the secondary endpoint, condition on the calibration and selection history; the new assessment sequences remain fresh. Interval containment proves the ratio statement.

  • sectionIsoacute comparisonIntervention accounting and certified matching › Isoacute comparison · lines 1721–1733
    Open as its own page

    Isoacute and equal-displacement comparisons answer different questions. Neither is automatically a pharmacological dose comparison, an equal-resource comparison, or a mechanism-identification theorem.

    Taking candidate minima within each seed and then averaging those minima estimates a selected-family summary. It does not estimate one common matched intervention unless that policy and its selection correction are explicitly defined.

Source-pattern audit and debugging decisions

  • sectionSource-pattern audit and debugging decisionsSource-pattern audit and debugging decisions · lines 1735–1816
    Open as its own page

    This ledger retains the supplied development brief's findings DevelopmentBrief. The public task definitions were separately aligned with 069av2.py CheungPublicCode. It is not a claim that every version underlying every published table has been independently reconstructed.

    • Notebook syntax versus a Python script. The public export contains a leading notebook shell command. Remove it from a standard Python source and declare dependencies separately. A parse failure occurs before an experiment can run.

    • Missing rule evidence. Under the stated point-only assessment interface, neither rule IDs, past targets, correctness, nor rewards enter the recurrent update. Theorem thm:observability supplies the exact consequence.

    • Duplicated label mappings. Use the distinction between IDs, effective functions, and informative disagreements. Do not describe four IDs as four independent rules.

    • Training and assessment schedules. Random training switches and deterministic assessment switches are different schedule laws. They do not remove the uncued observation obstruction when both remain independent of the points and preserve uniform rule marginals.

    • Response-repetition naming. The reported post-switch error metric repeats the preceding response, not the old rule's prediction on the current point. Retain it under the neutral name in (eq:repeatmetric).

    • Stable-window coverage. Construct stable windows from all segments, including the final segment. Report empty windows rather than dropping them without a selection record.

    • Window overlap. Stop a post-switch window at the next switch. Otherwise a statistic attributed to one switch can include responses under another rule. The corrected metric definition changes that protocol.

    • Recovery bounds and censoring. State whether time refers to a window start or completion. Do not search through later switches without declaring that estimand. A sentinel is not a censoring indicator. Include the final permitted window start when implementing an inclusive observation horizon.

    • Rule-inference metric. Classification accuracy on selected stable windows is still classification accuracy. It is not a direct estimate of the hidden rule-ID posterior.

    • Entropy scope. Marginal output-label entropy and temporal conditional entropy are different. A high marginal entropy can coexist with deterministic repetition patterns.

    • Mixed gradient interfaces. In-forward masked linears have . Post-step-zeroed recurrent parameters can have nonzero ambient inactive derivatives. Record which interface supplied each score.

    • Restoration reference. A manager built after loading zeroed weights does not recover an immutable pre-pruning reference. Mask access can reopen while the numerical initialization remains zero. Preserve reference weights separately.

  • sectionSource-pattern audit and debugging decisionsSource-pattern audit and debugging decisions · lines 1816–1889
    Open as its own page

    • Activity versus loss influence. Accumulated absolute loss derivatives are loss-influence scores, not direct measurements of synaptic activity. ReLU saturation or an unused branch can give zero scores for reasons unrelated to biological inactivity.

    • Protective-score direction. A per-tensor positive multiplier cancels. Global division lowers designated scores. Theorems thm:cancel and prop:division identify the two different issues.

    • Unused control and topology. A configured striatal-specific multiplier has no effect if never read. A pointwise striatal readout is not a second recurrent loop unless it is fed back or has its own state.

    • Dropout and evaluation mode. Training-mode interlayer dropout and evaluation-mode computation are different laws. PyTorch locates GRU dropout between layers PyTorchGRU. Mode restoration and the assessed mode belong in provenance.

    • No permanent scar register. An active mask and regrowth eligibility are not Psy03-B's separate permanently forbidden coordinate set. Its scar-capacity theorem is not silently transferred.

    • Composite challenges. Cumulative pruning with rising stress changes two controls. An evaluation after stress reset is a different endpoint from the stressed trajectory. Report both if both are claimed.

    • Matching statuses. Interpolated outcomes are surrogate estimates. Nearest achieved candidates must retain residual mismatches. Pooled target support is not common arm support.

    • Isoacute implementation. A notebook heading containing “isoacute” does not establish calibrated acute matching and independent durability evaluation. Theorem thm:isoacute states the needed procedure.

    • Candidate-minimum summaries. Independent seed counts do not turn different selected candidate minima into one executed matched intervention. Retain candidate IDs, absolute targets, and selection rules.

    • Architecture ablations. GRU and LSTM use different gate counts and parameter spaces. A modular-off toggle can leave unused branch parameters registered; then total stored count need not decrease although active computation changes. Report registered parameters, used parameters, masks, and computational cost separately.

    • Random-stream isolation. Training, scoring, initialization, dropout, assessment, and selection need named streams and complete replay state. A seed is not a proof of statistical independence or cross-platform bitwise identity PyTorchRandom.

    • Endpoint interpretation. A validated computational effect is not clinical efficacy, OCD mechanism identification, or a treatment recommendation. Printed interpretations must remain within the certified task and intervention scope.

A subordinate finite quantum cue extension

  • corollaryCorollary: Carrier-independent uncued obstructionA subordinate finite quantum cue extension › No carrier supplies absent observations · Psy03-D@1#cor:qobstruction · proof attached · lines 1895–1913
    Open as its own page

    Suppose a finite quantum processor starts in a state independent of the assessment rule and receives only the point sequence and rule-independent randomness. Let every admitted channel and instrument choice depend only on those inputs and previous accessible records, not on hidden rule-dependent feedback. Its predictions obey the same uncued accuracy bound .

    Proof. Conditional on the point sequence, all initial states, update maps, and outcome laws are independent of the rule. Induction through the complete instrument sequence preserves that independence. Its final prediction is therefore another randomized decision rule covered by Theorem thm:observability.

  • sectionNo carrier supplies absent observationsA subordinate finite quantum cue extension › No carrier supplies absent observations · lines 1913–1925
    Open as its own page

    This is not a quantum advantage obstruction for every task. It says that changing the carrier does not add the missing observation channel.

    Complete sequential probabilities require instruments, and equal complete record laws cannot be distinguished by a test, as in Psy02-A and Psy02-B CheungPsy02A,CheungPsy02B,Watrous. An expectation-valued feature is not automatically a noiseless record available from one unknown state.

  • sectionTwo observed rule cuesA subordinate finite quantum cue extension › Two observed rule cues · lines 1926–1939
    Open as its own page

    Choose two label functions , with equal rule priors. The cue prepares respectively, independently of the current point. After a declared storage channel , the observer receives the point and the stored carrier.

    Let

  • theoremTheorem: Cue distinguishability and rule executionA subordinate finite quantum cue extension › Two observed rule cues · Psy03-D@1#thm:qexecution, Psy03-D@1#eq:qexecution · proof attached · lines 1940–1969
    Open as its own page

    The optimal current-label accuracy is

    A complete readout first distinguishes the two cue states on informative points and then executes the corresponding label function. On uninformative points it returns the common label.

    Proof. On a point where the functions agree, correctness one is available without distinguishing the cue.

    Where they disagree, label classification is equal-prior binary state discrimination. For an effect declaring cue 0,

    The maximum effect expectation is the positive-part trace, equal to . Average over informative and uninformative points Watrous.

  • sectionAn exact delayed cue pilotA subordinate finite quantum cue extension › An exact delayed cue pilot · Psy03-D@1#eq:qchannel · lines 1971–1990
    Open as its own page

    On a qubit, encode the two cues as

    For each delay step apply

    This is a linear CPTP map. Later inputs contain no further rule cue and no retained classical copy of the cue label is admitted to the readout.

  • theoremTheorem: Exact delayed rule-cue retentionA subordinate finite quantum cue extension › An exact delayed cue pilot · Psy03-D@1#thm:qpilot · proof attached · lines 1991–2023
    Open as its own page

    After delay steps,

    The rule-execution accuracy is

    For the pair , , giving

    The exact global carrier trace-distance contraction coefficient of one step is . It is not generally .

    Proof. The Bloch map scales the two transverse components by and the longitudinal component by . Iterate the transverse phase inputs. Their trace distance is the transverse separation factor. Apply Theorem thm:qexecution.

    The largest singular value of the Bloch map is , attained by opposite longitudinal-axis states. Qubit trace distance is half Euclidean Bloch distance.

  • sectionAn exact delayed cue pilotA subordinate finite quantum cue extension › An exact delayed cue pilot · lines 2023–2060
    Open as its own page

    The pilot independently reproduces the distinction between phase-specific decay and global forgetting developed in Psy03-C CheungPsy03C.

    For an observed-cue versus dephased-cue comparison, assign a neutral score on uninformative points, preparation failures, and erasures. On informative observed trials, score correct execution one and incorrect execution zero. With preparation success , observation probability , and symmetric assignment error , the ideal oriented record contrast is

    Uniform complete-law errors leave the allowance

    A positive remainder separates the specified record families. Sampling still requires independent attempted runs or the corresponding conditional mean assumptions.

    The cue states are orthogonal. A classical memory allowed to read and store their label can reproduce this binary cue task. The construction proves neither asymptotic advantage nor a quantum model of OCD.

    A persistent classical rule or structural label outside the contracting carrier also invalidates an automatic global forgetting claim. That observation does not imply that the modular implementation contains Psy03-B's scar register.

Discussion and mathematical release

  • sectionDiscussion and mathematical releaseDiscussion and mathematical release · lines 2062–2083
    Open as its own page

    The uncued task is not merely difficult. Its admitted inputs do not identify the current rule. The duplicated function makes a memoryless mapping optimal at population accuracy . A recurrent classifier approaching that value need not have learned online rule inference.

    Switch metrics require a second audit. Immediate response repetition is not adherence to the old function on a new point. Old-function responses on informative points are better specified, but still describe behavior rather than an identified internal representation.

    Repair and matching require separate interface audits. A masked stored derivative, an effective-weight derivative, a restoration reference, a reopened mask, and an executed intervention are distinct objects. Interpolation does not remove those distinctions.

  • theoremTheorem: Psy03-D mathematical releaseDiscussion and mathematical release · Psy03-D@1#thm:release · proof attached · lines 2084–2123
    Open as its own page

    For the objects and hypotheses printed here:

    1. the uncued rule process is unobservable from the point history, and its exact population classification optimum is ;

    2. two rule IDs implement the same function, and the stated switch and disagreement frequencies hold;

    3. explicit, delayed, erased-cue, and feedback protocols have the stated information references;

    4. old-function responses, repeated errors, entropy, flexibility, and recovery patterns have distinct operational meanings;

    5. sequence-level mean, ratio, paired, and censored-pattern certificates hold under their freshness and denominator hypotheses;

    6. the masked-gradient and reference-preservation identities hold;

    7. per-tensor multiplier cancellation and reversed global-score protection have the stated counterexamples;

    8. executed matching, conditional interpolation, and isoacute calibration have the stated certificates;

    9. a rule-independent quantum processor inherits the uncued obstruction, while the separately cued pilot has the exact retention and execution formulas.

    Adaptation requires observable evidence of change. Response repetition alone does not identify rule perseveration.

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

    Proof. The preceding independent proofs establish each positive statement. Their hypotheses exclude the unsupported observation, optimization, matching, and interpretive transfers. The absent biological correspondence is not a premise of any theorem.

  • sectionDiscussion and mathematical releaseDiscussion and mathematical release · lines 2123–2134
    Open as its own page

    No scalar Fock model, Wick-square contact class, gravitational kernel, characteristic quantum coefficient, or Ward identity is used. This manuscript licenses no O.1 closure, XV-B continuation, or downstream inherited admission. It does not purport to audit the status of unavailable full sources. The analytic boundaries recorded in Psy02-B remain separate CheungPsy02B.

Declarations

  • sectionDeclarationsDeclarations · lines 2135–2168
    Open as its own page

    and competing interests. No specific funding or competing interests are declared in the supplied project materials for this mathematical analysis.

    . No new human or animal experimentation is reported.

    and source availability. The manuscript uses supplied documentary materials and a public implementation record. No new empirical dataset or reproduced performance table is provided. The mathematical definitions and optional repair artifacts are printed in this single source.

    provenance. Analytic proofs and unexecuted test specifications are supplied. The public file was used for task-definition alignment, not represented as a version-stable substitute for an unprovided attachment. No source hash, commit identity, successful build, executed regression, or machine proof certificate is invented.

    boundary. The paper does not recommend selecting, combining, discontinuing, or timing treatments. It does not identify rule-ID switching with clinical events, parameter deletion with biological lesions, or computational endpoint matching with pharmacological dose equivalence.

Fresh task and observation interfaces

  • sectionFresh task and observation interfacesFresh task and observation interfaces · lines 2170–2183
    Open as its own page

    The following independently extractable CPU code implements the printed task and observation repairs. It does not reproduce a complete original experiment. Separate role streams are an implementation convention; statistical independence remains a hypothesis of the intended sampling law.

    The current target is never included in the current feedback input. Rule annotations remain evaluator-side information in the uncued mode.

  • listingListing: ListingFresh task and observation interfaces · lines 2184–2269
    Open as its own page
    import copy
    import math
    from fractions import Fraction
    import torch
    from torch import nn
    from torch.nn import functional as F
    
    def role_rng(seed, role):
        offsets = {
            "points": 101, "rules": 211, "schedule": 307,
            "assessment": 401
        }
        if role not in offsets:
            raise ValueError("unknown random-stream role")
        value = (int(seed) * 1009 + offsets[role]) % (2**63 - 1)
        return torch.Generator(device="cpu").manual_seed(value)
    
    def rule_table(points):
        if points.shape[-1] != 2 or not bool(torch.isfinite(points).all()):
            raise ValueError("finite two-dimensional points required")
        x, y = points[..., 0], points[..., 1]
        bx, by = (x >= 0).long(), (y >= 0).long()
        first = 2 * bx + by
        second = 2 * by + bx
        duplicate = bx + 2 * by
        diagonal = 2 * (y >= x).long() + (y >= -x).long()
        return torch.stack((first, second, duplicate, diagonal), dim=-1)
    
    def effective_rule_ids(rules):
        lookup = torch.tensor([0, 1, 1, 2], dtype=torch.long)
        return lookup[rules]
    
    def make_uncued_task(n, length, switch_interval, seed,
                         center=1.5, noise=0.8, dtype=torch.float64):
        if not isinstance(n, int) or n < 1:
            raise ValueError("positive sequence count required")
        if not isinstance(length, int) or length < 1:
            raise ValueError("positive sequence length required")
        if not isinstance(switch_interval, int) or switch_interval < 1:
            raise ValueError("positive integer switch interval required")
        if center <= 0 or noise <= 0:
            raise ValueError("the printed continuous task uses positive scales")
        point_gen, rule_gen = role_rng(seed, "points"), role_rng(seed, "rules")
        centers = torch.tensor(
            [[center, center], [-center, center],
             [-center, -center], [center, -center]], dtype=dtype
        )
        cluster = torch.randint(0, 4, (n, length), generator=point_gen)
        points = centers[cluster] + noise * torch.randn(
            (n, length, 2), dtype=dtype, generator=point_gen
        )
        rules = torch.empty((n, length), dtype=torch.long)
        current = torch.randint(0, 4, (n,), generator=rule_gen)
        for t in range(length):
            if t > 0 and t % switch_interval == 0:
                current = (current + torch.randint(
                    1, 4, (n,), generator=rule_gen
                )) % 4
            rules[:, t] = current
        labels = rule_table(points).gather(-1, rules[..., None]).squeeze(-1)
        return {"points": points, "labels": labels, "rules": rules}
    
    def observation_tensor(task, mode="uncued"):
        points, labels, rules = (
            task["points"], task["labels"], task["rules"]
        )
        if mode == "uncued":
            return points
        if mode == "full_cue":
            cue = F.one_hot(rules, num_classes=4).to(points.dtype)
            return torch.cat((points, cue), dim=-1)
        if mode == "delayed_cue":
            present = torch.ones_like(rules, dtype=torch.bool)
            present[:, 1:] = rules[:, 1:] != rules[:, :-1]
            cue = F.one_hot(rules, num_classes=4).to(points.dtype)
            cue = cue * present[..., None]
            return torch.cat((points, cue), dim=-1)
        if mode == "past_target_feedback":
            feedback = points.new_zeros((*labels.shape, 4))
            feedback[:, 1:, :] = F.one_hot(
                labels[:, :-1], num_classes=4
            ).to(points.dtype)
            return torch.cat((points, feedback), dim=-1)
        raise ValueError("unsupported observation protocol")
  • sectionFresh task and observation interfacesFresh task and observation interfaces · lines 2269–2275
    Open as its own page

    The delayed-cue protocol explicitly reveals a cue at each recorded segment boundary. The past-target protocol is a new feedback experiment. Neither is silently attributed to the uncued source.

Sequence metrics with informative denominators

  • sectionSequence metrics with informative denominatorsSequence metrics with informative denominators · lines 2277–2286
    Open as its own page

    The implementation below truncates windows at the next switch, includes the final stable segment, and records censoring. Recovery-pattern entries are restricted to genuine label-function changes.

    Its normalized summaries support ratios of population means. They do not implement an average of per-sequence ratios.

  • listingListing: ListingSequence metrics with informative denominators · lines 2287–2435
    Open as its own page
    def first_completion(correct, window=5, required=4):
        correct = correct.bool()
        horizon = len(correct)
        if window < 1 or not 0 <= required <= window:
            raise ValueError("invalid recovery pattern")
        for end in range(window, horizon + 1):
            if int(correct[end-window:end].sum()) >= required:
                return {
                    "first_completion": end,
                    "horizon": horizon,
                    "censored": False,
                    "restricted_time": end,
                }
        return {
            "first_completion": None,
            "horizon": horizon,
            "censored": True,
            "restricted_time": horizon,
        }
    
    def sequence_metrics(points, rules, predictions, post_window=10,
                         stable_margin=5, recovery_horizon=50):
        if points.ndim != 2 or points.shape[1] != 2:
            raise ValueError("one [T, 2] sequence required")
        length = len(points)
        if length < 1 or rules.shape != (length,) \
                or predictions.shape != (length,):
            raise ValueError("aligned nonempty sequence required")
        if rules.dtype != torch.long or predictions.dtype != torch.long:
            raise ValueError("integer labels required")
        if not bool(((rules >= 0) & (rules < 4)).all()) \
                or not bool(((predictions >= 0) & (predictions < 4)).all()):
            raise ValueError("rule or prediction outside label range")
        if post_window < 1 or stable_margin < 0 or recovery_horizon < 1:
            raise ValueError("invalid window controls")
    
        mappings = rule_table(points)
        labels = mappings.gather(-1, rules[:, None]).squeeze(-1)
        correct = predictions == labels
        switches = (torch.nonzero(rules[1:] != rules[:-1]).flatten() + 1).tolist()
        boundaries = [0] + switches + [length]
        semantic = effective_rule_ids(rules)
    
        old_count = new_count = other_count = informative = 0
        repeated_errors = post_errors = 0
        early_correct = early_exposure = 0
        function_switches = 0
        recovery = []
    
        for j, start in enumerate(switches):
            next_start = boundaries[j + 2]
            stop = min(start + post_window, next_start, length)
            old_id, new_id = int(rules[start-1]), int(rules[start])
            old_label = mappings[start:stop, old_id]
            new_label = mappings[start:stop, new_id]
            pred = predictions[start:stop]
            info = old_label != new_label
            old = info & (pred == old_label)
            new = info & (pred == new_label)
            other = info & ~old & ~new
    
            informative += int(info.sum())
            old_count += int(old.sum())
            new_count += int(new.sum())
            other_count += int(other.sum())
    
            errors = ~correct[start:stop]
            repeat = predictions[start:stop] == predictions[start-1:stop-1]
            post_errors += int(errors.sum())
            repeated_errors += int((errors & repeat).sum())
            early_correct += int(correct[start:stop].sum())
            early_exposure += stop - start
    
            if int(semantic[start-1]) != int(semantic[start]):
                function_switches += 1
                end = min(start + recovery_horizon, next_start, length)
                record = first_completion(correct[start:end])
                record["switch_index"] = start
                recovery.append(record)
    
        stable_correct = stable_exposure = 0
        for left, right in zip(boundaries[:-1], boundaries[1:]):
            lo, hi = left + stable_margin, right - stable_margin
            if lo < hi:
                stable_correct += int(correct[lo:hi].sum())
                stable_exposure += hi - lo
    
        assert old_count + new_count + other_count == informative
        return {
            "accuracy": float(correct.double().mean()),
            "id_switches": len(switches),
            "function_switches": function_switches,
            "informative_trials": informative,
            "old_responses": old_count,
            "new_responses": new_count,
            "other_errors": other_count,
            "old_fraction_sample": (
                old_count / informative if informative else None
            ),
            "repeated_error_fraction_sample": (
                repeated_errors / post_errors if post_errors else None
            ),
            "p_old": old_count / length,
            "n_info": informative / length,
            "p_repeat": repeated_errors / length,
            "n_error": post_errors / length,
            "c_early": early_correct / length,
            "n_early": early_exposure / length,
            "c_stable": stable_correct / length,
            "n_stable": stable_exposure / length,
            "recovery_records": recovery,
            "normalization": "counts divided by complete sequence length",
        }
    
    def ratio_certificate(rows, numerator, denominator, delta=0.05,
                          number_of_ratios=1, upper_one=True):
        if not rows or not 0 < delta < 1 or number_of_ratios < 1:
            raise ValueError("invalid certification controls")
        p = torch.tensor([r[numerator] for r in rows], dtype=torch.float64)
        n = torch.tensor([r[denominator] for r in rows], dtype=torch.float64)
        if not bool(((p >= 0) & (p <= 1) & (n >= 0) & (n <= 1)).all()):
            raise ValueError("bounded sequence summaries required")
        if upper_one and not bool((p <= n).all()):
            raise ValueError("fraction numerator must not exceed denominator")
    
        # Two means for each of the predeclared ratios.
        radius = math.sqrt(
            math.log(4.0 * number_of_ratios / delta) / (2.0 * len(rows))
        )
        pm, nm = float(p.mean()), float(n.mean())
        pl, pu = max(0.0, pm-radius), min(1.0, pm+radius)
        nl, nu = max(0.0, nm-radius), min(1.0, nm+radius)
        result = {
            "numerator_interval": (pl, pu),
            "denominator_interval": (nl, nu),
            "radius": radius,
            "target": "ratio of population sequence-summary means",
            "estimate": pm / nm if nm > 0 else None,
        }
        if nl == 0.0:
            result.update(status="unresolved_denominator", interval=None)
        else:
            lower, upper = pl / nu, pu / nl
            if upper_one:
                upper = min(1.0, upper)
            result.update(status="certified_interval", interval=(lower, upper))
        return result
  • sectionSequence metrics with informative denominatorsSequence metrics with informative denominators · lines 2435–2440
    Open as its own page

    For recovery analyses with a common horizon, use only a predeclared schedule-eligible set of switches with that horizon. Do not select eligible switches after viewing correctness.

An effective-gradient and reference-preserving linear interface

  • sectionAn effective-gradient and reference-preserving linear interfaceAn effective-gradient and reference-preserving linear interface · lines 2442–2453
    Open as its own page

    This compact module demonstrates the two gradient interfaces. It does not silently change the source's entire recurrent implementation.

    The reference is captured only through an explicit method. Repeated use of the same effective tensor parameter in a computation is handled by summing derivatives over its recorded forward uses. The stored-weight derivative still receives the mask factor.

  • listingListing: ListingAn effective-gradient and reference-preserving linear interface · lines 2454–2549
    Open as its own page
    class ReferenceMaskedLinear(nn.Module):
        def __init__(self, inputs, outputs, bias=False, dtype=torch.float64):
            super().__init__()
            self.weight = nn.Parameter(torch.zeros(outputs, inputs, dtype=dtype))
            self.bias = nn.Parameter(torch.zeros(outputs, dtype=dtype)) \
                if bias else None
            self.register_buffer("mask", torch.ones_like(self.weight, dtype=torch.bool))
            self.register_buffer("reference", torch.zeros_like(self.weight))
            self.register_buffer("reference_valid", torch.tensor(False))
            self.record_effective = False
            self.effective_uses = []
    
        @torch.no_grad()
        def capture_dense_reference(self):
            if not bool(self.mask.all()):
                raise ValueError("capture reference before pruning")
            if not bool(torch.isfinite(self.weight).all()):
                raise ValueError("non-finite reference")
            self.reference.copy_(self.weight)
            self.reference_valid.fill_(True)
    
        def begin_scoring(self):
            self.effective_uses.clear()
            self.record_effective = True
    
        def end_scoring(self):
            self.record_effective = False
            self.effective_uses.clear()
    
        def forward(self, x):
            effective = self.weight * self.mask.to(self.weight.dtype)
            if self.record_effective and torch.is_grad_enabled():
                effective.retain_grad()
                self.effective_uses.append(effective)
            return F.linear(x, effective, self.bias)
    
        def effective_gradient(self):
            if not self.effective_uses:
                raise ValueError("no recorded differentiable forward use")
            if any(t.grad is None for t in self.effective_uses):
                raise ValueError("loss must use every recorded forward tensor")
            return sum(
                (t.grad.detach() for t in self.effective_uses),
                torch.zeros_like(self.weight)
            )
    
        @torch.no_grad()
        def enforce(self):
            self.weight.mul_(self.mask.to(self.weight.dtype))
    
        @torch.no_grad()
        def delete_exact(self, count):
            active = torch.nonzero(self.mask.reshape(-1)).flatten()
            if not isinstance(count, int) or not 0 <= count <= len(active):
                raise ValueError("invalid exact deletion count")
            values = self.weight.detach().reshape(-1)[active].abs()
            order = torch.argsort(values, stable=True)
            selected = active[order[:count]]
            self.mask.view(-1)[selected] = False
            self.enforce()
            return selected.clone()
    
        @torch.no_grad()
        def reopen_exact(self, count, score, scale=1.0, positive_only=False):
            if not bool(self.reference_valid):
                raise ValueError("pre-pruning reference is unavailable")
            scale = float(scale)
            if not math.isfinite(scale):
                raise ValueError("finite restoration scale required")
            if score.shape != self.weight.shape \
                    or not bool(torch.isfinite(score).all()):
                raise ValueError("finite aligned score required")
            eligible = torch.nonzero((~self.mask).reshape(-1)).flatten()
            values = score.detach().reshape(-1)[eligible].abs()
            if positive_only:
                keep = values > 0
                eligible, values = eligible[keep], values[keep]
            if not isinstance(count, int) or not 0 <= count <= len(eligible):
                raise ValueError("count exceeds declared repair eligibility")
            order = torch.argsort(values, descending=True, stable=True)
            selected = eligible[order[:count]]
            self.mask.view(-1)[selected] = True
            self.weight.view(-1)[selected] = (
                scale * self.reference.view(-1)[selected]
            )
            self.enforce()
            return {
                "selected": selected.clone(),
                "numerically_zero_initializations": int(
                    (self.weight.view(-1)[selected] == 0).sum()
                ),
                "score": "effective-weight derivative supplied by caller",
                "initialization": "scaled immutable pre-pruning reference",
            }
  • sectionAn effective-gradient and reference-preserving linear interfaceAn effective-gradient and reference-preserving linear interface · lines 2549–2560
    Open as its own page

    The caller must clear ordinary gradients before scoring and restore mode and controls in a finally block. The scored loss must not be constructed from assessment data later claimed to be independent.

    Normal optimization of fixed support should enforce the mask after each step or maintain the in-forward reparameterization. Optimizer moments and regrowth-state policy must be specified. The listing contains no permanently forbidden scar set.

Matching records and interpolation allowances

  • sectionMatching records and interpolation allowancesMatching records and interpolation allowances · lines 2562–2568
    Open as its own page

    The following matcher does not generate a new trained checkpoint. A bracket is accepted only within one caller-declared path. A curvature value is treated as an externally certified input, not inferred from the endpoints.

  • listingListing: ListingMatching records and interpolation allowances · lines 2569–2651
    Open as its own page
    def matching_record(rows, target, tolerance, curvature=None):
        target, tolerance = float(target), float(tolerance)
        if not math.isfinite(target) or target < 0 \
                or not math.isfinite(tolerance) or tolerance < 0:
            raise ValueError("invalid matching target")
        if curvature is not None:
            curvature = float(curvature)
            if not math.isfinite(curvature) or curvature < 0:
                raise ValueError("invalid curvature certificate")
        checked = []
        for row in rows:
            d = float(row["displacement"])
            if not math.isfinite(d) or d < 0:
                raise ValueError("invalid executed displacement")
            checked.append((d, str(row["candidate_id"]), row))
        if not checked:
            return {"status": "unsupported_target", "target": target}
    
        nearest = min(
            checked, key=lambda item: (abs(item[0]-target), item[1])
        )
        residual = abs(nearest[0] - target)
        if residual <= tolerance:
            return {
                "status": "executed_match",
                "target": target,
                "candidate": nearest[2],
                "actual_displacement": nearest[0],
                "residual": residual,
                "tolerance": tolerance,
            }
    
        ordered = sorted(checked, key=lambda item: (item[0], item[1]))
        brackets = []
        for left, right in zip(ordered[:-1], ordered[1:]):
            d0, _, r0 = left
            d1, _, r1 = right
            same_path = r0.get("path_id") is not None \
                and r0.get("path_id") == r1.get("path_id")
            if same_path and d0 < target < d1:
                brackets.append((d1-d0, left, right))
        if not brackets:
            return {
                "status": "unsupported_target",
                "target": target,
                "nearest_candidate_id": nearest[1],
                "nearest_residual": residual,
            }
    
        _, left, right = min(brackets, key=lambda item: item[0])
        d0, _, r0 = left
        d1, _, r1 = right
        w1 = (target-d0)/(d1-d0)
        w0 = 1.0-w1
        estimate = w0 * float(r0["endpoint"]) + w1 * float(r1["endpoint"])
        allowance = None
        if curvature is not None and r0.get("radius") is not None \
                and r1.get("radius") is not None:
            allowance = (
                0.5 * curvature * (target-d0) * (d1-target)
                + w0 * float(r0["radius"]) + w1 * float(r1["radius"])
            )
        return {
            "status": "bracketed_surrogate",
            "target": target,
            "estimate": estimate,
            "allowance": allowance,
            "endpoint_candidate_ids": (r0["candidate_id"], r1["candidate_id"]),
            "path_id": r0["path_id"],
            "executed_target_checkpoint": False,
            "warning": "path and curvature certificates are caller obligations",
        }
    
    def isoacute_eligible(estimate, radius, target, tolerance):
        values = tuple(map(float, (estimate, radius, target, tolerance)))
        if not all(math.isfinite(v) for v in values):
            raise ValueError("finite calibration values required")
        estimate, radius, target, tolerance = values
        if radius < 0 or tolerance < 0:
            raise ValueError("negative calibration allowance")
        return abs(estimate-target) + radius <= tolerance
  • sectionMatching records and interpolation allowancesMatching records and interpolation allowances · lines 2651–2657
    Open as its own page

    For multiple treatment families, every reported executed target must pass the tolerance criterion in every family. For multiple seeds, use common absolute targets or state the seed-relative selection policy as the estimand.

Unexecuted unit-test specifications

  • listingListing: ListingUnexecuted unit-test specifications · lines 2661–2762
    Open as its own page
    def proposed_tests():
        # These are specifications; no executed pass is asserted.
        points = torch.tensor(
            [[2., 1.], [1., 2.], [-2., 1.], [-1., 2.],
             [-2., -1.], [-1., -2.], [2., -1.], [1., -2.]],
            dtype=torch.float64
        )
        table = rule_table(points)
        assert torch.equal(table[:, 1], table[:, 2])
        votes = torch.stack(
            [(table == label).sum(dim=1) for label in range(4)], dim=1
        )
        assert float(votes.max(dim=1).values.double().mean()) / 4.0 == 0.75
        chosen_votes = (table == table[:, 1, None]).sum(dim=1)
        assert torch.equal(chosen_votes, votes.max(dim=1).values)
    
        expected = torch.tensor(
            [[0., .5, .5, .75], [.5, 0., 0., .5],
             [.5, 0., 0., .5], [.75, .5, .5, 0.]],
            dtype=torch.float64
        )
        observed = torch.empty((4, 4), dtype=torch.float64)
        for r in range(4):
            for s in range(4):
                observed[r, s] = (table[:, r] != table[:, s]).double().mean()
        assert torch.equal(observed, expected)
    
        # Old-function responses without adjacent response repetition.
        alternating = torch.tensor(
            [[-2., 1.], [2., -1.]] * 6, dtype=torch.float64
        )
        rules = torch.tensor([1] + [0] * 11, dtype=torch.long)
        old_predictions = rule_table(alternating)[:, 1]
        metrics = sequence_metrics(
            alternating, rules, old_predictions, post_window=10
        )
        assert metrics["old_fraction_sample"] == 1.0
        assert metrics["repeated_error_fraction_sample"] == 0.0
    
        constant = torch.zeros(12, dtype=torch.long)
        metrics = sequence_metrics(alternating, rules, constant, post_window=10)
        assert metrics["old_fraction_sample"] == 0.0
        assert metrics["repeated_error_fraction_sample"] == 1.0
    
        # Zero-denominator certification remains unresolved.
        certificate = ratio_certificate(
            [{"p": 0.0, "n": 0.0}] * 20, "p", "n"
        )
        assert certificate["status"] == "unresolved_denominator"
    
        event = first_completion(torch.tensor([1, 1, 1, 1, 0]))
        censored = first_completion(torch.tensor([0, 0, 0, 0, 0]))
        assert event["first_completion"] == 5 and not event["censored"]
        assert censored["first_completion"] is None and censored["censored"]
        assert event["restricted_time"] == censored["restricted_time"]
    
        layer = ReferenceMaskedLinear(2, 1)
        with torch.no_grad():
            layer.weight.copy_(torch.tensor([[3., 2.]], dtype=torch.float64))
        layer.capture_dense_reference()
        deleted = layer.delete_exact(1)
        assert deleted.tolist() == [1]
    
        layer.zero_grad(set_to_none=True)
        layer.begin_scoring()
        loss = layer(torch.ones((1, 2), dtype=torch.float64)).square().sum()
        loss.backward()
        effective_score = layer.effective_gradient().clone()
        assert layer.weight.grad[0, 1].item() == 0.0
        assert effective_score[0, 1].item() != 0.0
        layer.end_scoring()
    
        clone = copy.deepcopy(layer)
        result = clone.reopen_exact(1, effective_score, scale=1.0)
        assert result["selected"].tolist() == [1]
        assert clone.weight[0, 1].item() == 2.0
        assert layer.weight[0, 1].item() == 0.0
    
        # Exact interpolation remainder for q(d)=d^2 on [0,1].
        rows = [
            {"candidate_id": "left", "displacement": 0.0,
             "endpoint": 0.0, "radius": 0.0, "path_id": "quadratic"},
            {"candidate_id": "right", "displacement": 1.0,
             "endpoint": 1.0, "radius": 0.0, "path_id": "quadratic"},
        ]
        record = matching_record(rows, 0.5, 0.01, curvature=2.0)
        assert record["status"] == "bracketed_surrogate"
        assert record["estimate"] == 0.5
        assert record["allowance"] == 0.25
        assert abs(record["estimate"] - 0.5**2) == record["allowance"]
    
        # Feedback inputs contain the preceding label only.
        task = make_uncued_task(3, 12, 4, seed=0)
        feedback = observation_tensor(task, "past_target_feedback")
        assert bool((feedback[:, 0, 2:] == 0).all())
        assert torch.equal(
            feedback[:, 1:, 2:].argmax(dim=-1),
            task["labels"][:, :-1]
        )
        assert observation_tensor(task, "uncued").shape[-1] == 2
  • sectionUnexecuted unit-test specificationsUnexecuted unit-test specifications · lines 2762–2770
    Open as its own page

    The eight-point test checks the algebraic reference on one symmetric finite design. It is not a numerical reproduction of the Gaussian population experiment. Passing implementation tests would not prove statistical freshness, optimizer convergence, or construct validity.

Claim-to-certificate ledger

  • sectionClaim-to-certificate ledgerClaim-to-certificate ledger · lines 2772–2845
    Open as its own page
    of the mathematical release.
    ClaimStatusCertificate or boundary
    ClaimStatusCertificate or boundary
    Point history reveals the active hidden ruleExcluded under the printed interfaceInput-rule independence and stationary posterior.
    The uncued optimum is ProvedContinuous symmetric point law and the four printed ID mappings.
    Four IDs give four distinct functionsFalseIDs 1 and 2 implement the same function.
    Every ID switch is behaviorally informativeFalseFunction equivalence and disagreement matrix.
    Optimal accuracy proves rule adaptationFalseA memoryless -mapping attains the optimum.
    Delayed cues and feedback test observable adaptationDeclared new protocolsTheir observation timing differs from the uncued task.
    Repeated response identifies old-rule persistenceFalseAlternating old responses and constant-response counterexamples.
    Corrected old-function fraction identifies an internal rule stateNot establishedIt certifies an observation-level response category only.
    Trial count gives independent sample countNot generallyThe fresh sequence is the statistical block.
    Ratios are certified without denominator controlExcludedPositive denominator lower bound required.
    Five-trial success pattern proves recoveryNot establishedPattern, horizon, and censoring are separately recorded.
    Masked inactive stored derivatives support regrowthFalse for the stated loss interfaceChain-rule mask factor.
    Reopened mask restores a healthy weightConditionalRequires an independently preserved pre-pruning reference.
    Score multiplier necessarily protects recurrenceFalse for the reported allocationsPer-tensor cancellation and global-division counterexample.
    Interpolated outcome is an executed matchFalseSurrogate status and response assumptions required.
    Isoacute equals iso-displacementFalseDifferent matching quantities and assessment designs.
    Quantum processing recovers absent rule informationExcluded under the same observation lawCarrier-independent observation obstruction.
    Finite cued quantum retention is exactProved pilotSpecified encoding, storage, and readout.
    Clinical ranking, cognitive mechanism, or analytic admissionNot establishedNo empirical correspondence or inherited construction.

Submission and source-alignment checklist

  • sectionSubmission and source-alignment checklistSubmission and source-alignment checklist · lines 2847–2875
    Open as its own page

    Before an empirical application, retain:

    1. an immutable source deposit, version, configuration, and checksums computed from actual deposited bytes;

    2. the complete rule functions, boundary conventions, rule priors, switch law, and optional label modifications;

    3. the precise information supplied before and after prediction;

    4. fixed versus online-updated checkpoint status;

    5. sequence, trial, segment, and window definitions;

    6. all metric numerators, denominators, exposures, and censoring;

    7. current weights, masks, references, scoring interfaces, optimizer policy, and named streams;

    8. executed candidate identities and complete intervention budgets;

    9. explicit matching statuses and surrogate assumptions;

    10. calibration and fresh assessment separation;

    11. independent training replicates when procedure-level claims are made;

    12. a separate construct-validation dossier before cognitive or clinical interpretation.

    A source title, a notebook heading, a mutable repository root, or a numerical summary is not a complete source-alignment certificate. A mathematical proof, a software execution, and a biological correspondence are different forms of evidence.

  • bibliographyReferencesSubmission and source-alignment checklist · lines 2876–3072
    Open as its own page

    CheungOCD

    N. Cheung, Structural synaptogenesis superior to functional modulation in a pruning-based recurrent network model of OCD. Frontiers in Computational Neuroscience 20 (2026), 1799705. Published 20 July 2026. https://doi.org/10.3389/fncom.2026.1799705. Computational motivation. The article's operational and biological qualifications are retained; no clinical hierarchy is imported.

    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. A different computational task and architecture.

    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. Intervention motivation, not a clinical premise.

    CheungPublicCode

    N. Cheung, 069av2.py. Public file in Structural-Synaptogenesis-Superior-to-Functional-Modulation-in-a-Network-Model-of-OCD. https://github.com/cheungngo/Structural-Synaptogenesis-Superior-to-Functional-Modulation-in-a-Network-Model-of-OCD/blob/main/069av2.py. Consulted for the task mappings and generator. Mutable branch record; no byte identity with an unprovided attachment, source checksum, or verified numerical reproduction is asserted.

    DevelopmentBrief

    N. Cheung, Psy03-D development brief: hidden-rule observability, switching metrics, masked repair, and certified matching. Supplied documentary text, undated. Its implementation descriptions are source-pattern records, not a complete versioned code deposit.

    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:cueobstruction, thm:nesting, thm:accuracystability, and prop:harddiscontinuity. No architecture identity 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 records: prop:instrument, thm:nonidentifiable, and thm:nonentailment. Its scalar and reduction models are not imported.

    CheungPsy02B

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

    CheungPsy03A

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

    CheungPsy03B

    N. Cheung, Psy03-B: Irreversible structural memory and threshold-triggered feedback in pruned networks: longitudinal certificates and a quantum–classical extension. Undated manuscript, Psy03-B-v1.tex, version 1, supplied in full. Relevant records: cor:capacity, thm:conditional, prop:fixeddesign, thm:paired, and thm:operationalmemory. No permanent scar register is inferred for the modular source.

    CheungPsy03C

    N. Cheung, Psy03-C: Recurrent stability and probe identifiability in scar-constrained networks: task geometry, temporal certificates, and a separate quantum extension. Undated manuscript, Psy03-C-v1.tex, version 1, supplied in full. Relevant records: prop:repetition, thm:bayes, cor:battery, prop:identifiability, prop:register, and thm:qpilot. Its repeated-point task and recurrent state interface are not identified with the present task.

    Hoeffding

    W. Hoeffding, Probability inequalities for sums of bounded random variables. Journal of the American Statistical Association 58, no. 301 (1963), 13–30. https://doi.org/10.1080/01621459.1963.10500830. Here applied to independent or conditionally fresh sequence blocks.

    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. A topology-update precedent, not an identity with the reported repair algorithm.

    Watrous

    J. Watrous, The Theory of Quantum Information. Cambridge University Press, 2018. Author's manuscript: https://cs.uwaterloo.ca/ watrous/TQI/. Cited for channels, instruments, trace distance, and binary state discrimination.

    PyTorchGRU

    PyTorch Contributors, GRU. Official PyTorch main documentation. https://docs.pytorch.org/docs/main/generated/torch.nn.GRU.html. Cited for gate conventions, initial-state and sequence interfaces, and interlayer dropout placement. An executed reproduction must pin its installed implementation.

    PyTorchPruning

    M. Paganini and PyTorch Contributors, Pruning Tutorial. Official PyTorch Tutorials. Created 22 July 2019; updated 2 November 2023; last-verified date stated as 5 November 2024. https://docs.pytorch.org/tutorials/intermediate/pruning_tutorial.html. Cited for original parameters, mask buffers, effective tensors, iterative masks, serialization, and removal of reparameterization. Its use of “permanent” for retaining current pruned values is not identified with a future regrowth-prohibition rule.

    PyTorchRandom

    PyTorch Contributors, Reproducibility. Official PyTorch documentation. https://docs.pytorch.org/docs/main/notes/randomness.html. Environment- and version-specific implementation guidance, not a proof of statistical independence.