How the model learns

Most language models learn by working out a smooth slope for every number inside them and nudging all the numbers a little. This model does not. It takes one entry of its table, tries every legal turn that entry can make, counts the mistakes after each turn using whole numbers, and keeps the best turn only if it beats leaving the entry alone. The method is exact, cheap per step and runs on the GPU. So far it has moved some counts but has not produced better language, and every new training run needs the owner's personal release.

One batch of discrete learning: score every legal move on 64 rows, choose the lowest integer loss, commit only a strict gain, then verify the stored result.

Labels follow docs/formal_vocabulary.md: proof is derived from definitions or code, measurement is a recorded run, hypothesis is untested. The mechanism page, discrete-learning, is the short form of this page and carries the full run history.

How it works

What is learned. The model holds three kinds of coordinate. A vector block is one of the four 8-number blocks of one token's vector. A route frame is one of 64 signed-axis rotations of 8-dimensional space, one per routing stage. A gate is a switch that takes the values \(-1\), \(0\) or \(+1\). A vector block is always one of 16 roots of an E8 orbit, so it has 16 legal states, counting "stay as it is" (architecture).

The learning step (definition). Training visits one coordinate \(\theta\) per batch. A batch is 64 rows of training text, and which rows can count is fixed by the baseline. For each candidate move \(m\) among the identity and 15 rotations, the machine replays the read and the writer and adds up the integer rank-margin loss:

\[L(m)=\sum_{x\in\mathcal R}\ell\big(x;\ \theta\leftarrow m\big),\qquad m\in\{\mathrm{id},m_1,\dots,m_{15}\}.\]

It chooses \(m^*=\arg\min_m L(m)\). Ties go to the identity, then to the lowest resulting port number, then to the lowest move index. It applies \(m^*\) only if \(L(m^*)<L(\mathrm{id})\), and then re-checks the stored table on the GPU. Nothing is sampled, and no floating-point number appears in the step.

Consequence (proof, from the definition). Every committed move strictly lowers the loss on its own batch, and the new state is always a legal state. The rule says nothing about rows outside the batch. A move that helps its 64 rows can push other targets out of the shortlist, and that is the failure behind the early stops in the table below.

Coverage (proof, by arithmetic). One pass is 16,404 batches of 64 rows, which is 1,049,856 target rows. The training split has 2,425,925 targets, so one pass sees 43.3% of them. Each coordinate is visited about once per pass, with about 64 rows of evidence (chief architect's review §3.4).

The GPU kernels

All model compute is GPU-only; a host fallback is a defect to fix (charter §3.5). The kernels live in discrete.cu and its generated siblings. The build checks the emitted GPU code and rejects any floating-point type, tensor-core instruction or approximate exponent (crates/uor-r4-discrete/build.rs, PTX admission audit).

1. Ordinary counterfactual. One block of 16 threads, one thread per move. Each thread walks every row in turn and recomputes the baseline. A route proposal took 3.903 s against 37.8 ms for a plain forward pass, which projected to about 17.8 hours for one 16,404-batch pass (measurement and projection, unverified, driver cost). A later diagnostic put this kernel at 99.99% of a proposal (sub-phase diagnostic).
2. Row-parallel counterfactual (rows_v1). It computes the baseline once per row and each virtual move once per (row, lane), then a reducer replays the ordinary loop over those records in row order. So 64 rows by 16 lanes run as 1,024 threads. It is opt-in, and it matched the ordinary kernel's losses on every finite case checked (72, 108 and 288 cases in the three tables of the rows parity record; 1,085 in all across the attempt files, per the documentation reconciliation).
3. Speed (measurement). At vocabulary 4096, 4 blocks, context 192, \(K=8\), 64 rows, on one RTX 5090, the median of five proposals:

This is the "56 times" figure. The timing is non-gating and was not qualified (qualified=false). The A8 control arm later completed 16,404 batches in 1,967 s, or 0.12 s per batch (A8 dose). It used a different read, so treat that as a rough size of the gain.

BVG-K: several coordinates per launch

BVG-K means batched verified coordinates, with \(K\) the batch size. One row-parallel launch occupies at most 8 of an RTX 5090's 170 multiprocessors, so the card sits mostly idle. BVG-K scores \(K\) coordinates in one launch (1 to 64 are supported), chooses the best move for each, and commits the whole block only if its joint loss beats the best single move.

• Scoring (measurement, quoted). About 16 times faster at \(K=16\) than scoring one coordinate at a time, from the first qualifier (BVG-K scoring).
• Block apply (measurement, on fixtures). 259 ms at \(K=16\) with joint verification, about 8 times faster than 16 single proposals at roughly 130 ms each (qualifier).
• As a learning law, never run. BVG-K has passed construction tests only. It is the matched discrete competitor that any float method must beat.

Float training, offline only (D37)

On 18 October the owner revised the discrete-only rule: floating point is legal in offline training. A float forward pass, gradients and an optimizer may be used. Three things still hold (D37):

• The bans on expensive operations stand. No softmax or other squashing function, no dense matrix multiplication, GPU only, and the path must stay geometric.
• Float lives in a separate module. It gets its own scanned entry, added with its pre-registration. It never goes in the discrete crate or in crates/uor-r4-training.
• The integer artifact is the boundary. Every float candidate reports its export gap, the loss in quality when its weights become the integer file. A gap above the two-seed noise band disqualifies it, and a float score alone qualifies nothing (D39 item 5).

No float sheet is registered. The order set in D39 item 4 is the read-code capacity capture (W2), then BVG-K (W3), then a single float-credit sheet only if W2 points at the learning law and W3 fails. The chief architect expects the export gap to be structurally non-zero, because the table entries are exact roots with no continuous scale (hypothesis, docs/labs/course-correction-2026-10-18/audits/d37-reactivation-architect.md §3.3).

Holds and pre-registration

Training is held. The global training hold, the M2 hold and Stage B all stay in force, and a review that finds a plan fit releases nothing (charter §5.1; D37 item 6).

• Pre-registration. Before any GPU training or evaluation, and before any run a milestone claim rests on, a one-page sheet states the bar, the noise, the controls, the seeds, the cost and what each outcome decides. A non-author reviews it for TEST FITNESS: FIT. A fresh-context subagent counts as non-author. Builds, finite kernel tests and host checks need no sheet.
• Release. One typed owner release per sheet covers all its arms, seeds and stop rules. Casey types it personally with UOR_LAB unset. A lab stages the commands and verifies the records, and never types one itself (D40).
• Compute. Pods go through scripts/pod/uor-pod: at most 4 pods and $8 an hour across all labs. A healthy run is never cancelled for a self-set budget.
• Bar. The M1 closing bar is integer top-1 through the D11 export, on each of two seeds, beating the unigram table (1,226 of 14,287) and the successor table (6,300 of 14,287) on the same panel, with tokens per second reported (charter §4.8). The earlier 0.90 bits-per-byte bar was replaced for M1, since the hinge gives no likelihood.

Where it stands

No training run on this path has produced a KEEP. The table below lists six campaigns since 13 October: the pilot, the Stage A sweep, the Q1 diagnosis, the four K16 runs, the A8 dose and the controller run.

What the runs say. Only 0.8% to 2.5% of batches in the K16 runs were accepted (407, 130, 410 and 129 of 16,404), against 14.4% in the pilot. A negative closes a configuration, not the mechanism (D22). The next decisive step, W2, is already reviewed fit and queued. It separates a representation wall from a learning-law wall (renormalization audit record).

Never tested. Route-frame and gate learning at dose; a full corpus pass; BVG-K or the admission-preserving rule as a GPU training run; all 240 E8 roots; any generated text or tokens per second from a trained discrete model; fresh-slice transfer (sealed); any float credit sheet.

Go deeper

• Pipeline: the model, end to end.
• Mechanism pages: discrete-learning, rank-margin, admission, legal-construction (the older float attempt at the same goal).
• Code: device.rs, training.rs, rows_source.rs, bvgk_source.rs.
• Audit: the renormalization audit record and the discrete-learning mechanism page.