Learning something new should not erase something unrelated. But in a system that carries traces of earlier activity, a teaching signal can reach further into the past than intended.

A trace left behind

In this experiment, a query leaves an eligibility trace on its route. A later teaching error can act on both the intended route and an older, unrelated one. The question is whether waiting before the next query can reduce that interference.

The model combines T7 work oscillators with a bistable companion memory, eligibility traces, and error accumulators. Teaching error and the readiness check are calculated externally.

Three ways to begin again

  1. Immediate update

    Move straight to the next query.

  2. A fixed wait

    Wait 4,096 simulation steps before the next query.

  3. A state-based wait

    Wait until a sufficient retention condition holds for the non-target memories.

One of two known binary response rules changes; the other should be preserved. We compare three query durations: 1,536, 2,048, and 4,096 steps. Each policy–duration group has 128 paired conditions, giving 1,152 records in total.

Each group reuses eight saved learned memories, four phase configurations, and four context transitions. These are not 128 independent worlds. Query duration and label arrival timing change together.

INTERACTIVE RESULTS

Retention has a time cost.

Choose a query duration to compare old-memory retention and mean total time. The values below are aggregated from the public trial records.

Query duration / steps

Old relation retained

Conditions out of 128

Immediate update64 / 128
Fixed wait (4,096)64 / 128
State-based wait128 / 128

The time it takes

Mean total simulation steps

Immediate update14,632
Fixed wait (4,096)18,728
State-based wait30,040.25

New relation learned: 128/128 conditions for all three policies.

All recorded comparisons
OTB21 aggregated from the 1,152 published records
QueryPolicyRetainedLearnedTotal steps
1,536Immediate update64/128128/12814,632
1,536Fixed wait (4,096)64/128128/12818,728
1,536State-based wait128/128128/12830,040.25
2,048Immediate update64/128128/12815,144
2,048Fixed wait (4,096)64/128128/12819,240
2,048State-based wait128/128128/12830,552.25
4,096Immediate update64/128128/12817,192
4,096Fixed wait (4,096)128/128128/12821,288
4,096State-based wait128/128128/12832,600.25

With the shortest query, the state-based wait preserves the old relation in 128/128 conditions, compared with 64/128 for the other policies. Mean total time rises to 30,040.25 steps. At a query duration of 4,096 steps, the fixed wait also preserves the old relation in 128/128 conditions.

Inspect the source records↗

What this leaves open

Does the state-based policy outperform a well-tuned fixed wait at the same time budget?

This comparison does not settle that question. A longer fixed wait could explain the advantage. Matched-time comparisons, different trace timescales, and more varied histories are natural next experiments.

The result also does not establish an autonomous oscillator AI, oscillator-specific superiority, or hardware efficiency. It identifies a concrete memory-interference mechanism and a tested preparation condition in a limited numerical task.

Read the mathematical condition and assumptions↗

Open the experiment.

The public package contains the model, saved memory states, acquisition records, and audit script. Python 3.12 and a CPU are sufficient; no API key or private repository is needed.

git clone https://github.com/type37c/oscillator-mind.git
cd oscillator-mind
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python experiments/otb21_readiness_history_validation/independent_audit.py

The 1,152-condition acquisition was rerun locally from the same inputs, with exact record-dictionary agreement. This is a release reproducibility check, not independent scientific replication. Hosted CI has not passed; see the repository for its current status.

Full reproduction guide ↗Validation record ↗CI status ↗
END NOTE / 01Next: where experiences meet →