nys-sft-public

NYS — Sparse Kuramoto EqProp (public lineage)

NYS is not a transformer. It is a coupled-oscillator organism: phases (\theta_i), amplitudes, natural frequencies (\omega_i), and a sparse coupling graph (K). Language, compiler bits, and speech-frame IDs live on one graph ((N = 5{,}000{,}000) nodes, (k = 512) edges per node). The native graph trains by Equilibrium Propagation (free RK4, then same-moment free/nudged branches, then a contrastive (K) update), without backprop or a cross-entropy objective. A separate sparse context head now provides retrieved language inputs. The GPU Qwen teacher uses PyTorch/Transformers; that does not make the native graph a transformer.

Dakuwon Moody (YNSScarSaiyan) · Saiyan Corp

Current status — 2026-10-09

The 16,777,216-token-capacity context adapter is integrated into live NYS language training. It is sparse indexed memory, not a 16M-token dense attention window or proof of 16M-token language understanding. NYS remains an experimental research artifact, not a validated production chatbot.

Snapshot: 2026-10-09 15:29:56 UTC. These are dated observations, not a live dashboard or a promise that the target has been reached.

Cumulative source IDs processed are not the size of one retained context. Independent corpus rows reset the previous row's memory. Most live prompts are much shorter than capacity. Training counters and contrast are not accuracy or generalization evidence.

Source is pinned at GitHub commit df0024a30542b57d7946ea39fd453ace6180ee58. The backend workflow passed Linux CPU, Windows CPU, CUDA compilation, HIP compilation, and Intel SYCL compilation. Compilation is not GPU runtime validation: real CUDA tests ran separately on an A100, and real HIP tests on the MI325X. Intel GPU runtime has not been demonstrated. Compact public provenance and result summaries are in the evidence snapshot.

Live context mechanism and validation

Full represented prompts are indexed on the host in an ordered SQLite lexical-occurrence store. The shared sparse head scores candidates using an explicitly selected CPU, CUDA, HIP, or Intel SYCL numerical backend. The full index is not copied into GPU memory.

In the deployed language step, up to 12 retrieved IDs with explicit word boundaries plus the most recent 96 IDs enter a 127-ID maximum prompt including role framing. The native graph and Qwen teacher see the same represented content. Selected older evidence reaches the short native prompt; the graph does not attend to every stored token simultaneously. Retrieval is bounded to 32 query lexical units, 128 occurrences per cue, and 4,096 candidate IDs. Budget exhaustion causes reported abstention from evidence injection and the associated head update. Common/repeated cues can exhaust these budgets.

Retrieval happens before teacher targets exist. Projected Qwen probabilities update the separate head only after native acknowledgement of the matching complete five-step curriculum rotation. The teacher cannot run ahead. Rejected projections discard an unconsumed row without updating either model. Row-isolated indexes prevent cross-example context leakage.

The head uses analytic free/nudged equilibria of a quadratic energy, with sparse contrastive updates, decay, and clipping: not the native graph's Kuramoto RK4 dynamics. Its parameters are separate, but save/resume requires a logically paired native/head checkpoint. Context integration does not rewire the graph, add a sixth curriculum step, or replace NYS's output with a retrieved copy.

r3's retrieved-input formatting was corrected to preserve explicit word boundaries. r4 restored native progress and all 260 committed head updates; it did not silently reset the learned head. See the pinned implementation/build guide.

Verified checks, with their boundaries:

• CUDA storage/reachability probes at 1,048,576 and 16,777,216 IDs passed using handcrafted relation weights and punctuation distractors. These are not learned long-document recall or broad reasoning tests.
• An isolated 4,096-node, k=32 HIP graph completed two full five-step rotations: actual native/head HIP updates, retrieval before labels, longer-than-old-limit inputs reaching the native stream, row isolation, paired saving, and bitwise head restoration. This is an integration check, not a full-size accuracy benchmark.
• The first r4 production checkpoint at 2,190,215 had live_deployed=true and 712 nonzero learned head weights. Its head restored bit-for-bit in a separate bounded HIP process. Native + head + integrity metadata were uploaded and verified together on HF.
• Production journals show continuing head updates and retrieved-input injection. These establish actual use, not an accuracy improvement.

Current evaluations and unresolved limits

Checkpoint 2,210,000, reported at 15:11:58 UTC, was evaluated on frozen September 30 cases: 512 external next-token cases, 128 arithmetic cases, and 128 nonce-binding pairs / 256 binding cases. These are reused regression tests, not a newly sealed uncontaminated benchmark. Exact-context audits cannot exclude historical or semantic training overlap.

Binding constrained-choice was 50%, chance, with identical predictions for both members of all 128 pairs. Canonical CPU settle is an experimental readout, not the live native reader. Next-token matching is not conversational accuracy. Broad generalization is not proven. These reporters do not use the context adapter, so cannot establish its quality. A matched context-on/context-off language evaluation remains missing.

Fixed training-fixture diagnostics at this checkpoint:

• Language mix: 5 / 96 clamped top-1 (5.2083%); 74 / 96 targets had direct prompt-to-gold edges. 22 / 96 still lack these sampled connections. Stronger existing weights cannot create absent edges; context integration did not repair native topology.
• Compiler: 80.3828% clamped free-bit accuracy vs 61.7225% after 25 CPU settle steps on fixed gadgets. Different diagnostics, not open-ended compilation or execution correctness.
• Speech: gold-edge weight lead 0.200936; gold strongest in its wired pool 16.8055%, vs untrained pool reference 13.7649%. Pool comparison is not speech recognition/synthesis accuracy.

Recovered corpora and the speech codebook differ from the September reporting series. These numbers are not a controlled before/after comparison with historical tables below.

An independent A100-SXM4-80GB topology-repair A/B started from step 2,120,000. Each arm ran 1,440 CUDA updates on the same 288 language records over five epochs. Repair changed 54,546 edges; 381 added edges changed weight during native training. Sampled direct coverage rose from 74/96 to 78/96. But canonical external accuracy stayed 3/512 for source, control, and repair, arithmetic 1/128, and complete binding pairs 0/128. Repair vs control had zero helpful and zero harmful canonical prediction changes. The candidate was not promoted. This bounded language-only trial does not evaluate the full live curriculum or the newly integrated context adapter.

Paired checkpoint downloads and recovery

Known verified pair at the dated snapshot:

• Native checkpoint at step 2,210,000
• Immutable HF revision: 9cf0a6f80a49a899d5c6583445dd1a7b9493ab14
• Native bytes: 20,640,000,016; SHA256: 74494f292bf836582b723004d6fcee72af3b9462312079bce0d6069de28c4369
• Required same-name .bin.context/ directory: model.json, weights.npy, pair.json. The native .bin.json upload record also records sizes and hashes.

Download this pair using the current hf CLI:

hf download YNSScarSaiyan/nys-sft-public \
  --revision 9cf0a6f80a49a899d5c6583445dd1a7b9493ab14 \
  --include 'lineages/qwen-mi325x-4b-20261009-r4/checkpoints/gpu_eqprop_2210000_20261009_150930.bin*' \
  --local-dir ./nys-checkpoint

The wildcard includes the native file, upload JSON, and three companion files. Preserve their relative layout. Verify native size/header/hash and companion hashes, vocabulary, geometry, basename, and exact step. A .bin alone is not a complete context-enabled resume. pair.json is published only after the head/config files are durable.

Retention commits both halves and recovery metadata together, keeps the two newest complete local snapshots, and protects recovery inputs. Local pruning requires fresh integrity plus immutable-revision and current-remote verification of native and context files. Remote snapshots are never deleted. Reviewed source/launch recipes are in the lineage's recovery/ directory.

Context resume requires --context-library, explicit --context-backend, and --context-resume CHECKPOINT paired with the exact protected native recovery checkpoint. Omitting context resume creates a new head, not continued learned context state. See the pinned guarded supervisor and paired retention worker.

The read-only context reader loads the same head/input adapter and a read-only graph. Its final output is a CPU KOPG graph readout, not an automatic copy answer or a demonstration of native RK4 text generation. This custom format is not a Transformers AutoModel.from_pretrained checkpoint.

Historical diagnosis — 2026-09-11: the training rule was measured to be broken, and why

This section preserves the diagnosis and verification status as written on September 11. The corrected rule is now deployed in the October continuation and has passed real HIP integration/numerical checks. Runtime correctness does not establish improved accuracy; use dated results above.

Every accuracy number below step ~1,350,000 in this card was produced under a contrastive update that we have since measured to be dominated by noise unrelated to the training signal, on every slot. This is not a data problem, a wiring problem, or a readout problem — those were real and were fixed first (see the changelog below) — it is a problem in how this specific kernel computed the EqProp contrast. Recording the failure honestly, and the fix, in public:

The mechanism. Each training step: 5 RK4 steps free, then 5 more RK4 steps with the nudge force on, then (\Delta K_{ij} \propto \cos\Delta\theta_{\mathrm{nudge}} - \cos\Delta\theta_{\mathrm{free}}) on gated edges. That contrasts the state 5 steps later against the state 5 steps earlier — two different points in time, not two conditions at the same moment. Natural frequencies (\omega_i) span 50–1000 rad/s (host_init_graph, uniform), so in the 0.1 s (5 × dt=0.02) between the two snapshots a typical pair of nodes counter-rotates by ~36 rad from (\omega) alone. The nudge itself moves a target by ~0.003 rad in the same window. We measured this directly by replaying real training steps offline against a live checkpoint, once with the nudge force on and once with it zeroed (same amplitudes, same gated edges), and comparing:

At that SNR, (K) on any edge is a random walk that happens to be centered near the target most of the time — not a trained value. This explains a pattern that was otherwise puzzling: the speech clamped-pair accuracy went from 16.1% at 930k to 4.4% at 1,350,000 — worse, after 420,000 more steps, on a slot that was correctly wired the whole time. A noise-dominated update drifts; it does not reliably improve.

A second, smaller effect compounded this on speech specifically: the target phase ((\bar\theta), what nudged nodes are pulled toward) was computed as the mean over the entire prompt, which for a typical speech step is 32 neighbor-fill tokens spliced in for exploration plus ~2.3 real text tokens. The fill tokens were 91.5% of that mean. Gold frames were being pulled toward the phase of unrelated neighbor tokens, not the phase of the text that was supposed to teach them.

The fix (deployed 2026-09-11, verified offline, live verification in progress — check the changelog / latest checkpoint metadata for confirmed results before citing numbers past this point):

1. Same-moment contrast. After the free phase, two branches run from the identical state: one continues free, one is nudged, both for the same number of steps. (\Delta K) contrasts those two — the (\omega) rotation is common to both branches and cancels exactly. Costs one extra 5-step integration per training step.
2. Target from the real prompt only, not the neighbor-fill tokens.
3. (\omega) scaled by 0.01 inside the integrator (--omega-scale, the stored (\omega) in the checkpoint is untouched and this is reversible by restarting with a different value). Comparing branches removes the drift, but at the original (\omega) magnitude no pair can phase-lock within a 5-step nudge window regardless — the coupling term is too slow relative to the free rotation. Offline replay on 40 real speech records, same edges, before vs. after:

Both signs correct, both far outside noise, only once (\omega) is slowed. A HIP self-test confirmed the new kernel runs correctly on-GPU at both settings before it went into the training loop.

What this means for the numbers in the rest of this card. They are real measurements of a real (and, until now, undiagnosed) failure mode — useful for exactly that reason — but they are not evidence about what this graph and this coupling rule can or cannot learn. Compiler and speech being stuck near chance was previously attributed to topology and shared-register conflicts (both real, both fixed at 925k and 2026-09-10 respectively); it now looks like the update itself never had the SNR to learn regardless. That question is open again, correctly this time, and is what the current run is testing.

Two artifacts on this repo — do not confuse them

The model card you are reading describes the sparse GPU lineage. The legacy file is kept for history. tlc-infer / sampler.cpp still assume the 65,536 dense (K). Dropping a gpu_eqprop_*.bin into that binary will not work. Context-enabled sparse checkpoints additionally require their learned-head companion bundle; the native binary layout remains the same.

A complete CPU sparse base also exists on YNSScarSaiyan/nys-checkpoints (base_sparse_*). This public GPU run did not resume that file. It was --init (random ring + stubs) at step 0, then trained on-card. Same (N), same (k) the whole way. No second --init, ever, on this lineage.

Changelog (most recent first)

• 2026-10-09 — native context integration and paired recovery. 16,777,216-ID memory feeds retrieved evidence into the existing Qwen language step; target-blind retrieval, native-acknowledged head updates, word-boundary correction, learned-head-preserving resume, and hash-verified native + head HF retention. CUDA capacity and actual HIP integration checks passed; broad language generalization remains unproven.
• 2026-10-09 — A100 repair A/B. Connectivity and native learnability improved, canonical accuracy did not. Candidate not deployed.
• October continuation — MI325X and GPU Qwen3-4B. Complete verified five-step curriculum, pinned teacher/data, 5,000-step saves, guarded resources, and CPU-only accuracy/generalization reporters attached.
• 2026-09-11 — contrastive-update SNR fix. Same-moment branch contrast (cancels (\omega) drift exactly), target phase from real prompt tokens only, (\omega \times 0.01) inside the integrator. See the section above. Offline-verified at that date; October corrected training is live. Runtime correctness and measured capability remain separate.
• 2026-09-10 — speech data/training fixes, in order:
• Vocoder codebook rebuilt: the old k-means fit left 235 of 256 atoms at their identity-DC initialization (empty-cluster failure — a centroid with no assigned frames never moves). One code covered 79% of every frame in the training corpus. Refit with data-seeded k-means++ and empty-cluster reseeding from the worst-fit frame: 1 of 256 atoms left flat, all 256 codes in use, reconstruction SNR 2.9→9.2 dB.
• Silence frames (the code that maps to near-zero-variance PCM, ~65–75% of real speech audio) excluded from both training targets and negative examples, on both the HIP trainer and the Python wiring pass. They were previously being pulled toward every record's own phase simultaneously — the same "shared register, many writers" conflict described below for the compiler band.
• Speech negative-example generation fixed: the old rule added code+1 and code+127 neighbors of every gold frame as negatives appended to the prompt (so they dominated the target-phase mean; see above), and did not check whether a negative for one record was gold for another. Measured on the live corpus: 39.9% of positive pushes were being fought by a negative push on the identical physical node. Fixed: one negative per gold frame, checked against a corpus-wide gold set (load_global_gold_frames) so a negative can never be a duplicate of someone else's target.
• (K)-value clamp added to the kernel ((\lvert K \rvert \le 3)): contested nodes had walked to (\lvert K \rvert = 16)–18 (vs. a wiring-pass seed of (K=0.2)) before this was caught; a stale hard reset of the speech band's edges (--reset-speech) was run once to clear the accumulated damage.
• 2026-09-09 (925k) — CSR wire. Random ring+stubs never connected vocab tokens to the compiler band (3,800,000+) or the speech band (4,300,000+). Wired in place on existing (k=512) slots (weakest non-protected edge replaced, seed (K=0.2)). (N), (k) unchanged.
• Earlier: neighbor-fill (32), speech (\beta) floor (0.25), compiler signed 0-bit nudge — see prior card revisions in this repo's commit history.

Status at 1,350,000 — under the pre-2026-09-11 rule (see caveat above)

These are the last numbers produced before the SNR fix. Treat them as a record of the failure mode, not a capability grade.

Compiler additionally has its own, separate confound even with a correct update: 11 gold gadgets share the same 64 bit-oscillators. A settle-based probe (clamp the spec, run free RK4, read where the 64 nodes land — bypassing the old "read whatever theta a node was last left at" readout convention) confirmed the band is driven by the spec (no zero-displacement edges), but different specs produced statistically unrelated crystals (pairwise Hamming ~30/64, chance is 32) — the register is being fought over, not un-addressed. That conflict is unresolved and is a second, independent reason compiler will need more than the SNR fix.

Sidecar quizzes at 930k (historical; see caveat above)

930k chat probe (for the record, unaffected by any of the above fixes since language readout is a separate mechanism from the SNR issue affecting the trained signal — though the same broken contrastive update was training it the whole time):

• hello → based on you provide of your was a by the there are based, we importantafter
• the result is → l0_wra in the of the
• nys is listening → "_i3gw98h

Not a chatbot. Neighbor structure is not uniform noise; replies are still template / salad. Whether that ceiling is topology (briefing hypothesis: fixed ring+stubs never contain the right edge) or the same SNR problem as speech/compiler is now an open question again — it hasn't been re-tested under the fixed update yet.

What the organism is

NYS is one substrate with five slots. Slots 1, 2, and 4 train. Slot 3 is a crystal→beep readout. Slot 5 is a dump envelope (not trained). These organism slots are not the five curriculum steps (mix, hard, qwen_direct, compiler, speech): the first three all train language. Context feeds qwen_direct; voice and dump remain non-training slots.

Compiler execution of open-ended x86 is a quench + crystallize + mprotect/CALL path (execute.asm). This sidecar does not execute the crystal. Demo gold (8-byte active, LSB-first spins):

• f(x)=x+42: 48 89 F8 48 83 C0 2A C3
• f(x)=x*x: 48 89 F8 48 0F AF C7 C3
• plus ident, inc, dec, neg, not, shl1, add_self, zero, sub1 (11 gadgets on the same 64 bit nodes — this is the shared-register conflict noted above, separate from and in addition to the SNR issue)

Spins freeze LSB-first, 8 spins/byte, bit = (\mathrm{sign}(a_i \cos\theta_i)). 26 bits are tied across all padded golds; 38 are free. Grade free bits.

Physics and trainer

Equation and active set

The HIP fused kernel (eqprop_gpu.hip, hipcc, --offload-arch=gfx942) does not wrap all (N) oscillators and does not explode 512 neighbors of neighbors. As of the 2026-09-11 fix, each training step:

1. Build (S = \mathrm{unique}(\mathrm{prompt} \cup \mathrm{nudge\ IDs})), hard cap 256. Prompt is packed first; if (|S|>256), the tail is dropped.
2. Prompt nodes start at amplitude 1; others 0.
3. Neighbor fill: up to 32 unseen CSR neighbors of the last prompt token are spliced into the prompt (amp 1) for exploration. The target-phase mean (next step) is computed from the real prompt only, excluding these — fixed 2026-09-11; previously the fill dominated the mean.
4. Free RK4: 5 steps, (\mathrm{d}t = 0.02), (\omega) scaled by --omega-scale inside the integrator (default in the current run: 0.01; the checkpoint's stored (\omega) is never modified, so this is a launch-time choice, reversible by restarting with a different value).
5. Branch point. From the free-phase end state: - Branch A (free-continued): 5 more RK4 steps, no nudge. - Branch B (nudged): 5 more RK4 steps from the same starting state, force (\beta \sin(\bar\theta - \theta_i)) on nudge targets. (\bar\theta) is the circular mean of the real prompt at the branch point (see step 3).
6. Nudge targets get amplitude (\min(1, |\beta|)) for branch B. Amp gate for (K) updates is 0.1.
7. Contrastive (K): on CSR edges whose both ends have amp (> 0.1), (\Delta K_{ij} \leftarrow \eta\,(\cos\Delta\theta_{B} - \cos\Delta\theta_{A})) — both branches measured at the same elapsed time from the same starting state, so (\omega)-driven rotation is common to both and cancels. (K) is clamped to (\lvert K \rvert \le 3) after each update.
8. Amplitudes written back to 0.

Before 2026-09-11, step 5 did not exist: branch B was compared directly against the step-4 (free) snapshot, 5 steps earlier in time. See the diagnosis at the top of this card.

Defaults: (\eta = 0.05), (\beta = 1.5). One HIP block, 256 threads. Model state ~20.64 GB HBM. The historical cap was 77 GiB. The October continuation caps native owned allocation at 28 GiB and configures a 12 GiB GPU-teacher budget, with shared-host reserves including at least 16 GiB free VRAM. Guards do not count every driver/runtime allocation. No hipDeviceReset or control of other projects' trainer processes.

Contrast is the native signal

A printed contrast=0.00000 (or a slot column of 0.00000) can reflect no amp-gated edges, a small rounded value, or cancellation, not a perfect model. It is a heartbeat (mean (\Delta\cos) on gated edges), not accuracy, and — as of 2026-09-11 — is understood to have been dominated by an artifact for every slot prior to the branch fix. Post-fix, it is the same statistic computed on a rule with verified nonzero SNR; still not a substitute for the clamped-pair / settle-based accuracy checks.

Live rotation

Each loop tries, in order: mix (tailed hard file) → hard (train + SFT wrap) → SDS1 distill → NYSA compiler → NYSV speech.

October training requires all five steps, using live GPU Qwen3-4B projected probabilities in qwen_direct instead of the historical static SDS1 file. A complete rotation advances five native updates. Separate context-head updates do not count as extra native steps.

HIP holds NYSA/NYSV as FILE* for the life of the process. Slot updates must be atomic mv onto those paths; a truncate/scp onto an open slot file will crash the trainer.

Sparse checkpoint layout

Little-endian. Reject any file whose size is not 20,640,000,016. Current saves are append-only immutable snapshots with partial-write handling and exclusive final publication. Resume only from a complete file and, for context continuation, a validated companion bundle. Native layout is unchanged by context integration or the 2026-09-11 fix — \omega in the file is the same value it always was; scaling happens only inside the integrator at load time via --omega-scale.

Offsets:

theta_off  = 8
amp_off    = 8 + 8N
omega_off  = 8 + 16N
row_off    = 8 + 24N
col_off    = row_off + 8(N+1)
val_off    = col_off + 4 N k
end        = val_off + 4 N k   = 20,640,000,016

Init topology (this lineage): for each row, (k-16) local ring (i - k/2 + j) mod N, last 16 random stubs. Training updates values on those edges. At 925k, a CPU pass replaced the weakest non-protected column in some rows so vocab ↔ compiler/speech IDs share an edge. At 2026-09-10, the speech band's edges were additionally force-reset to the wiring seed value once, to clear damage accumulated before the silence/ negative-collision fixes existed. (k) is still 512 throughout.

Filename: gpu_eqprop_<steps>_<YYYYMMDD>_<HHMMSS>.bin (UTC). The trainer parses steps from the name (or symlink target) for --resume-steps.

Tokenizer (do not retrain)

vocab_sparse.json (~107 MB). HierarchicalTokenizer: bytes 0–255, then greedy 4-gram phrases. The frozen space-join encode bug is part of the ID space — do not "fix" it or IDs will not match (K).

The October adapter's frozen vocabulary SHA256 is 23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e. Retrieved-input boundary corrections do not change the tokenizer. NYS capacity counts these IDs, not interchangeable Qwen tokenizer tokens.

IDs above vocab and below (N) are reserved bands (compiler / voice entropy / speech / dump). They are first-class oscillators, not a second model.

Training data

Corpora live on YNSScarSaiyan/nys-corpus unless noted. Slot files also upload under slots/ on this repo.

Slot 1 — language

The static distillation row is historical: that fixture is absent from the restored bundle; no accuracy on it is claimed. The current run validates both hard corpora and a corrected 2,050,000-record mixture with all nine sources: agent_flan, glaive, hermes_fc, openhermes, orca, toolace, tulu3, ultrachat, xlam. Mix SHA256: 425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9.

Live teacher prompts use HuggingFaceH4/ultrachat_200k, train_sft, revision 8049631c405ae6576f93f445c6b8166f76f5505a. Prompt repetition is enabled. Upstream model/data licenses and terms apply separately; this repository's MIT metadata does not relicense third-party teachers or training material.

Slot 2 — compiler physics (NYSA)

412 records: I/O triples (kind 1: 385), gold bytes (11), structural bit maps (5), traces (11). HIP nudges bit nodes at 3_800_000 + i with (+\beta) (spin 1) or (-\beta) (spin 0). All 11 gadgets share the same 64 oscillators — confirmed via settle-based conditioning probe to be a genuine unresolved conflict, not a readout artifact.

Slot 4 — speech (NYSV + NYVC)

Frame IDs = 4_300_000 + t*256 + code. ALIGN_MAX_FRAMES=64 keeps (|S|) under the 256 cap. As of 2026-09-10, silence-coded frames are excluded from both nudge targets and negative examples; negatives are checked against a corpus-wide gold set to guarantee zero collision with another record's target.

Slot 5 — dump (NYSD)

Reserved envelope + inbox. The trainer does not EqProp NYSD.

Historical sidecar (CPU, after every complete snap)

sidecar.py mmaps the checkpoint. Does not run the HIP kernel. Its readouts (chat KOPG, crystal Hamming, speech frame_match) score stored theta directly — which, independent of the SNR issue, is the value a node was left at by whichever record touched it last, not a response to a live prompt. A separate read-only inference mode (eqprop_gpu --settle: clamp a prompt, run free RK4, read where target nodes land, no training-state mutation) exists and was used for the compiler conditioning check above; it is not yet wired into the routine sidecar quiz path.

Outputs (also uploaded here):

sidecar/gpu_eqprop_<step>_<utc>/
  train_acc.json  # clamped-pair acc (language / compiler / speech)
  eval.json       # train_acc + chat + free Hamming + speech lock + codec
  ...

This is the historical sidecar path. October CPU reporters also produce fixed-fixture language/speech/compiler diagnostics and frozen generalization controls, with readout/contamination caveats; they do not evaluate context. Current retention requires size and SHA256, paired native/head files, pinned/current remote verification, and two newest local snapshots. A size-only remote listing is insufficient deletion authority.

How to load (sparse)

import os, struct, mmap

FULL = 20_640_000_016
path = "gpu_eqprop_1350000_20260911_071500.bin"  # use the newest on this repo
assert os.path.getsize(path) == FULL

with open(path, "rb") as f:
    mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
    N, k = struct.unpack_from("<II", mm, 0)
    assert N == 5_000_000 and k == 512

Historical native-only train / resume example (HIP, MI300X / gfx942), not the current full-curriculum GPU-teacher/context continuation. For the current recipe use the pinned supervisor and paired recovery metadata above. Never --init unless you intend to throw this lineage away.

hipcc -O3 -std=c++17 --offload-arch=gfx942 -o eqprop_gpu eqprop_gpu.hip
./eqprop_gpu \
  --data-dir ./data --live --live-mix ./data/mix_sft_sparse.bin \
  --ckpt ./gpu_eqprop_1350000_20260911_071500.bin \
  --save-every 5000 --save-dir ./ckpts \
  --vram-limit-gb 77 --device 0 --lr 0.05 --beta 1.5 \
  --omega-scale 0.01

Omit --omega-scale (or pass 1) to reproduce the pre-2026-09-11 dynamics exactly — the checkpoint format and stored values are identical either way.

Files in this repo

• gpu_eqprop_<step>_<utc>.bin — sparse snapshots every 5,000 steps. Each file is the full substrate, not a delta. Reject any file that is not 20,640,000,016 B.
• sidecar/gpu_eqprop_*/ — CPU readouts.
• slots/ — NYSA / NYSV / NYVC / NYSD copies used by this run.
• nys_sft_final.bin — legacy 65,536 dense SFT (see table above).
• PROGRAM_CHARTER.md — cross-program charter.
• lineages/<run-id>/checkpoints/ — continuation snapshots, upload JSONs, and required .bin.context/ bundles for context-enabled runs.
• lineages/<run-id>/recovery/ — reviewed source and launch/source metadata.
• documentation/20261009-evidence.json — compact dated evidence for this update.

Select within the documented production lineage and verify the record, not the largest filename globally: historical and experimental lineages coexist. Pin immutable HF revisions. More steps do not imply higher accuracy.

Hardware and stack

Limitations (read this)

• Historical accuracy caveat: every accuracy number from before 2026-09-11 was produced under a contrastive update with a measured signal-to-noise ratio of roughly 1:6,000. Treat those numbers as documentation of the failure mode, not as evidence about the organism's ceiling in either direction.
• Runtime correctness is not capability. Corrected native training and context integration have actual HIP verification; broad generalization and a context-on/context-off language-quality gain remain unproven.
• 16M means indexed memory capacity, not dense attention, a native active set of that size, a 16M-parameter head in this run, or demonstrated 16M-token language understanding. Sparse retrieval can miss evidence.
• Native topology still limits readout. In the fixed language sample, 22/96 targets lack direct prompt-to-gold edges. Context does not create native edges. The A100 topology-repair candidate was not promoted.
• Readout/data changes matter. Stored phase, weight only, canonical CPU settle, clamped fixtures, and context-assisted readout differ. Restored corpus/codebook changes prevent simple historical accuracy comparisons.
• Compiler has a second, independent problem: 11 gadgets share one 64-bit register, confirmed via a settle-based conditioning probe to be a genuine write conflict, not a readout artifact. Fixing the SNR does not by itself fix this.
• Not a production chat model. No CE, no instruction-eval scores claimed here. Contrast ≠ quality grade. KOPG chat ≠ EqProp generation.
• This GPU lineage started from random init, not the completed CPU sparse base.
• Sparse ≠ dense. You cannot mmap these bins as a 65,536×65,536 K.
• Voice (slot 3) is digit-tone crystallize, not speech synthesis.
• Do not retrain vocab_sparse.json.
• Do not --init this lineage unless you mean to start over.
• Research artifact. Architecture-locked to this (N,k) and tokenizer.
• Not validated for high-stakes decisions. No comprehensive safety/bias assessment, reliable general-purpose generation, or open-ended compiler correctness is claimed.

Related

• Engine / trainers: local NYS/ (HIP gpu_eqprop/, CPU src/sparse_trainer.cpp, ASM src/{execute,audio,coupling,quench}.asm)
• Public source: deployed GitHub commit
• Backend CI: October 9 passing workflow
• Corpora: YNSScarSaiyan/nys-corpus
• Private / other snaps: YNSScarSaiyan/nys-checkpoints
• Charter: PROGRAM_CHARTER.md in this repo

Updated 2026-10-09 — live MI325X / GPU Qwen3-4B continuation, 16M-capacity sparse context integration, preserved learned head, paired HF recovery, backend validation boundaries, current graph-only metrics, and unpromoted A100 repair A/B. September diagnosis/results remain historical records. No broad generalization or 16M-token language-understanding claim is made.