A seed is not a file

Begin with an ordinary case. A harsh remark is heard once and forgotten as an episode, yet later criticism produces defensive attention before any deliberate recollection. Change one variable. Suppose the remark is remembered vividly but no longer changes the reaction. Which is the stronger trace?

The first case has weak provenance and strong disposition. The second has strong provenance and weak disposition. That separation prepares the Yogācāra idea better than the English word “storehouse”, which suggests shelves, objects and retrieval. In the relevant texts and scholarly reconstructions, ālayavijñāna is used to explain continuity in a changing stream: prior activity leaves bīja, often rendered as seeds, or vāsanā, often rendered as perfumings or traces. Under supporting conditions, these dispositions mature into later cognitions and actions. Those occurrences can in turn condition the stream that follows. Vasubandhu’s Thirty Verses gives compact expression to this reciprocal pattern, while the Stanford Encyclopedia of Philosophy and historical studies explain the problems it was meant to solve.

Three cautions belong inside the account. First, ālayavijñāna is not an eternal witness smuggled back into a no-self tradition. It is described as a changing current. Second, a seed is not a miniature future event waiting intact for release. It is a conditioned potential whose expression depends on other conditions. Third, the account is ethical and soteriological. It concerns how afflicted appropriation and action continue, and how the basis can be transformed. These are not decorative details. They determine where a machine comparison must stop.

The distinction can be sharpened without deciding whether Yogācāra is idealism, phenomenology or another kind of Buddhist analysis. Ask what survives an intervention. If a prior act leaves a seed, then changing the relevant history while holding present conditions fixed should alter the later propensity. If present conditions matter, changing those conditions while holding the latent disposition fixed should alter manifestation. If a later event perfumes the stream, allowing or blocking the update should change subsequent propensities. These are relational commitments. They can inspire tests without converting a Buddhist term into an engineering component.

This is the first break with the storehouse metaphor. A storehouse usually preserves identity through retrieval: the grain removed is the grain deposited. A disposition does not work that way. It persists as altered sensitivity. Yogācāra’s seed language already resists literal storage when read carefully, because seeds mature through conditions and are transformed through the stream. Machine weights also resist literal storage, though for different reasons. They distribute constraints over a function. Some exact examples may be extractable, but exact memorisation is a special empirical phenomenon, not the general meaning of a trained parameter.

The source relation is thicker than causal residue

Suppose a machine passes the simple history test. Earlier interactions change a latent state, and the state changes later behaviour. That result establishes historical sensitivity. Yogācāra asks for more. The continuing stream is also appropriated through afflicted mentation as “I” and “mine”; actions are ethically inflected; their maturation belongs to a lived causal continuum; and the project culminates in a transformation that changes how subject and object are taken. A generic adaptive controller can reproduce historical sensitivity without any of these relations.

This matters because analogy often expands by verbal momentum. “Seed” first means latent causal potential. It then becomes “memory”. Memory becomes “unconscious”. Unconscious becomes “subject”. The last step appears licensed by the first, although no intervention connected them. A disciplined comparison freezes the vocabulary at the relation actually tested. If the target only shows that prior updates alter later output distributions, call it a history-shaped disposition. Do not let the source term carry appropriation, experience or ethical continuity into the target for free.

The same discipline also protects the Yogācāra account from reduction. A machine-learning description can model how one disposition conditions one output. It does not thereby explain why the source tradition distinguishes wholesome and unwholesome conditioning, why ignorance and grasping matter, or why liberation is described as a reversal of the basis. Those questions may be reconstrued under physicalism, functionalism, idealism or another metaphysics, but the reconstruction must be argued. The present paper remains neutral about that choice.

There is still genuine gain. The seed vocabulary warns against treating a latent state as a miniature stored occurrence. The machine case makes the warning experimentally sharp: many histories can converge, one state can support many behaviours, and one behaviour can be produced through different states. The transferable insight is a causal grammar of propensity, not a hidden-object ontology.

flowchart TD
  A["Two identical models with<br/>different pasts"] --> B["A seed is not a file"]
  B --> C["What training leaves behind"]
  C --> D["The comparison under intervention"]
  D -. "re-test" .-> A
  classDef first fill:#0a1424,stroke:#B96D00,stroke-width:2px,color:#e6f3ff
  classDef step fill:#0a1424,stroke:#3f7da0,stroke-width:1px,color:#e6f3ff
  class A first
  class B,C,D step

What training leaves behind

A parameter has no effect in isolation. Put the same scalar weight into two different equations and it does different work. Keep the equation fixed but change the input, and the output changes again. The operative unit is a relation among parameters, architecture, input and runtime rules.

Consider the smallest useful example. A model returns a probability

Here w is a learnt sensitivity to an input feature, b is a learnt baseline, x is the present condition, and p is the model’s current propensity to emit class one. Let w = 1.6 and b = −0.4. When x = 0, the model returns about 0.40. When x = 1, it returns about 0.77. When x = −1, it returns about 0.12. Nothing was written to the weights between cases. The latent disposition stayed fixed while the condition selected its manifestation.

What “stored in weights” can legitimately mean

Machine-learning researchers use “memory” at several levels. A model may reproduce a training string, as extraction attacks have shown in some language models. A feed-forward layer may behave like a key-value memory under a useful mechanistic abstraction. A factual association may be altered through a targeted weight update. A continually trained network may protect parameters important to earlier tasks. Each result supports a different claim.

None licenses the universal statement that each learned fact sits at one address. Geva and colleagues showed a productive key-value interpretation of transformer feed-forward layers. Meng and colleagues found localised computations and introduced a successful rank-one editing method. Hase and colleagues then showed that causal localisation does not reliably identify the best layer to edit for a standard fact-changing task. The apparent disagreement is instructive. Mediation, readability, editability and native storage are not interchangeable.

Exact memorisation is also real but narrower than the storehouse metaphor implies. Carlini and colleagues extracted individual training examples from language models under particular conditions. The finding establishes privacy risk and verbatim retention. It does not turn all parameter effects into retrievable records. Most learnt structure is many-to-many: numerous examples shape shared parameters, and one parameter participates in many behaviours.

This thought experiment exposes a common boundary error. A chat transcript may influence later tokens inside one context window. A retrieval store may carry notes across sessions. An online updater may change an adapter after feedback. The base checkpoint may remain fixed throughout. Calling the whole arrangement “the weights” hides where state lives and which process has authority to change it.

The machine candidate for a stronger comparison is therefore not a parameter tensor alone. It is a configured loop with an updater, persistence rule, data-selection policy, runtime condition and release boundary. Even then, passing the four-stage grammar does not import the source tradition’s subject, ethics or telos. It only makes the structural question well formed.

Parameters are only one layer of learnt state

Imagine pausing training at step ten thousand. Save the weights but discard the optimiser’s moving averages. Resume from the same data batch. A system restored with the full optimiser state can take a different next step from a system restored with weights alone. Both have the same current function, yet their update dispositions differ. If the comparison includes re-inscription, the optimiser state belongs inside the target boundary. If it concerns only present inference, it may remain outside.

The same boundary logic applies to adapters, normalisation statistics, routing tables and learned retrieval indexes. A low-rank adapter can carry task-specific dispositions while the base weights remain unchanged. Batch-normalisation statistics can alter predictions without appearing in the ordinary gradient parameter list. A tokenizer determines which distinctions can reach the model. A retrieval index can make new evidence available without changing the model. A policy layer can block an output that the model strongly proposes. Calling every one of these “memory” prevents precise intervention.

This example produces a practical boundary rule. Choose the state by the counterfactual being asked. “What will the system output now?” may require weights, architecture and context. “How will feedback change it?” may also require optimiser state, replay buffer, data-selection rule and release gate. “Why does it have this state?” requires provenance records that may be absent from all computational state. No single memory object answers all three questions.

The rule also explains why checkpoint copying is so revealing. Copying can preserve the present function while severing the process that produced it. Distillation goes further: a student can approximate a teacher’s behaviour using a different architecture and data route. Behavioural inheritance, parameter inheritance and historical inheritance then come apart. A robust analogy must say which one matters.

The comparison under intervention

A comparison becomes useful when it can fail for a specific reason. “Both systems contain traces” is too loose because nearly any history-dependent object qualifies. A tyre, immune system, database and coastline all contain effects of the past. The relevant test must specify which operations are preserved.

The proposed Dispositional Commutation Test uses four operations. Inscription maps a history into a changed latent disposition. Latency asks whether the changed propensity survives without continuous expression. Maturation combines the disposition with current conditions to produce an outcome. Re-inscription asks whether the occurrence can alter later dispositions through an identified update path.

Imagine two diagrams, one for the source model and one for the machine target. A mapping Φ translates the source disposition z into a target state w. A second mapping Ψ translates conditions. The comparison is strongest when translating before an operation gives nearly the same result as operating before translation.

Us is the source update described at the chosen structural level. Ut is the target system’s update. The denominator prevents a large state from making a modest mismatch look impressive. A similar error compares source and target manifestation. The equation does not prove that the domains are the same. It measures whether one declared relation survives the declared mapping.

Executable lab: Dispositional Commutation Test

The browser lab below implements a deliberately small source and target. The source has a scalar disposition z. Present condition c produces an outcome through a sigmoid. Feedback then changes the disposition. The target maps z into a machine parameter w = kz. Under matched scaling, learning rate, decay and online updating, the two paths commute. Freeze updates or change the target rule, and the analogy weakens in a measurable way.

A positive result permits only this: under the declared mapping and interventions, the target preserves the selected disposition-to-manifestation or update relation. A negative result identifies which relation fails. An indeterminate result means the tolerance, mapping or boundary is under-specified. None of the three outcomes establishes consciousness, karmic continuity or metaphysical equivalence.

from __future__ import annotations

from dataclasses import asdict, dataclass
from math import exp
from typing import Literal

Status = Literal["PRESERVE", "PARTIAL", "BREAK", "INDETERMINATE"]


def sigmoid(x: float) -> float:
    return 1.0 / (1.0 + exp(-x))


@dataclass(frozen=True)
class TestConfig:
    disposition: float = 0.40
    condition: float = 0.30
    feedback_target: float = 0.90
    source_rate: float = 0.25
    target_rate_multiplier: float = 1.0
    target_decay: float = 0.0
    scale: float = 1.40
    online_update: bool = True
    preserve_condition: bool = True
    manifest_tolerance: float = 0.02
    update_tolerance: float = 0.03


@dataclass(frozen=True)
class TestResult:
    source_output: float
    target_output: float
    mapped_source_next: float
    target_next: float
    manifest_error: float
    update_error: float
    status: Status


def run_test(cfg: TestConfig) -> TestResult:
    if cfg.scale == 0 or cfg.manifest_tolerance <= 0 or cfg.update_tolerance <= 0:
        raise ValueError("Scale and tolerances must be positive")

    z = cfg.disposition
    c_source = cfg.condition
    c_target = cfg.condition if cfg.preserve_condition else 0.0
    w = cfg.scale * z

    source_output = sigmoid(z + c_source)
    target_output = sigmoid((w / cfg.scale) + c_target)

    source_next = z + cfg.source_rate * (cfg.feedback_target - source_output)
    mapped_source_next = cfg.scale * source_next

    if cfg.online_update:
        target_rate = cfg.scale * cfg.source_rate * cfg.target_rate_multiplier
        target_next = (1.0 - cfg.target_decay) * w + target_rate * (
            cfg.feedback_target - target_output
        )
    else:
        target_next = w

    manifest_error = abs(source_output - target_output)
    update_error = abs(mapped_source_next - target_next) / max(1.0, abs(mapped_source_next))

    if manifest_error <= cfg.manifest_tolerance and update_error <= cfg.update_tolerance:
        status: Status = "PRESERVE"
    elif manifest_error <= cfg.manifest_tolerance:
        status = "PARTIAL"
    else:
        status = "BREAK"

    return TestResult(
        source_output=source_output,
        target_output=target_output,
        mapped_source_next=mapped_source_next,
        target_next=target_next,
        manifest_error=manifest_error,
        update_error=update_error,
        status=status,
    )


if __name__ == "__main__":
    result = run_test(TestConfig())
    print(asdict(result))
    assert result.status == "PRESERVE"
    assert run_test(TestConfig(online_update=False)).status == "PARTIAL"

Save the code as commutation_test.py and run python commutation_test.py. It uses only the standard library. The assertions confirm that the matched case preserves both declared relations and that a frozen target preserves manifestation while failing re-inscription.

From toy square to preregistered experiment

A serious comparison should test a family of systems rather than one favoured example. Begin with a frozen model, the same model plus persistent context, the same model plus a trainable adapter, and a fixed lookup-table rival. Give each candidate matched histories and matched present conditions. This design asks whether the apparent disposition belongs to the base parameters, transient context, a genuine update path or a simpler mimic.

The history intervention should change training examples or their order while holding evaluation conditions fixed. The condition intervention should change the eliciting context while holding learnt state fixed. The update intervention should permit, block or redirect feedback. The reset intervention should restore selected state components and check which effects survive. Each intervention targets a different arrow in the four-stage grammar. Pooling them into one score would hide where the mapping failed.

Before running the study, specify the source relation in ordinary language, the machine boundary, the translation map, tolerated error and prohibited conclusions. Preregister at least one rival that can reproduce the observed output without the proposed disposition. A lookup table is useful for narrow tasks. A prompt-conditioned policy with no persistent update is a stronger rival when the claim concerns learning. A second model with correlated training is not independent verification of the analogy.

Reparameterisation is the hardest test. Neural networks often permit changes of basis or compensating transformations that preserve the input-output function. If the proposed “seed” is tied to one coordinate that disappears under a function-preserving change, the claim concerns an analyst’s basis rather than a stable causal unit. The test can still succeed at a subspace, circuit or intervention-equivalence class, but the mapping must move to that level.

Null results are useful. If history changes do not affect later outcomes, there is no evidence for inscription at the tested boundary. If condition changes dominate while history has no effect, the system may be a contextual mimic. If feedback changes a log but not later behaviour, provenance changed without disposition. If behaviour changes but the effect vanishes under reset, the relevant state was transient. A failed arrow tells the researcher which comparison to abandon or relocate.

The smallest useful implementation is therefore not a grand consciousness architecture. It is a paired intervention: change training history while holding runtime conditions fixed, then change runtime conditions while holding learnt state fixed. Add an update gate and test whether feedback changes future dispositions. Keep a separate provenance ledger. That design already prevents the most damaging category error: mistaking a parameter effect for evidence about its historical origin.

stateDiagram-v2
  [*] --> Claim
  state "The source relation is thicker<br/>than causal residue" as Claim
  state "What “stored in weights” can<br/>legitimately mean" as Test
  state "Parameters are only one layer<br/>of learnt state" as Revision
  Claim --> Test: expose mechanism
  Test --> Decision: evidence survives
  Test --> Revision: rival survives
  Revision --> Claim: narrow or rebuild
  Decision --> [*]

Where the bridge breaks

A disciplined analogy should become more informative as it fails. Four failures matter most here: lineage without subjecthood, editing without transformation, recurrence without normativity and parameter persistence without provenance.

Forks preserve parameters, not one unquestioned subject

The fork reveals why model lineage should be tracked without importing personal identity. Copies can share all internal dispositions at time zero and then diverge. An external operator can delete, merge or deploy them. Consequences may persist in users and systems even after a checkpoint reset. The relevant machine governance objects are version lineage, effect receipts and release authority. Calling these karmic continuity adds metaphysical weight without improving control.

A local edit is not transformation of the basis

Yogācāra’s āśrayaparāvṛtti names a radical transformation associated with overcoming afflicted cognition and dual grasping. It is more than replacing one proposition with another. A model edit can be precise, useful and causally informative while remaining local to a behaviour surface.

Recursive output can re-inscribe a system and make it worse

The reciprocal loop is not automatically beneficial. When model outputs become future training data, the system can reinforce its own distortions. Shumailov and colleagues showed model collapse under indiscriminate recursive training regimes, with tails of the original distribution disappearing over generations. This provides a genuine machine instance of output affecting later disposition. It also shows why the mere presence of a loop says nothing about wisdom, purification or truth.

A Yogācāra comparison therefore needs a normative break condition. In the source tradition, karmic quality, affliction and liberation organise the account. A machine optimiser has an objective chosen by designers and data pipelines. Even when both systems exhibit recursive conditioning, the criterion of improvement is not preserved unless a rigorous mapping is supplied. Loss reduction is not moral purification. Preference optimisation is not release from grasping.

The decision matrix

What no commutation score can decide

The test deliberately abstains on metaphysics. A functionalist may argue that preserving the right causal roles is enough for a form of memory, perhaps eventually for mentality. A biological naturalist may answer that organismal regulation, embodiment and living stakes are constitutive, so an engineered loop remains only an analogy. An idealist or consciousness-primary view may treat awareness as the condition within which both biological and artificial appearances must be understood. Neutral monism, dual-aspect theory and process philosophy offer other accounts of what the shared structure might express. The commutation result does not select among them.

Nor can the result settle experience. A system can carry dispositions, update itself and report a personal history while remaining a functional mimic under many theories of consciousness. Conversely, failure to map Yogācāra vocabulary does not show that artificial consciousness is impossible. It shows only that this particular bridge has not earned the inference. Consciousness research would need a declared candidate boundary, theory-relative indicators, rival generators and a measurement bridge of its own.

Normativity is another untransferred relation. Yogācāra’s account is more than about prediction becoming statistically easier. It distinguishes forms of conditioning within a path aimed at ending affliction. A machine objective can encode human preferences, safety constraints or task rewards, but those are externally specified unless a stronger account is given. Even an agent that protects its own operation may exhibit control-theoretic stakes without felt valence or moral appropriation.

Finally, transformation of the basis is not a magnitude of parameter change. A full retraining run can alter every weight and still preserve the same harmful objective. A one-parameter edit can radically change a consequential action. Size, depth and moral significance do not align automatically. The relevant question is which organising relations changed, which remained, and according to whose criterion. This is why “fine-tuning as awakening” is more than exaggerated language. It erases the source structure that made the comparison interesting.

sequenceDiagram
  participant Q as Question
  participant M as Mechanism
  participant E as Evidence
  participant D as Decision
  Q->>M: Two identical models with different pasts
  M->>E: The source relation is thicker than causal residue
  E-->>M: compare rival explanations
  E->>D: Keep disposition, provenance and ontology apart
  D-->>Q: revise scope or act

Keep disposition, provenance and ontology apart

Do not ask whether weights “are” the Yogācāra storehouse. That question begins with an identity claim too coarse to test. Ask which relation is being borrowed, at which boundary, under which intervention, with which break condition.

For research, the practical rule is simple. Use the phrase bounded dispositional correspondence only after separating inscription, latency, maturation and re-inscription. Report the commutation errors and rival systems. State explicitly that a pass preserves a relation, not an ontology. Reserve “formal equivalence” for a supplied structure and preservation proof, which this paper does not claim.

For engineering, the comparison changes system design in a more immediate way. Separate model parameters from training provenance. Separate runtime context from world state. Separate retrieval from evidence receipts. Separate an online updater from the authority that releases its changes. A parameter tensor may carry what training made likely. It should not be asked to prove where that likelihood came from.

For philosophy, the result is neither dismissal nor assimilation. Yogācāra contributes a demanding causal grammar: dispositions are conditioned, context-sensitive and recursively transformed inside a larger account of affliction and liberation. Machine learning supplies concrete systems in which some of those relations can be intervened on. The comparison becomes intellectually useful precisely where it refuses to turn shared grammar into shared being.