The mechanism board

Most chat AIs are built from a few standard parts: a way to look back at earlier words (attention), a block that processes each word (a feed-forward layer), big grids of multiplications, and a function that scores every possible next word. UOR-R4 is trying to replace each of those parts with something built from geometry, such as rotations, exact addresses and lookup tables. Each replacement is called a mechanism. This page lists all 27 of them and says where each one stands today. Status here means how far a mechanism has been built and tested. No mechanism has produced a useful conversation yet: the project is pre-alpha, and 0 of its 8 milestones are complete (STATUS.md).

A family tree of the 27 mechanisms, coloured by status, showing which mechanism grew out of which

The 22 mechanisms with a recorded parent or child, drawn as a family tree. Most of the live ones descend from earlier, parked attempts.

What the three statuses mean

StatusMeaningCount
ACTIVEOn the current model path, crates/uor-r4-discrete.10
READYBuilt and tested, but not yet trained into a model.4
PARKEDThe forms tried so far failed or broke a project rule. The mechanism stays open, and its page lists what would reopen it.13

There is no "retired" status. Owner decision D22 says a negative result closes one tested configuration, never the mechanism, and stopping a mechanism needs the owner (D22). This board replaces the 18 October labels (active, dormant, archived-negative), which did not map one to one onto these three and had no rows for ten mechanisms.

Every number in the tables is a measurement from a recorded run or test, linked in its row, unless the cell says otherwise. The "Next" column is a hypothesis about what would help, not a result. A passing test is not a trained capability, and NOT_RUN is not a pass. BPB means bits per byte of text (lower is better). "FIT" means a pre-registered test was reviewed and judged able to answer its question.

The family tree

An arrow means "came from" or "was replaced by". A solid arrow is a successor, a dotted arrow means the target is the integer form of the source, and a double arrow means the target is a specialisation of the source.

flowchart TD
  r4g1["R4G1 graph<br/>PARKED"]
  nat["Native geometric engine<br/>PARKED"]
  lut["D11 integer serving<br/>ACTIVE"]
  stack["Geometric stack<br/>PARKED"]
  disc["Discrete learning<br/>ACTIVE"]
  pz["Prime-zeta codebook<br/>ACTIVE"]
  rel["Relation read<br/>ACTIVE"]
  obj["Object store<br/>READY"]
  rank["Rank-margin hinge<br/>ACTIVE"]
  cc["Carrier credit<br/>PARKED"]
  lc["Legal construction<br/>PARKED"]
  sfbs["SpiralCore/FBS<br/>READY"]
  tx["Ternary/XOR<br/>PARKED"]
  spin["Spin-native weights<br/>PARKED"]
  ham["Hamilton gate<br/>READY"]
  rec["Recurrence gates<br/>READY"]
  flock["Flock read<br/>ACTIVE"]
  route["Routed read<br/>ACTIVE"]
  ptr["Pointer key<br/>PARKED"]
  cells["Address cells (A8)<br/>ACTIVE"]
  mem["Exact memory<br/>PARKED"]
  e8["E8 orbit memory<br/>PARKED"]

  r4g1 --> nat
  r4g1 --> lut
  nat --> stack
  nat --> disc
  nat --> pz
  nat --> rel
  nat --> obj
  nat --> rank
  cc -.-> disc
  lc --> disc
  sfbs -.-> disc
  tx --> disc
  spin --> sfbs
  stack --> ham
  stack --> rec
  stack -.-> flock
  route --> flock
  flock ==> rel
  ptr --> rel
  pz --> cells
  mem ==> e8

  classDef ACTIVE fill:#d7f0e0,stroke:#1a7f4b,color:#0b2e1a,stroke-width:2px
  classDef READY fill:#dbe8fb,stroke:#1d4ed8,color:#0b1f4d,stroke-width:2px,stroke-dasharray:6 3
  classDef PARKED fill:#e5e7eb,stroke:#4b5563,color:#111827,stroke-width:2px,stroke-dasharray:2 3
  class lut,disc,pz,rel,rank,flock,route,cells ACTIVE
  class obj,sfbs,ham,rec READY
  class r4g1,nat,stack,cc,lc,tx,spin,ptr,mem,e8 PARKED

Five mechanisms have no recorded parent or child, so they are not drawn: admission, the tokenizer, Hopf observation, read binding and VSA. Source for all edges: the family_tree field of the mechanism board (19 October 2026).

ACTIVE: on the current model path (10)

MechanismIn plain wordsReplacesWhy this statusNext step
Discrete geometric learningTries every legal rotation of one table entry and keeps it only if the whole-number loss strictly drops. No gradients, no floating point.optimizerLearning rule of the only live model. A pilot and four large runs (K16) finished and no arm passed the bars (K16 outcome).First trained model that beats its frozen control
Prime-zeta codebookGives each word a fixed, unique starting address built from primes and zeta-zero phases.embeddingWired in as the start for new lineages, and the baseline arm P8; no trained artifact has started from it. The trained comparison against its two null controls is NOT_RUN (record).Run that comparison
Address cells (A8)Puts each word on a 16-by-16 board, next to the words that usually come just before it.embeddingRaised successor admission from 127 to 1,351 of 3,847 before training. Learning then eroded it, and a first test stopped when Relation admission fell to 551 against the control's 857 (A8 dose).Run the real CUDA qualification of the merged guard (NOT_RUN), then rerun
Routed readSends a query down a small tree of addresses and picks up the one earlier word at the end.attentionBase read of every trained artifact, but its own effect is unattributed: 20 proposals in 16,404 updates (attention state).Read-off versus read-on test with enough proposals
Flock readLooks at a few nearest earlier positions, rotates them into its own frame and moves toward their consensus.attentionPasses its 6 Flock controls (25 of 25 in the combined Route, Flock and driver run) and runs inside every Relation arm, but its own value was never isolated (driver cost).Get the coupling test sheet to FIT, with zero and random controls
Relation readLets the read follow links, such as "the word after the earlier copy of this word" (copying).attention scoring9/9 controls and two trained runs, both stopped by admission loss. No paired verdict yet (A8 dose).Paired verdict; it must beat a lookup table (6,300 of 14,287)
AdmissionNarrows 4,096 words to those in a few opened "drawers". A word in an unopened drawer can never be chosen.softmax output headThe first measured limit, seen on rung 0 (the cause of weak ranking after K16 is open): one run fell from 5,680 to 1,920 admitted rows (attention state).Admission-preserving A8 rerun
Rank-margin hingeThe loss only asks whether the right answer beats its strongest rivals by a fixed gap.cross-entropy lossInteger hinge is the discrete writer's loss. One variant (K16-R) collapsed cell occupancy (K16 outcome).Occupancy-regularised version
D11 integer servingRuns a finished model with whole numbers, adds, shifts and tables only. An audit proves no multiply instruction.arithmetic (matmul)Zero-multiply audits are green (44 native symbol ranges, 7 of 7 WebAssembly), but no lawful trained model has been exported (docs/integration/project-track.md).Export one discrete model and measure its export gap
TokenizerCuts text into 4,096 numbered pieces and back.tokenizerEvery corpus, test and artifact is pinned to it. A 16,384-piece trainer exists as tooling only (record).Matched 4,096 versus 16,384 comparison

READY: built and tested, not yet trained in (4)

MechanismIn plain wordsReplacesWhy this statusNext step
Hamilton gate (G2)Turns the gate signal into a rotation and rotates the value, so no sigmoid is needed.feed-forward gate944 tests, GPU parity 43 passed and 0 failed, 18 CUDA controls. Never trained (parity, controls).Offline-float (D37) sheet with language fit and export gap
Recurrence gatesFade rate from a table of powers of two, input opened by a clamped line, state carried by rotation.sigmoid, exp and tanh gatesTable errors at most 5.5e-8, 18 CUDA controls. The six-recurrence fit never ran (record).Show the learning surrogate gives descent
SpiralCore/FBS projectionEach output block picks one stored block and moves it along exact steps in 8-dimensional E8 space. No learned weight is multiplied.dense projections (matmul)Exact fixtures pass on an RTX 5090. Never trained. Its integer form is ACTIVE inside discrete learning (record).Descent and tokens per second in an offline-float sheet
Object store (D19)Keeps bytes exactly in a hashed tree: repeats are stored once and any range can be checked.none (durable memory)60 tests and a client conformance pass. Nothing consumes it; the durable-memory bars have not run (D19, conformance).Wire it in and run those bars (milestone M3)

PARKED: tested forms failed or broke a rule, still open (13)

MechanismIn plain wordsReplacesWhy this statusNext step
Carrier creditSends learning credit back to the geometric objects that carried the information.optimizerThree fixed arms fell from 437/512 to 0/512. The sampled-choice step uses softmax (record).Hard-selection step; needs the M2 training hold released
Legal constructionPicks each parameter change from values the integer model can hold, protecting answers already correct.optimizerNever scored. Every attempt stopped on solver numerics (record).Solve the saved case (1,960 variables) in exact arithmetic
E8 orbit memoryReplaces a feed-forward layer with a few rows of a large table addressed by E8 lattice points.feed-forward layer (MLP)Half-MLP form cost +0.033 BPB, within its bar, but learned keys beat E8 by 0.023. The gate is a sigmoid (record).Sigmoid-free gate and the named next iteration
Exact memoryWrites a fact once under an exact prime address and reads it back exactly.key-value memoryTrained forms scored 19/40 against a 27/40 bar, or used softmax. The address-as-read form was never built (record).Build the address as the read, oracle first
Pointer keyCopies the answer by the slot's exact name, not by the surrounding wording.copy headA softmax pointer. Hit rate rose from 0.377 to 0.545, but memory missed its bar (record).Lawful oracle, then a prime entity key
Read bindingA teacher marks which earlier value the question asks for, and the read is rewarded for landing on it.auxiliary lossWrong-value errors fell from 47 to 30 of 120 over 3 seeds, but on a softmax read (record).Port it to a Flock or Relation read
Hopf observationViews a 4D rotation through a 3D shadow while keeping the lost angle separately.attention scoringTelemetry only. Sector routing used 7 of 512 sectors (occupancy record); the kept-fibre language test was never run (census).Retained-fibre test
VSA4,096-bit codes glued by XOR and compared by counting differing bits.key-value memoryImproved BPB by 0.014 to 0.023 on 2 seeds, but on the banned CPU learner (record).GPU Hamming binding in the discrete model
Spin-native weightsEach 4-by-4 weight block is one quaternion, snapped to 120 icosian rotations.arithmetic (matmul)Reached 1.5148 BPB, level with dense, but only through matmul (record).Owner architecture decision
Ternary/XORWeights of -1, 0 or +1, with similarity by counting differing bits.arithmetic (matmul)A dense ternary sum is still dense (D25). Export lost: 7.416 versus 7.171 bits. Its parts run inside discrete learning.Owner ruling, or a geometric alphabet
Geometric stackThe old 7M to 214M-parameter layered model with quaternion recurrence.whole modelTrained form used softmax and matmul and served 1.20 to 1.24 BPB against a 0.90 bar (record).Rebuild from lawful parts (D37)
Native geometric engineA from-scratch Rust model with prime addresses and version chains. It answered authored questions only.whole modelNo prose. 437/512 fell to 0/128 on fresh rows (record).Re-register with the hinge loss once the M2 hold lifts
R4G1 graphCompiled a teacher model's preferences into integer lookup tables.whole modelNever wrote coherent free text, and needs a banned transformer teacher.Owner decision on repairing or removing the crates (D36)

Which mechanism covers each part of a transformer

Each row names a part of a standard transformer, says what it does, and lists the mechanisms aimed at it (A = ACTIVE, R = READY, P = PARKED). Source: the slot_map of the mechanism board (19 October 2026).

Transformer partWhat it doesOur mechanisms
TokenizerCuts text into piecestokenizer (A)
Token embedding tableGives each piece a starting vectorprime-zeta-codebook (A), address-cells (A)
Positional encodingTells the model the order of wordsGAP: none. No record names a mechanism for this.
Attention: choosing what to readPicks which earlier words matterroute-read (A), flock-read (A), relation-read (A), admission (A), hopf-observation (P)
Attention: mixing what was readCombines the chosen wordsflock-read (A)
Copy and induction headsRepeats what appeared earlierrelation-read (A), pointer-key (P)
Context memory (KV cache)Holds earlier words ready to readexact-memory (P), vsa (P), read-binding (P)
Durable memory outside the modelStores facts between chatsobject-store (R)
Feed-forward block (MLP)Processes each wordspiralcore-fbs (R), hamilton-gate (R), e8-orbit-memory (P)
Activation and gatingDecides how much signal passeshamilton-gate (R), recurrence-gates (R)
Recurrent sequence mixingCarries a running memory alongrecurrence-gates (R), geometric-stack (P)
Projections and matmulThe big grids of multiplicationslut-serving (A), spiralcore-fbs (R), spin-weights (P), ternary-xor (P)
NormalizationKeeps numbers in a stable rangeGAP: none. Snapping to an E8 root may serve, but no record says so.
Output headScores every word and picks oneadmission (A), discrete-learning (A)
LossMeasures how wrong a guess wasrank-margin (A), read-binding (P)
OptimizerDecides how to change the modeldiscrete-learning (A), carrier-credit (P), legal-construction (P)
Inference runtimeRuns the finished modellut-serving (A), r4g1-graph (P)
Whole-model engineThe complete modelgeometric-stack (P), native-geometric (P), r4g1-graph (P)

The two gaps matter. The only position-related result is about recurrent state transport, not word order, and it was measured in a model that used banned parts. The live discrete model has no position mechanism, no normalization and no feed-forward block, and it scores below a unigram baseline (audit synthesis, section 1). Having a mechanism for a slot does not mean it works: a row can list four mechanisms and no trained result.

Where the audit questions a status

Statuses are left as the audit dossiers set them (docs/labs/repo-renormalization-2026-10-19/audit/mechanisms/). Two are open to challenge:

  • D11 integer serving is ACTIVE as the end-of-pipeline contract, but no lawful model has ever been exported through it, so READY may be more accurate.
  • Hopf observation is PARKED, but its kept-fibre map is built and unit-tested and its language test never ran. Only sector routing failed, so splitting the two forms may be more accurate.

How to read a mechanism page

Each page follows the same order:

  1. In one paragraph: the idea and what it replaces, in plain words.
  2. Figure: a picture of the mechanism at work.
  3. How it works: the mechanism and its maths, labelled as definition, measurement or hypothesis.
  4. Where it stands: its status, the evidence behind it with sources, and for a PARKED mechanism what would reopen it.
  5. Go deeper: the code, the archived records and the nearest neighbours in the tree above.

Read the status first, then the "Where it stands" table. A claim there is a measurement only if it names a recorded run.

Go deeper