Contents
Where this sits
This page is the front end of the system map. Its focus node is stage D, the address: it takes the token ids and WordNet’s hierarchy, uses the norm-5 tree, and feeds the exact placement and the records.
Phase 0 is analysis, seven measurement spikes and a preregistration. No code for any stage existed then, apart from the shared cores this page loads unchanged; Phase 1 has since written stages A–E in the Python reference (Explainer 9), and Phase 2 in the browser core, lexicon_core.js (Explainer 10); Phase 4 wrote stage F, the learned static embeddings, in the reference, and the browser core ranks their snapped tables exactly (Explainer 12). The spikes S1–S7 have run; their scripts and captured outputs are in the spikes/ folder (Explainer 8), and this page links each output where it quotes it. They measured on data kept apart from every registered instance: WordNet verbs and adjectives, Owl Academy’s canon tree, synthetic words and repository Markdown. They fixed facts the design depends on, and they decide no claim. The eleven claims L1–L11 in PREREGISTRATION.md are registered REGISTERED; Phase 1 decided L2, L3’s Python side, L5 and L7, Phase 2 L1, L3(f) and L4(a, b), Phase 3 L8–L11 (Explainer 11) and Phase 4 L6 and L4(c) (Explainer 12), all SUPPORTED, L6(c) against its registered prediction.
exact: integers, rationals or bytes, identical in every engine. float: floating point, rounded at every step. A number called a spike result comes from a captured spike output, quoted as printed (“spike S3 measured …”). Lines that the spikes mark with “~” are timings or runtime versions on this container; they are labelled as such here. A value marked illustrative is made up to show the shape of a stage, because the thing it stands for does not exist yet.
- Synset
- A WordNet set of synonyms naming one concept, such as cat.n.01. Each has an 8-digit offset. The pin holds 82,115 noun synsets.
- Hypernym
- The more general concept: mammal is a hypernym of cat. WordNet writes it as an
@pointer, or@ifor an instance. - Spanning tree
- Keep one parent per synset, its first
@or@ipointer, and WordNet’s noun hierarchy becomes a tree with entity.n.01 at the root. - Word, letter
- An address in the norm-5 tree. Letters 0–5 stand for the quaternions 1+2i, 1−2i, 1+2j, 1−2j, 1+2k, 1−2k. A word is reduced when no letter is followed by its conjugate, so the root has six children and every other node five.
- Virtual letter
- A letter that stands for no synset. A node with more than five children needs two or more letters per child; the letters after the first on such an edge are virtual.
- Lorentz product
- ⟨x, y⟩L = −x₀y₀ + x₁y₁ + …. For two points on the hyperboloid, −⟨x, y⟩L = cosh d(x, y), so it ranks by distance without a square root or a logarithm.
- MAP
- Mean average precision. Rank every other node by distance from a query node, score how early its true neighbours come, and average over the queries; 1 is perfect. Graph-edge MAP counts the parent and the children as neighbours; closure MAP counts all ancestors and descendants.
Stages A–H
Eight stages take a sentence from bytes to a model’s output. The first five are exact and need no training. The last three learn, in floats, and two of them wait until every Stage-1 claim is decided.
Green stages are exact: the Python reference decides them, and the browser core must reproduce its traces line for line (the common rules of the preregistration). Gold is float, with exact snapshots. Grey dashed stages come after the Stage-1 gate: all of L1–L11 decided and reviewed with the project’s owner before any encoder code.
| Stage | Kind | Reused unchanged | New | Decided by |
|---|---|---|---|---|
| A Normalise | exact | Nothing: the repositories have only regex and whitespace splitters (Explainer 1) | N_B in reference/lexicon/normalise.py and lexicon_core.js, on a pinned table | L1 (Phase 2) |
| B Tokenize | exact | Nothing | WordPiece and the V0 trainer (wordpiece.py) | L1 |
| C Ids | exact | engram/1 (ttmpt_core_v1.js, and biochain_v1.js engramStreamFromText) | The LEB128 id stream and its hash | L1, L2, L8(d) |
| D Address | exact | The norm-5 tree P (children, wordQuaternion, rightDivide, isReduced); certifyWord | The L3 rule, the token map, the id codec (address.py) | L3 (Phases 1–2), L7 |
| E Placement | exact | TreeEmbedding3D (pointExact, decodeExact) and nearestExact; Q and X | The exact H² tree (h2exact.py, TreeEmbedding2DExact); exact ranking (rank.py) | L3, L4, L5 |
| F Static embeddings | float | fence.js dyadic and lift for snapping | A numpy float64 trainer (embed.py) | L6, L4(c) (Phase 4) |
| G Encoder | float | H.logOrigin; for browser demos, softmaxWeights and H.lorentzCentroid | A small BERT-style encoder | Claims registered by amendment (Phases 6–7) |
| H Heads | float exact | decodeExact, nearestExact; PolyStepH for tiny heads | MLM and hierarchy heads | The same |
Every stage that produces a table also produces a record: LVOCAB/1 for the vocabulary, LADDR/1 for the address table, LPREP/1 per shard, LBENCH/1 for results (D7; Explainer 4). Each commits its stage by SHA-256, so a reader can check that two runs used the same front end.
A · Normalise exact
Before text can be split into pieces it must be cleaned the same way everywhere. That sounds trivial. Spike S6 found that it is not: the three runtimes here do not carry the same version of Unicode.
The normaliser N_B follows the rules of BERT’s BasicTokenizer, in BERT’s order (D5 and the design):
- Read UTF-8 bytes; reject invalid UTF-8 and report its offset.
- Drop U+0000, U+FFFD and control, format and private-use characters (categories Cc, Cf and Co), except tab, line feed and carriage return, which become whitespace; unassigned code points (Cn) are kept, so that their word fails closed (below). Spaces (Zs) become a plain space. This is the rule in force since Amendment 1: google-research/bert drops only Cc and Cf, and Hugging Face’s copy every C category (Amendment 2’s erratum).
- Put spaces around CJK ideographs (BERT’s ranges), then split on whitespace.
- Lowercase each word as Python 3.13’s
str.lowerdoes at Unicode 15.1: full mappings, so U+0130 İ becomes two code points, and the Final_Sigma rule, so Σ becomes ς at the end of a word and σ elsewhere. - Decompose (NFD: canonical decomposition, canonical ordering, algorithmic Hangul), then drop the combining marks (Mn). This strips accents: café becomes cafe.
- Split off punctuation (any P* category, and BERT’s ASCII ranges).
Pinned tables. Every Unicode fact N_B uses comes from a table exported once from Python’s unicodedata 15.1.0 and pinned by SHA-256 (reference/golden/unicode_15_1_v1.json, checked by make_unicode_v1.py --check). The JavaScript never calls String.prototype.normalize, toLowerCase or \p{…}. A word containing a code point that Unicode 15.1 does not assign fails closed: it becomes [UNK] and its byte offset is logged. The original bytes are never lost, because the shdccp/2 stream keeps them losslessly (Explainer 4).
Why the tables are pinned: spike S6
Spike S6 (output) swept every code point, 0 to 10FFFF without the surrogates (1,112,064 of them), through Node, Python and headless Chromium. On this container (a “~” line, the runtimes’ own versions): Node 22.23.4 reports Unicode 17.0 (ICU 78.3); Python 3.13.18 reports 15.1.0; Chrome for Testing 153 behaves as 17.0, inferred from its 159,801 assigned graphic and format code points. Node and Chromium agreed on every value. Node and Python differed on 9,990 code points, almost all of them unassigned in 15.1 and assigned since.
| Case (spike S6) | Python 3.13 · Unicode 15.1 | Node 22 and Chromium · Unicode 17.0 |
|---|---|---|
| lowercase ΟΔΟΣ (U+039F 0394 039F 03A3) | 03BF 03B4 03BF 03C2: final ς | the same, on all 52 fixed Final_Sigma cases |
| lowercase İ (U+0130) | 0069 0307: two code points | the same, on all 10 U+0130 cases |
| lowercase A ʕ Σ (U+0041 0295 03A3) | 0061 0295 03C2: final ς | 0061 0295 03C3: not final. U+0295 changed from a cased letter (Ll) to Lo after 15.1 |
| lowercase, NFD, drop marks: U+0897 alone | 0897: kept, it is unassigned | dropped: a combining mark (Mn) since Unicode 16.0 |
the platform normaliser, toLowerCase().normalize('NFD') then remove \p{Mn}, on the 20,520-case stress set | the reference | differs on 725 in Node and 725 in Chromium: 143 of the 9,990 divergent code points alone and 143 in context, 392 of 444 Final_Sigma cases, 47 of 71 canonical-ordering cases, 0 of 10 U+0130, 0 of 15 Hangul |
N_B, reading the pinned 15.1 table, gives the Python column, except that a word containing U+0897, unassigned in 15.1, fails closed and becomes [UNK]. The last row is L1’s first control, which must fail on at least one case of the stress set: it does, in both runtimes. The stress set itself is pinned: spikes/s6_stress_set_v1.json, 360,160 bytes, 20,520 cases, SHA-256 bd1179ea… (instance (c) of L1).
Spike S6 built a prototype of the 15.1 table from Python’s unicodedata: 4,009 category ranges, 2,061 single-step canonical decompositions, 388 combining-class ranges, 1,433 lowercase mappings, and two Final_Sigma sets of 437 and 150 ranges; 142,041 bytes as compact JSON. Driven by that table alone, lowercase, Final_Sigma, NFD and mark-dropping reproduced Python’s own functions with 0 mismatches on all 1,112,064 code points, and 0 on 2,000 synthetic strings. One catch: Final_Sigma needs the Cased and Case_Ignorable sets, which unicodedata does not expose. S6 read them by probing str.lower, so the real export must include them. The prototype is not the pin; the pin is written in Phase 1.
L1 registers the test: on every WordNet gloss (117,659 strings), every UD English EWT sentence (16,622), the stress set and 2,000 synthetic strings, Python, Node and Chromium must give identical normalised bytes, tokens, ids, byte offsets and id-stream SHA-256. Its prediction names the risk points: Final_Sigma context, multi-code-point lowercase (U+0130) and canonical ordering. If L1 is refuted, a fallback N1 (bytes as given, BOM stripped, CRLF to LF, ASCII lowercase) is registered. Phase 2 found no difference in any of L1’s four cells, and every control failed: L1 is supported (Explainer 10).
B · Tokenize exact
WordPiece splits each normalised word into the longest pieces found in a fixed vocabulary. A rare word still gets ids; it just gets more of them.
WordPiece, BERT’s tokenizer, works greedily from the left: take the longest prefix that is in the vocabulary, then the longest piece of the rest, marked with ## to say it continues a word. A word longer than 100 characters, or one with no matching piece, becomes [UNK]. The rule is deterministic, so once the normaliser and the vocabulary file are pinned, every engine should give the same pieces. L1 tests that it does.
V0 “lex0” · now
8,192 entries, trained by the Python reference on the 117,659 WordNet gloss strings with the algorithm Amendment 1 fixed, then frozen and hashed before the decisive run (reference/golden/vocab_v0_lex0.txt, SHA-256 df227056…): 8,059 merges on an alphabet of 64 ASCII code points, so under V0 a word with a non-ASCII letter is [UNK]. The design puts [PAD], [UNK], [CLS], [SEP], [MASK] at ids 0–4, then the alphabet, then the merges in order. V0 decides L1.
V1 · pinned
bert-base-uncased’s vocab.txt: 30,522 entries, Apache-2.0, with [UNK] = 100, [CLS] = 101, [SEP] = 102, [MASK] = 103. Phase 1 pinned it from huggingface.co, reachable since the network was widened, at revision 86b5e09 (SHA-256 07eced37…; the file stays in the cache, outside git), so it is L1’s second cell. Stage 2’s tokenizer.
A toy WordPiece in three runtimes: spike S6
S6 trained a 500-entry vocabulary on ten Markdown files of this repository (commit 7b10514, 114,397 bytes) and tokenized the same text in Python, Node and Chromium. All three built the same vocabulary (SHA-256 57273a74…) and the same 48,007-token id stream (a64bec9f…). A 500-entry vocabulary is tiny, so most words shatter:
→ hyperbolic l ##ex ##ic ##on : p ##in ##ne ##d t ##a ##b ##les , token ##i ##z ##at ##ion and word ##p ##i ##e ##ce .
ids 143 54 454 338 311 30 58 355 316 86 62 83 84 361 16 260 91 108 367 315 110 193 98 91 87 313 18
That is a determinism check, not a tokenizer worth using. V0 is about 16 times larger and trained on glosses. L1 reports, without deciding on them, how well it splits: fertility (pieces per word), the share of words split at all, bytes per token, Rényi efficiency at α = 2.5, the [UNK] rate and the fail-closed count, and its agreement with Hugging Face’s tokenizers on the same vocabulary. Two more controls must fail: WordPiece with shortest-match-first must differ from the reference somewhere on the glosses, and N_B with accent stripping turned off somewhere on the glosses or the EWT sentences.
C · Ids exact
Three different numbers attach to a token, and the design keeps them apart (D4): its token id, its tree address, and its engram/1 key. Only the first is the model’s input.
The id stream. A shard’s token ids are written as LEB128 varints: seven bits per byte, with the top bit set on every byte but the last. An id below 128 takes one byte and an id below 16,384 takes two, so every V0 id fits in two bytes and every V1 id in three. The stream is hashed with SHA-256, and that hash is part of what L1 compares across engines and what L8(d) requires Python and JavaScript to agree on; in Phase 3 they agreed on all 168 shards (Explainer 11). Byte offsets back into the original text are optional.
The id 1,907 in LEB128: its low seven bits first, with the continuation bit set (F3), then the remaining bits (0E). The id is illustrative.
engram/1, demoted. The engram/1 key, the XOR of one fixed 64-bit grid per letter, is computed only as a checksum layer that Owl Academy can read, through the verbatim biochain_v1.js engramStreamFromText. It is off by default for corpora and never an input. It keeps only which letters occur an odd number of times, so anagrams share a key and numerals sit on the zero key (Explainer 1). Claim L2 registers how often that bites: on the WordNet lemma types (147,306 before N_B), at least 1% must share their key with another type; the prediction was 2–10%. Phase 1 found 52.6% (77,520 of the 147,305 types left after N_B): L2 is supported, and the prediction was wrong (Explainer 9). Spike S4 (output) also timed it: the verbatim engram layer took 6,933.7 ms on one full verb shard, against a median 40.9 ms for the whole synchronous grow of a shard (“~” timings on this container; Engram’s engram_core: 130.5 ms). That cost is a second reason it is off by default. In Phase 3, Owl’s own grower took a median 9,319 ms a shard with engrams on and 70.5 ms with them off (over the 168 shards, C0’s and the 20 synthetic; ~, run beside other work; Explainer 11).
| Number | Comes from | Unique per entry? | Used for |
|---|---|---|---|
| Token id | The pinned vocabulary (stage B) | Yes, by construction | The model’s input; the LEB128 stream |
| Address and its id | The L3 rule on WordNet, and the token map (stage D) | Yes for synsets: claim L3 | Exact geometry, the hierarchy factor, the record LADDR/1 |
| engram/1 key | Letter parity (ttmpt_core_v1.js) | No: claim L2 | An Owl-compatibility checksum, off by default |
D · Address exact
Every WordNet noun synset gets a word of the norm-5 tree. Nothing is trained: a fixed rule reads WordNet’s own hierarchy and spells it out in letters.
The rule (claim L3)
- The spanning parent of a synset is the first
@or@ipointer of its data line. - entity.n.01 sits at the word [0].
- Children are ordered by synset offset.
- Child k of a node with c children takes m = max(1, ⌈log₅ c⌉) letters: the m base-5 digits of k, most significant first, each choosing
P.children(current word)[digit].
Each node has five onward letters, so up to five children get one letter each. A sixth child forces two letters on every child: 25 slots. A 26th forces three. The max(1, ·) gives an only child one letter instead of none. A child’s word extends its parent’s, so an ancestor’s word is always a prefix. L3(d) registers the full statement: u is a spanning-tree ancestor of v exactly when u’s word is a proper prefix of v’s. That turns the address prefix into a meaning: a prefix that two words share, if it is a synset’s word, names a shared ancestor, not the base-5 accident of engram/1 addresses (Explainer 1).
A worked example
Take a node with the word W = 00000000 (in the lab’s toy tree, mammal) and seven children. Seven is more than five, so m = ⌈log₅ 7⌉ = 2: each child writes k in two base-5 digits. After a word ending in 0, P.children allows [0, 2, 3, 4, 5] (1 would undo the 0); after a 2 it allows [0, 1, 2, 4, 5].
| k | Digits | First letter | Second letter (virtual) | Child’s word |
|---|---|---|---|---|
| 0 | 0 0 | [0,2,3,4,5][0] = 0 | [0,2,3,4,5][0] = 0 | 00000000·00 |
| 1 | 0 1 | 0 | [0,2,3,4,5][1] = 2 | 00000000·02 |
| 4 | 0 4 | 0 | [0,2,3,4,5][4] = 5 | 00000000·05 |
| 5 | 1 0 | [0,2,3,4,5][1] = 2 | [0,1,2,4,5][0] = 0 | 00000000·20 |
| 6 | 1 1 | 2 | [0,1,2,4,5][1] = 1 | 00000000·21 |
The second letters (gold) are virtual: the prefixes 00000000·0 and 00000000·2 stand for no synset. Children 0–4 share the first, children 5 and 6 the second. That sharing is what costs MAP below. The words are reduced by construction, and each is an integer quaternion of norm exactly 510 that right division unfolds back into the word: certifyWord, L3(c). The lab below recomputes this table live.
What WordNet asks of the rule
The pinned noun tree (wordnet_v1.meta.json) reaches depth 19 below entity.n.01. Of its 16,897 internal nodes, 6,162 have one child, 3,291 more than five and 396 more than 25; the largest has 659, so each of its children takes ⌈log₅ 659⌉ = 5 letters. Phase 0 counted the nouns but addressed none of them: they are registered instances. Spike S3 (output) ran the rule on the disjoint verb forest instead.
| Spike S3, the verb forest | Measured |
|---|---|
| Synsets; roots | 13,767; 559 roots under a virtual verb root [1], 4 letters each (559 ≤ 625 = 54) |
| Shape | Depth ≤ 12 below the roots; 1,462 of 3,309 internal nodes (44.18%) have one child; 526 have more than 5, 41 more than 25; the largest family, change (00126264), has 399 |
| Letters | 12,912 virtual letters; 1.9379 letters per edge on average |
| Word lengths | 5 to 26 letters. 13,762 of 13,767 (99.96%) fit 25 letters, all fit 27; the 5 longest (26 letters, depth 10) are pick_up, wave_off, foreground, raise and soft-pedal |
| Exact H³ points | All 13,767 on the sheet exactly; numerators ≤ 133 bits, denominators ≤ 73 bits per coordinate |
| Owl Academy’s canon tree | 169 nodes (canon > 10 depts > 13 artifacts > 145 tomes): words of 1, 3, 4 and 6 letters |
A 59- or 64-bit id for every word (D6)
A word is not yet a fixed-width number. The design numbers all reduced words in one sequence: first by length, then, within a length, by reading the letters as digits, the first in base 6 and each later one in base 5 (its index among the five children P.children allows):
id(w) = (number of reduced words shorter than w) + (rank of w among words of its length)
words of length n: 6·5n−1 words shorter than n: 1 + 6(5n−1 − 1)/4
The code is a bijection: every id is one word and every word one id. Words of up to 25 letters number 1 + 6(525 − 1)/4 ≈ 4.47·1017 < 259, so they fit in 59 bits (id59); up to 27 letters, about 1.12·1019 < 264 (id64). L3(g) requires the code to round-trip every noun word it covers. The design does not reuse engram_core.encode for ids: it always writes 28 letters, never uses the sixth root letter and records no length.
The 59-bit form is what the proposed SHD-CCP kernel 0xA, the Hyperbolic Address Tile, carries: the Form header in bits 60–63, even parity in bit 59, the id in bits 0–58 (the proposal; Explainer 2). Run read-only against SHD-CCP’s own Kernel Ontology tooling, it passes lint_kernel, layout_integrity (3 fields tile bits 0–63 exactly once) and glass_box_round_trip (1,000 random round trips), and Form 0xA is free in that registry. Inside Owl Academy’s and BioChain-AI’s shdccp/2 streams Form 10 is the ROT gate, so the kernel is never written there. On S3’s verbs, 5 words of 13,767 would need a continuation tile; the kernel leaves that for a later version, once L3 has measured the nouns.
What virtual letters cost: spike S3’s MAP
S3 placed every verb word in the exact H³ tree and ranked all 13,766 other verbs for each of the 13,542 verbs that have a neighbour, exactly, with ties counted against the query.
| Spike S3, verbs, exact H³ | Queries | Graph-edge MAP |
|---|---|---|
| All queries | 13,542 | 0.6309 |
| Query’s own edge has 1 letter | 5,357 | 0.9974 |
| 2 letters | 5,195 | 0.4087 |
| 3 letters | 1,928 | 0.3217 |
| 4 letters (the verb roots with children, and the children of the 3 families above 125) | 1,062 | 0.4301 |
| Closure MAP, all queries | 13,542 | 0.4206 |
Where an edge has one letter, the exact tree reconstructs the hierarchy almost perfectly (0.9974). Where it has two to four, MAP falls to 0.32–0.43. The reason is geometric, and spike S1 measured it: with one letter per edge, every neighbour is 1.9459 away and the nearest non-neighbour 3.2375. A two-letter child is 3.2375 from its parent if its last letter bends and 3.8918 if it goes straight, the same distances as its siblings under the same virtual prefix. So siblings tie with the parent or come before it. 5,396 of the 13,542 queries have a neighbour tied exactly with a non-neighbour; counting ties in the query’s favour instead would give 0.8149, shown for contrast only.
A rule fixed with the design sets the prediction for L6(c), which says the training-free exact H³ tree has graph-edge MAP at least that of learned Lorentz embeddings at d = 3: supported if S3’s verb MAP is at least 0.90, otherwise refuted. S3 measured 0.6309, exactly a 205-digit rational (SHA-256 2e428dd7…) that an independent Python recomputation reproduced. So the prediction registered for L6(c) reads refuted: the claim is expected to fail. That is a prediction, not a decision. L6 was decided in Phase 4 on the mammals, and (c) came out supported, against the prediction: trained on the closure, learned Lorentz d = 3 reaches a graph-edge MAP of only 0.458–0.477, against the exact tree’s 0.690653 (Explainer 12).
One more reading of the same word comes later. Reduced mod a prime q, a word’s quaternion lands on a vertex of the Ramanujan graph X(5, q), the overlay SHD-CCP’s RFC 03 plans (claim L7; Explainer 2). It is a shard key, never integrity: LPS Cayley hashes have known collision attacks.
E · Placement in H³ and H² exact
An address becomes a point by walking it: each letter is one step of fixed length in a fixed direction, taken in the frame of the node before. With rational steps, every point has exact rational coordinates, and greedy decoding walks it back to the word.
The octahedral tree in H³: the primary store
Hyperbolic Oracles’ decoder3d.js (TreeEmbedding3D) already does this in H³. A node sees its parent along −x in its own frame and its five children along +x (letter index 0, straight on) and ±y, ±z (90° bends). Each step is a boost with t = 3/4, so cosh τ = 25/7, sinh τ = 24/7 and τ = ln 7 = 1.9459. A point at word length n is an integer vector over 7n. Hyperbolic Oracles proves that greedy decoding returns every node at every depth when t > 1/√2 (E2, proved).
| Spike S1 (output), the H³ tree | Measured |
|---|---|
| Distances | Parent–child 1.9459 (cosh 25/7); siblings at 90° 3.2375 (cosh 625/49); siblings at 180° and the straight grandchild 3.8918 (cosh 1201/49). One 90° bend between two edges loses 0.6543, tending to ln 2 = 0.6931 on long edges |
| Exactness | Every coordinate at depth n is an integer over 7n, and every Lorentz product of two points an integer over 7na+nb. decodeExact returned the word on 840/840 ranked words |
| Bits at depth 28 | Numerators ≤ 139 bits on 20 random words, 157 on the straight word; denominators 79 bits (728). At depth 60: 297, 336 and 169 |
| Floats | Float decoding of the float placement first fails at depth 13 on random words; exact decoding never failed |
| Time (“~”) | About 1.63 ms per exact point at depth 28 on random words (0.37 ms on the straight word), against 3.0 µs for a float point |
A new exact tree in H²
The plane had no exact tree: hyperbolic_core.js’s H² TreeEmbedding uses Math.cos and Math.sin. The design builds one from directions whose coordinates are rational because they come from the Pythagorean triples 3–4–5 and 7–24–25 (D3):
- Root letters 0–5 go along (1, 0), (3/5, 4/5), (3/5, −4/5), (−7/25, 24/25), (−7/25, −24/25) and (−1, 0): angles 0°, ±53.13°, ±106.26° and 180°.
- Every later node’s children k = 0–4 take the first five in its own frame; the parent lies along (−1, 0).
- A step is the rotation R(u) to the child’s direction, then a boost with t = (m − 1)/(m + 1). Then cosh τ + sinh τ = m exactly, so τ = ln m.
The question was which m. Spike S2 (output) decoded 500 random reduced words at each depth, exactly, for six values:
| Spike S2: exact decodes of 500 | 2 | 4 | 8 | 12 | 16 | 20 | 28 |
|---|---|---|---|---|---|---|---|
| m = 3, t = 1/2 | 303 | 105 | 7 | 1 | 0 | 0 | 0 |
| m = 5, t = 2/3 | 375 | 179 | 54 | 16 | 5 | 0 | 0 |
| m = 7, t = 3/4 (H³’s boost) | 500 | 443 | 311 | 226 | 148 | 124 | 55 |
| m = 12, t = 11/13 | 500 | 500 | 500 | 500 | 500 | 500 | 500 |
| m = 19, 20 | 500 | 500 | 500 | 500 | 500 | 500 | 500 |
| H³, t = 3/4, for reference | 500 | 500 | 500 | 500 | 500 | 500 | 500 |
So the plane needs a longer step than H³ does. The H³ boost t = 3/4 decodes only 226 of 500 at depth 12 in the plane, because the plane’s directions are only 53.13° apart and a child’s subtree spreads past the half-way line toward its sibling’s direction; S2 measured that spread exactly. That failure is L3’s fourth control, which must fail. t = 11/13 (m = 12) decoded 500/500 at every depth from 2 to 28, with no exact ties in 390,000 greedy decisions and the sheet identity x₀² − x₁² − x₂² = 1 exact on all 30,000 points. So cosh τ = 145/24, sinh τ = 143/24 and τ = ln 12 = 2.4849 (D3).
S2 also looked past the design’s six values. m = 10 and 11 decode every sampled word too; the threshold lies between 9 and 10. An exact measure of how far a subtree spreads, seven levels down, leaves m = 12 a margin of at most 8.72° to the decision boundary (m = 10: 2.01°; m = 11: 6.00°). These are upper bounds: S2 measured the spread as a lower bound. On the depth-28 random words, m = 10, 11 and 12 cost 247/185, 235/167 and 225/152 bits, so m = 12 is also the cheapest of the three.
What the plane costs in bits
| Spike S2, depth 28, max numerator / denominator bits per coordinate | H², t = 11/13 | H³, t = 3/4 | Ratio |
|---|---|---|---|
| Random words (500) | 225 / 152 | 142 / 79 | 1.58× / 1.92× |
| The straight word | 201 / 102 | 157 / 79 | 1.28× / 1.29× |
| Most bent: always 106° (H²) against always 90° (H³) | 229 / 188 | 133 / 79 | 1.72× / 2.38× |
| Bent at random, ±106° against 90° | 251 / 188 | 133 / 79 | 1.89× / 2.38× |
The plane costs 1.28–2.38 times H³’s bits per coordinate, or 1.28–1.56 times for the whole point over one common denominator. The reason is the denominators: each H² step divides by 24 (the boost) times 1, 5 or 25 (the rotation), where each H³ step divides by 7. (S1 and S2 sampled different random words, hence 139 and 142 bits for the same depth.) Floats give out early here too: the same H² construction in float64 decodes 500/500 only up to depth 8 and 0/500 at depth 20.
H³ has six signed axes, exactly one per neighbour of a node, at 90° or 180° to each other; the plane must squeeze six directions into a circle. So the H³ tree uses the shorter step (ln 7 against ln 12), smaller denominators and fewer bits, its decoding is proved for every depth, and its code already exists and is tested. The H² tree’s decoding is measured, not proved: 500 words per depth to depth 28. That is why L3(e) checks every noun’s point in both trees. The plane’s tree is the 2D system’s view and a two-number feature; the float TreeEmbedding is kept for drawing only.
Exact ranking exact
To score the tree against WordNet, every query ranks every candidate by distance. In floats, deep rankings come out wrong. In exact arithmetic they are integers.
Because every Lorentz product of two points at word lengths na and nb is an integer over 7na+nb (spike S1), a ranking needs no fractions at all. Scale every point to one common power of 7, and the key −⟨Xu, Xv⟩L times that power is an integer: cosh d times a constant. Sorting integers is exact in BigInt and in Python’s int. In S3 the verb keys were at most 257-bit integers. Distances (acosh) are used only for display.
| Spike S1: first depth where the order breaks | Straight word | Random words | All 20 random words fail from |
|---|---|---|---|
float64 placement (point()) | 10 | 12 | 15 |
| float64 of the exact points | 10 | 12 | 15 |
| float32 | 5 | 5 | 7 |
| exact integer keys | the reference order itself; decodeExact also never failed (840/840) | ||
Here “breaks” means a float inversion: two candidates whose exact distances are strictly ordered come out in the wrong order. On the straight word floats mostly tie instead: from depth 10 its two growing coordinates, cosh nτ and sinh nτ, round to the same double, and products along its own line come out exactly 0 (from depth 12 with the float placement). Float32 products overflow from depth 23. Float decoding first fails at depth 13 on random words. The design concludes, and L4(b) registers, that float64 ranking is not certifiable at WordNet depth: the noun tree reaches spanning depth 19, so its deepest words have at least 20 letters, past these depths. L4(a) registers the converse: exact rank lists are identical in Python and JavaScript, and MAP and mean rank are equal as exact fractions, in both trees. Phase 2 supported both: float64 inverted an exactly ordered pair in 997 of the 1,000 noun queries, and Node gave Python’s rank lists, exact MAPs and mean ranks for the 1,176 mammal queries and noun queries 0–199 (Explainer 10).
Ties, counted against the query
Exact arithmetic finds real ties, and virtual letters make many: a neighbour and a non-neighbour at exactly the same distance. The rule (common rules of the preregistration) is pessimistic: inside a tie, every non-neighbour ranks before every neighbour, and tied candidates are listed by synset offset. Spike S1 built small trees to see how much this matters:
| Spike S1 tree | Letters per level | MAP, pessimistic | Optimistic (contrast) |
|---|---|---|---|
| Perfect 5-ary, depth 3 (156 nodes) | 1, 1, 1 | 1 exactly | 1 |
| Root with 25 children, then 5, 5 (776 nodes) | 2, 1, 1 | 0.995703 | 0.999141 |
| Root with 125 children, then 5, 5 (3,876 nodes) | 3, 1, 1 | 0.995276 | 0.995351 |
| 25-ary at every level, depth 2 (651 nodes) | 2, 2 | 0.260362 | 0.845473 |
Neighbour/non-neighbour ties appeared only where virtual letters occur. There, a float evaluator that breaks ties by node index gave a different average precision from the pessimistic exact one on 562 queries; that is L4’s second control. Hyperbolic distance is also not tree distance: on the 937 words of at most 4 letters (S1’s radius-4 ball around the empty word), it reversed the order of two tree distances in 47,352 of 2,264,600 comparisons (2.09%), only where the tree distances differ by one or two hops.
Cost. S3 ranked 13,542 verb queries against 13,766 candidates in Node in about 2.62 ms per query, 191 ns per pair (“~”). At that rate 1,000 noun queries against all 82,115 nouns take about 16 s or more, since noun words are longer. L4 uses the 1,000-query noun sample Rng(1000).sample(82115, 1000) and the 1,176-node mammal subtree, where every node is a query.
A toy tree, live
This lab runs the L3 rule, the id code and both exact trees in your browser, on Hyperbolic Oracles’ cores loaded unchanged. The hierarchy is a small hand-made one in WordNet’s style, not WordNet: nouns are registered instances, and Phase 0 addresses none of them.
H² · Poincaré disk · t = 11/13
H³ · Poincaré ball · t = 3/4
Cyan: one letter on the edge from the parent. Amber: two or more, so the edge carries virtual letters. Rose, under the control only: no letter at all. Gold: the path from entity to the selected node. ×: the tree’s origin, the empty word, which is no node. Hover or tap a node; tapping also selects it. Drag the ball sideways to turn it.
Every node: word, id, exact bits, decoding, average precision
| Node | Word | id | H³ bits | H² bits | Decodes | AP H³ | AP H² |
|---|
How it is computed. Children are ordered as listed (WordNet orders them by offset). Words follow the L3 rule with HPCore.P.children. H³ points are HPDecode3D.TreeEmbedding3D pointExact, decoded by decodeExact. H² points are built here exactly as spike S2 builds them, on HPCore.Q and X alone: the six Pythagorean directions, a step R(u)·B(11/13), frames multiplied in exact rationals, greedy exact decoding. The id is D6’s bijective code, decoded back to check. Average precision is graph-edge, ranked by exact Lorentz products with pessimistic ties. To draw, each point is moved by an exact isometry into the selected node’s frame (so its parent lies to the left and its straight child to the right), then rounded to floats. At spread ×1 the picture is the true Poincaré model; at ×s every distance from the centre is drawn divided by s, directions kept, so the outer levels do not all crowd onto the rim.
- mammal: 7 children. Every child of mammal grows from one letter to two, and the MAP drops below 1 in both trees. Tap dog: its parent is now 3.8918 away (two straight steps), while cat sits 3.2375 away, a sibling nearer than the parent.
- Add children. Select bird (3 children) and add three more. At the sixth, every child of bird is re-addressed with two letters: the L3 rule renumbers siblings when a family grows.
- The control. With “an only child gets no letter”, organism takes living thing’s word and snake takes reptile’s: distinct words fall below the node count. That is L3’s first control, which must break injectivity on WordNet’s 6,162 only children.
- Spread ×1. The true disk. With τ = ln 12 a node two straight steps from the centre is already at radius 0.986: the exponential room the tree lives in.
- The bits. Compare a node’s H² and H³ bits: the plane costs more at every depth, as spike S2 measured. These words are short; S1 and S2 measured the same growth out to depth 28 and beyond.
“The cat sat.”, stage by stage
One sentence, followed through all eight stages. Some values are fixed by the rules and some are computed live; others could not exist when this page was written in Phase 0, because the V0 vocabulary was not trained and no noun had an address. Those are marked illustrative; Phase 1 has since trained V0 and addressed every noun (Explainer 9).
| Stage | What happens to “The cat sat.” | Status |
|---|---|---|
| Bytes | 54 68 65 20 63 61 74 20 73 61 74 2E (12 bytes of UTF-8) | fixed |
| A Normalise | Lowercase, then split on whitespace and punctuation: the · cat · sat · . Everything is ASCII, so no table entry beyond ASCII is touched and nothing fails closed. | by the N_B rules |
| B Tokenize | [CLS] the cat sat . [SEP], if each word is a whole entry of V0. A rarer word would split into ## pieces, as in S6’s toy. | illustrative when written; V0, trained in Phase 1, has all four words as whole entries |
| C Ids | [CLS] = 2 and [SEP] = 3 in the design; say the = 214, cat = 1907, sat = 3315, . = 18. The LEB128 stream is 02 · D6 01 · F3 0E · F3 19 · 12 · 03, 9 bytes, and its SHA-256 goes into the shard’s LPREP/1 record. | specials by design; word ids illustrative (V0 gives the = 136, cat = 1057, sat = 1591, . = 17); the bytes follow from them |
| C engram/1 | THE c30fec4f40e96e68 · CAT f7b164a270b6804d · SAT 8f3abe44da397abc. A checksum only: ACT and TAC have CAT’s key, f7b164a270b6804d. | computed with ttmpt_core_v1.js |
| D Address | The token map (its details are fixed in Amendment 1) sends a whole-word lemma to its first-sense synset, in the part of speech with the larger WordNet tag count. For cat that should be cat.n.01, whose word starts with the nouns’ root letter 0. The design reserves root letter 1 for verbs, 2 for adjective and adverb lemmas, 3 for ## pieces, 4 for other whole words and 5 for specials, digits and punctuation. Where “the” and the inflected “sat” land depends on the map’s details. In the lab’s toy tree, cat is 000000002: 9 letters, id 585938. | cat.n.01’s real word was computed in Phase 1 (L3); the toy word is computed live |
| E Placement | The toy word’s exact H³ point: numerators ≤ 49 bits over 79 (26 bits); H²: 65 / 34 bits. Both lie on the sheet exactly and decode back to the word: checked live. | computed live on the toy word |
| F Static embeddings | cat.n.01 is a mammal, so it is one of the 1,182 synsets of the mammal closure that L6 trains on. In Phase 4 it got learned Lorentz and Euclidean points at d = 2, 3 and 50 (5 and 10 reported), five seeds each, snapped to 2−32 (Explainer 12). | Phase 4 |
| G Encoder input | For cat: its token embedding, plus the sum of learned embeddings of its address’s prefixes (length 1 to at most 12), plus the log coordinates of its exact point cut to at most 12 letters. For the toy cat these are (16.840, 5.6e-6, 0) in H³ and (22.143, 5.1e-8) in H²; for the toy dog, (17.513, 0, 0) and (22.364, 0). Seen from the origin, two words that share their first 8 letters point in almost the same direction, so these numbers mostly say how deep a word is. The prefix embeddings carry the rest. | Stage 2; the log coordinates are computed live on the toy words |
| H Heads | Masked: “The [MASK] sat.” The MLM head scores every vocabulary entry for the hidden slot. The hierarchy head scores pairs such as (feline, cat) as parent and child. | Stage 2, illustrative |
Three things are worth seeing in this table. The ids, the address and the engram key are different numbers with different jobs. Only stages A–E are fully determined by rules and pinned data, which is why L1 and L3 can be decided all-or-nothing. And the address of a function word or an inflected form carries spelling at best, not meaning: one address per token is one sense, without context.
F–H · The learned stages
The exact tree has two or three coordinates. A language model works in 128 to 768. So the hyperbolic geometry enters the model as a factor, a head and a view, not as the main embedding.
F · Static embeddings float
Phase 4 trains embeddings of the WordNet mammal hierarchy in Python float64 with a numpy reference trainer (D9): Riemannian SGD in the Lorentz model after Nickel and Kiela, and plain SGD for the Euclidean control, at d = 2, 3 and 50 (5 and 10 reported). The tables are then snapped to a 2−32 grid (fence.js dyadic and lift) and ranked exactly; L4(c) requires the snapped MAP to stay within 0.001 of float64 evaluation. L6 decides whether learned Lorentz beats learned Euclidean at low dimension and whether the advantage vanishes at d = 50 (Explainer 5). As an exploration, decodeExact can act as a codebook, sending a learned H³ point to its nearest tree word, to compare learned and constructed addresses. Phase 4 ran this design: L6 and L4(c) are supported, L6(c) against its registered prediction, and snapping moved no table’s MAP by more than 9.37×10−6 (Explainer 12).
G · The encoder float
Stage 2 is a Euclidean BERT-style encoder: 1–10M parameters on CPU in Phase 6, then BERT-mini and BERT-small on a GPU in Phase 7. It reads each token’s address as a hierarchy factor added to its input:
- Prefix embeddings. The sum of learned embeddings of the address’s prefixes of length 1 to k, k ≤ 12: a tree positional encoding in the style of Shiv and Quirk (NeurIPS 2019), applied to lexicon addresses.
- Log coordinates. A frozen factor:
H.logOriginof the exact point of the address cut to at most 12 letters, three numbers from H³ or two from H².
Why the cut at 12: a deep exact point cannot enter a float network without loss. Spike S1 saw float decoding fail from depth 13 and float ranking invert from depth 10. The prefix embeddings carry the full depth instead, as discrete symbols. Two existing pieces are deliberately left out: Engram’s register clock as a positional encoding (it is bookkeeping, not position) and its coupler as a binding of segments A and B (it gives integrity, not modelling). A fully Lorentz encoder (HyperCore) is a later, exploratory GPU arm.
H · The heads float exact
- Masked language model. A tied softmax over the vocabulary. An ablation replaces it with distance logits −d(h, ptoken)/T against fixed truncated points.
- Hierarchy head, after HiT (Explainer 5): a parent–child pair scores −(d + w·(‖parent‖ − ‖child‖)), with feature clipping (Guo et al., CVPR 2022). Its weight w, threshold and temperature are a few numbers, so PolyStepH can tune them in the browser (D11 allows heads of at most a few hundred parameters), or Adam on CPU.
- Certified assignment. Outputs are snapped and sent to tree words by
decodeExactornearestExact: an exact answer to “which synset is this?”. - Browser demos of tiny exported models can use
softmaxWeightsandH.lorentzCentroidas distance attention, for inference only. The fence and guard stay descriptors of stored tables.
None of this is registered. The roadmap lists candidate claims for an amendment after the Stage-1 gate: the address factor against shuffled addresses and no factor on BLiMP, predicted a null result within ±1 point; hyperbolic against Euclidean hierarchy heads on HiT-style splits rebuilt from WordNet; a Poincaré probe against the Euclidean structural probe on UD English EWT; and PolyStep against MeZO and zeroth-order SGD on a fixed head at equal evaluations. Hyperbolic Oracles’ C1 found no hyperbolic advantage in optimisation (0 supported, 12 refuted, 1 inconclusive), and the literature’s gains on general NLP are modest or unchecked (Explainer 1).
The 2D and 3D pages
Phase 5 builds two pages on the browser core, as Engram Mind’s Eye has its 2D and 3D pages. The lab above is a small preview, on the same cores.
lexicon-2d.html
The exact H² tree in the Poincaré disk. Type a sentence and see its tokens, ids, addresses and exact points; click a point to decode it exactly. A precision panel shows the bits per coordinate. Paths through the lowest common ancestor, the learned d = 2 cloud, and certified nearest neighbours.
lexicon-3d.html
The exact H³ tree in the ball. A frame per token from its quaternion (twin3d.js rotOfQuat). The learned d = 3 cloud, fence shells for display only, and each address’s X(5, q) vertex.
Both pages carry a shard panel that grows and verifies language biochains (Explainer 4), and an Engram session import that shows each token’s lexicon address beside its engram/1 key. Drawing uses floats: points convert to the disk and ball with H.toPoincare, and beyond depth 12 the view is a chart relative to the lowest common ancestor, re-centred as the lab does, because float positions of deep points are unreliable. The exact values stay exact underneath; only the picture is rounded. The pages will be checked in Chromium at 1440, 1024 and 390 px.
Honest limits
What this front end does not do, what it costs, and what is still open.
- All eleven are decided. Phase 1 decided L2, L3’s Python side, L5 and L7 (Explainer 9), Phase 2 L1, L3(f) and L4(a, b) (Explainer 10), Phase 3 L8–L11 (Explainer 11) and Phase 4 L6 and L4(c) (Explainer 12), all supported; L6(c) against its registered prediction. The spikes ran on verbs, a canon tree, synthetic words and Markdown; nouns may behave differently, and that is what the claims find out.
- Branching is fixed at five. Nodes with more children get virtual letters, siblings crowd the parent, and graph-edge MAP falls: 0.6309 on the verb forest (spike S3). On nouns, L5 reports it against a combinatorial embedding’s 0.989 in 2 dimensions at about 500 bits (Sala et al. 2018) verified and predicts it falls short; Phase 1 measured 0.5679 in H³ and 0.5901 in H² on the noun queries (Explainer 9). Address variants that give heavy subtrees shorter words (Huffman-5), or that follow the tokenizer’s merge forest for
##pieces, come later, by amendment. - One parent only. The spanning tree keeps the first hypernym; 2,213 noun synsets in the pin have several. Closure MAP keeps them, the address does not.
- Addresses belong to one WordNet. They depend on offset order and on family sizes. A new child renumbers the siblings after it, and a family passing 5, 25 or 125 children lengthens every sibling’s word (try it in the lab). The table is committed by a Merkle root,
addrTableRoot; another WordNet version is another table. - One sense, no context. A token maps to its first-sense synset. Most
##pieces have no synset and get spelling-based addresses that carry no meaning. - Exactness costs bits. Depth-28 points take about 139-bit numerators in H³ and up to 2.38 times as many bits per coordinate in H². Exact ranking is quadratic in BigInt, so nouns are sampled (1,000 queries). Exactness moves the precision problem into integers; it does not remove it.
- The plane is measured, not proved. S2 decoded 500 words per depth to 28, with a margin of at most 8.72° seven levels down; L3 checks every noun.
- Pinned Unicode is a choice. It makes the engines agree by making them all behave like Python’s 15.1 tables, Final_Sigma included. Text using characters assigned after 15.1 becomes [UNK]. Every receipt records the runtime versions.
- The vocabulary is ours. V0 is trained here on glosses; BERT’s V1, pinned in Phase 1, is only L1’s second cell. Results on V0 do not transfer to published BERT numbers.
- The encoder may not help. Stage 2 starts only after the gate, needs BabyLM (from Hugging Face, reachable since the network was widened in Phase 1) and, at scale, a GPU, and is predicted small or null on general NLP.
- engram/1 and X(5, q) stay out of integrity. One is letter parity; the other has known collision attacks. SHA-256 and the records carry integrity.
Nothing. It describes a design and quotes spikes. Decisions are made by the claims in PREREGISTRATION.md, on the instances and rules fixed there, and recorded in the ledger.