The model, end to end

UOR-R4 turns text into a short list of whole numbers per word, looks back at a few earlier words by walking a small tree of addresses, and picks the stored word nearest to what it found. It never turns scores into probabilities and never multiplies large grids of numbers. This page follows one piece of text through that whole chain and marks each stage as built, trained, or missing. The honest summary is short. Most stages exist and pass small fixed tests. None of them has learned language yet: the best trained model so far is worse than a plain table of word counts (K16 outcome). The project is pre-alpha, and 0 of its 8 milestones are complete (STATUS.md).

The current pipeline. Solid boxes exist in crates/uor-r4-discrete. Dashed boxes are slots a transformer fills that this model has not filled.

How to read the status labels

• Built means the source exists and passes its finite construction controls. These are small, fixed GPU tests that show the code does what it says. A control is not a language result.
• Trained in means the stage took part in at least one learning run with a recorded result. It does not mean the run helped.
• Missing means no code exists, or no mechanism has been assigned.

Labels follow docs/formal_vocabulary.md. Proof means derived from definitions or code. Measurement means a recorded run. Hypothesis means an untested idea. NOT_RUN is never a pass.

One piece of text, stage by stage

The current model lives in crates/uor-r4-discrete. The code-level map is docs/architecture.md.

1. Tokenizer (built; fixed before training). Text is cut into numbered pieces by a byte-level BPE tokenizer with 4,096 pieces, identity d36d3e87. Every corpus, test panel and trained artifact is pinned to it (tokenizer). A 16,384-piece trainer exists as tooling only, and no model has used it.

2. Token table (built; trained in). Each of the \(V=4096\) tokens owns \(B=4\) blocks of 8 whole numbers, so its vector has width 32. Each block is always one of 16 roots from a single orbit of the E8 lattice; each root is a signed rearrangement of \((2,2,0,0,0,0,0,0)\). The model does not use all 240 E8 roots. The same table encodes a token as input, carries it as memory, and ranks it as output; that is the shared vector writer. Exact token identity is kept separately from this geometric address.

There are three ways to fill the table at the start, and they matter a great deal:

An injective code is possible in principle, because \(16^4=65{,}536\ge 4{,}096\) (proof, from the block and root counts). See prime-zeta-codebook and address-cells.

3. Ordered context (built; not learned). The most recent tokens form a window of at most 243 positions (\(3^5\)). Recorded runs used 192. A ternary tree built by SpiralCore, the project's exact-arithmetic geometry library, puts those positions at its leaves in order (spiralcore-fbs). Which position a read lands on is decided by address, not by a score over all positions.

4. Reads (built; trained in, but no read's own value is isolated). A read turns the window into one integer vector \(q\) of width 32. There are three, each a hard selection with no softmax:

• Route walks the tree, one nearest port per level, and returns one earlier position's vector rotated along the path.
• Flock keeps a few nearest earlier positions, rotates each into the current frame, sums them and snaps to a root. It was trained only inside the Relation runs.
• Relation is Flock plus a rerank along link types such as "the word after the earlier copy". It has trained twice, and both runs stopped before a verdict.

Route is the base read of every trained artifact, yet it received only 20 learning proposals in 16,404 updates (attention state). Nobody has switched a read off to see what it adds.

5. Shared writer and admission (built; trained in). The writer gives each token a cell from the root numbers of its first and last block: \(c(t)=(\rho_{\text{first}}(t),\rho_{\text{last}}(t))\), so there are \(16\times16=256\) cells. It opens the \(K\) occupied cells nearest to \(q\) by L1 distance (8 in the lineage of record, at most 16), then picks the nearest token inside them. Ties go to the lowest id. No probabilities are formed. This shortlist is admission.

Proof. A target outside the opened cells can never be chosen, whatever the read did. So admission caps everything upstream. Rung 0's top-1 bar was 1,941 rows, but only 1,920 targets were admitted at the end, so the bar was unreachable (Stage A sweep).

6. Loss (built; trained in). The score is an integer rank-margin hinge: the right token must beat its strongest rival by a fixed gap, and the loss is the shortfall. It has no likelihood, so it yields no bits per byte.

7. Discrete learning (built; trained in). One table entry is tried in all 16 legal states on the GPU, and the best is kept only if it strictly lowers the loss. See training.

8. Export (missing for any trained model). The learned table is already integers, so there is no float to round. But no exporter turns a trained snapshot into a D11 artifact, and no export gap has been measured. The existing table engine's schemas /1 and /2 serve softmax through exponent tables, and all three schemas stream dense 4-bit maps with SiLU and GELU tables, so a new table-native schema is likely needed (audit reading, lut-serving dossier; hypothesis).

9. Serving (engine built; never used for this model). The D11 engine runs integer artifacts with no multiply instruction. Its audits pass: 44 native symbol ranges (project track, M4) and 7 of 7 WebAssembly serving functions (WASM runtime record) are free of multiplies. It has served only older models, which missed the milestone bar (the 19.9M-parameter stack reached 0.933 bits per byte against 0.90, "NOT MET by 0.033"). Tokens per second for the discrete model has never been measured (lut-serving).

The missing slots

A transformer has parts this model does not. The board lists them as gaps, and no record fills them:

Two further things are also not built: using an address as the read (memory by exact name), and a writer cheaper than a scan of the whole vocabulary. The writer's own count is about 5×10⁶ vocabulary-cell comparisons per row (chief architect's review, docs/labs/course-correction-2026-10-18/audits/d37-reactivation-architect.md §3.5), which breaks the per-token sparsity rule D5-b at larger sizes. A bounded \(K\) limits the shortlist, not the work to build it.

Where it stands

The measured result. On the 14,287-row development panel, a count of the most common next token scores 1,226 top-1 hits and a context-free successor table scores 6,300 (host diagnostics). The best trained discrete model scored 65 and 463 on its two seeds, with admission of 2,237 and 3,167, and both fail the admission gate (measurement, K16 outcome). The cause is not established. A census showed that training had broken much of the early aliasing, yet top-1 stayed low, so ranking capacity, the read and the schedule all remain open, as does the address key (the architect review, section 3.2, shows it takes only five values).

Proof (address key). The address distance uses only the first and last block, and after snapping each endpoint distance takes one of three values, so the sum takes at most five values: 0, 4, 8, 12 or 16. That key must order up to 256 cells, so which cells sit just inside \(K\) is largely decided by the arbitrary cell number (chief architect §3.2, read from discrete.cu).

Go deeper

• Training: how the model learns.
• Mechanism pages: discrete-learning, admission, the mechanism board.
• Code: discrete.cu holds the reads, the writer and the learning kernels. metadata.rs builds the context plans. device.rs is the GPU boundary.
• Audit: the renormalization audit record, which holds the stitching map and the code inventory.
• Terms: glossary.