Contents
Where this sits
The preregistration says what is tested and how it is decided. The Python reference is the code that decides the exact claims, and the browser core must reproduce it; Phase 2’s core does, line for line (Explainer 10). This page’s focus node is the reference.
The reference lives in reference/: the package reference/lexicon/, the runner run_claims.py, the pins in golden/, the traces in traces/ and the results in results/ (reference README). Every number on this page comes from results/claims.md (the same content as claims.json), its console log claims-console.txt, a commit message, PREREGISTRATION.md, or the pinned files’ own meta files and headers. The JSON gives exact metrics as rationals next to their floats; this page rounds the float. Where this page and those files differ, the files win.
supported means what the registered decision rule says, and nothing more. For an exact claim it means every case passed and every control failed. For L5 it means four bootstrap intervals lay above 0 on both instance sets. A prediction was written with each claim; it is not part of the rule, and a prediction can be wrong while its claim is supported. That happened once, on L2.
Timings belong to this container and change from machine to machine; claims.json marks L3’s millisecond timings “~ms” and gives every claim’s and arm’s seconds unmarked; this page adds “~” where it uses one.
- Python reference
- The code that decides the exact claims (the common rule “Authority”). It imports Hyperbolic Oracles’
hpstepand Engram Mind’s Eye’sengrammodules in place, unchanged. - Dry run
- The runner on data no claim uses: every seed moved up by 3000, the verb forest in place of the nouns, repository Markdown in place of the lemma types, and q = 13 only (Amendment 1, item 10). It decides nothing.
- Decisive run
- The one run on the registered instances that decides. Here:
python3 -B run_claims.py, on the code committed at 88e63f7. - Pin
- A file fixed by its SHA-256 and size. The reference refuses to load a pinned file whose hash differs.
- Trace
- A file of inputs and the reference’s outputs that the browser core must reproduce line for line. Traces use seeds 8000 + i, which no claim uses.
- Paired AP difference
- For each query, its average precision in one arm minus its average precision in another. L5 decides on the mean of these differences and its 95% percentile bootstrap interval (10,000 resamples, seed 7).
The four decisions at a glance
| Claim | What it says | Decision | Result | Controls that must fail |
|---|---|---|---|---|
| L2 | engram/1 cannot serve as a token id: at least 1% of WordNet’s lemma types share their key with another type | supported | 77,520 of 147,305 types (52.6%) share a key; the Python and Node key tables are identical | The SHA-256-prefix key gives 0 collisions, as required |
| L3 (a)–(e), (g) | Every noun synset has a distinct, invertible, certified address, with exact H³ and H² points that decode back | supported Python side | 0 failures in each part, on all 82,115 noun synsets | All four break as required: 11,978, 74,220, 67,989 and 19,796 failures |
| L5 | At d = 2 and 3 the exact hyperbolic tree reconstructs the noun hierarchy better than the same construction at curvature 0 | supported | All 8 registered intervals lie above 0; the smallest, H3 − F3* on the mammals, is 0.049 [0.042, 0.055] | The shuffled (S3) and content-hash (K3) arms score far below H3 on both sets |
| L7 | One tree, three readings: address, H³ point and X(5, q) vertex, for q = 13, 17, 29 | supported | (a), (b), (c), (e): 0 failures; (d): the smallest Ramanujan margin is 0.030120, at q = 29 | ι = 2, a 4-generator subset and the undivided Hurwitz product all fail |
Left open by Phase 1: L1 (byte identity in Python, Node and Chromium), L3(f) (Python against JavaScript) and L4(a, b), which Phase 2 decided with the browser core lexicon_core.js, all supported (Explainer 10). L8–L11 followed in Phase 3, all supported (Explainer 11). L6 and L4(c) followed in Phase 4, all supported, L6(c) against its registered prediction (Explainer 12). Their registration is summarised in Explainer 8.
How Phase 1 was ordered
Definitions first, then code, then two reviews and dry runs, then one decisive run on the code as committed. Seven commits on 2026-11-05 (times in UTC, from git) record the order.
- 29efe8a · 11:24 · Amendment 1, before any code. It fixed what the registration had left open: the normaliser NB step by step, the WordPiece loop and the id stream, the V0 “lex0” trainer, the token map A, ties and rank lists, the readings L2, L3, L5 and L7 need (the flat arms, S3, K3, the instance sets, the reported metrics, the intervals), and the dry-run and trace seeds. It was written before
reference/lexicon/existed, and no claim result was known. - d50a43f · 11:52 · The text track.
wordnet,unicode_tableswith the pinned Unicode 15.1 table,normalise(NB),wordpiecewith the V0 trainer, and the L1 loaders inl1. V0 was frozen by committing its file; V1 was pinned by hash. The text traces and L2’s Node half came with it. “No claim has been run.” - e51a866 · 12:02 · The geometry track and the runner.
address,h3tree,h2exact,flat,rankandlps, thenrun_claims.pyand its dry run. Its tests replay the spikes: S3’s verb-forest MAP 0.6309 with the same SHA-256, S2’s decodes and bit counts, S5’s girths, eigenvalues and controls. “No decisive run has been made.” - 8d845c7 · 12:24 · Fixes from the geometry review (chapter 4).
- 20c3320 · 12:39 · Fixes from the text review, and a fresh dry run on the fixed reference, all four claims end to end (results/dry/).
- 88e63f7 · 12:39 · Amendment 2, before any decisive run: a disclosure, an erratum, the readings fixed in the code, and the two reviews. “No claim result is known.”
- The decisive run · started 12:39:18. Once, on the code at 88e63f7, in 5 minutes of wall time (L2 9.3 s, L3 86.5 s, L5 152.1 s, L7 50.9 s, “~”).
- 6af2a83 · 12:44 · The results, as they came out:
claims.json,claims.md, the console log and L3(f)’s Python side. Every case is reported.
Why the definitions came first
The registration fixed the claims, but some things it named had no algorithm yet: how V0 is trained, how a vocabulary entry gets an address (map A), how tied candidates are listed. Others needed a reading before code could be written: what a lemma “type” is after normalisation, how the flat arms keep the trees’ directions, how S3’s permutations are drawn, which bootstrap computes the intervals. Writing all of this down before any module existed means none of it could be chosen after seeing how the code or the data behaved. Amendment 1 changed nothing registered; where a reading could be taken for a change, it gives the reason.
The reference then had to decide some smaller readings in code (an invalid-UTF-8 offset, the trivial eigenvalues, how distortion treats two synsets with one word). Each is marked READING in its code and listed in Amendment 2, which was committed before the decisive run.
Dry runs, then one decisive run
The registered dry run (Amendment 1, item 10) uses the same runner on data disjoint from the instances: seeds 4000 + i and 5000 + i, the verb forest with its 559 roots under a virtual root, the repository Markdown spike S6 used in place of the lemma types, and q = 13 only for L7. It ran after the geometry track and again after the fixes. Its outputs decide nothing, whatever labels they carry. Then run_claims.py ran once on the registered instances, and its output was committed as it came out.
| Draws in Phase 1 | Seeds |
|---|---|
Instances: the noun query sample Rng(1000).sample(82115, 1000); L3(f)’s 2,000 nodes; L7(b)’s random words | 1000 + i |
| Secondary draws: S3’s permutations; L7(e)’s random words | 2000 + i |
| Dry runs | 4000 + i, 5000 + i |
| Traces for the browser core (no claim uses them) | 8000 + i, 8100 + i, 8300 + i |
| Bootstrap intervals | seed 7, 10,000 resamples |
One label to note: the header of claims.json names its rules as “PREREGISTRATION.md with Amendment 1”. That is the runner’s fixed label. The run used the code at 88e63f7, which includes Amendment 2, and Amendment 2 changed no rule (Amendment 2: “Nothing registered is changed”).
What was built
Eleven modules, a runner, four pin scripts, two trace writers and a test suite. Exact stages work on integers and rationals only; floats appear only where a claim measures them.
The package reference/lexicon/
| Module | What it holds | Used by |
|---|---|---|
| wordnet.py | The reader of golden/wordnet_v1.cjs in Python: synsets, the spanning forest, the closure, the mammal sets, the lemma types, C0 and the glosses. It refuses the archive unless its SHA-256 and size are the pinned ones | L2, L3, L5, L7; L1(a) |
| unicode_tables.py | The pinned Unicode 15.1 table, the only source of Unicode facts for NB: categories, lowercase mappings, decompositions, combining classes and the two Final_Sigma sets | L1, L2 |
| normalise.py | NB, BERT’s BasicTokenizer on the pinned table, with byte spans, failing closed on code points unassigned in 15.1; N1, the registered fallback. It never calls str.lower, unicodedata or a regular-expression Unicode class | L1, L2 |
| wordpiece.py | Greedy longest-match-first WordPiece on code points, the LEB128 id stream, the V0 trainer, the reported tokenizer metrics | L1 |
| l1.py | L1’s instance loaders (a)–(d), the dry-run and trace strings. Loaders only: nothing here decides L1 | L1 (Phase 2) |
| address.py | The L3 rule and its two controls, the verb forest, certify, the bijective 59/64-bit id codec (D6), the prefix check of L3(d), map A, and the words of the S3 and K3 arms | L3, L5, L7 |
| h3tree.py | Exact H³ points (t = 3/4) as integer vectors over 7n, built once per distinct prefix; hpstep’s decode_exact as the authority, an integer decoder as a cross-check, and the float control | L3, L5 |
| h2exact.py | The exact H² tree of D3 (t = 11/13) as integer frames over 2·300n, with exact greedy decoding that counts ties; t = 3/4 as L3’s control 4 | L3, L5 |
| flat.py | The curvature-0 arms F3, F2 (unit edges) and F3*, F2* (edges (1/4)k), as exact integer vectors over one denominator per depth | L5 |
| rank.py | Exact integer ranking keys, pessimistic AP, MAP and mean rank as exact rationals, rank lists and their SHA-256, distortion, bits per node, and Hyperbolic Oracles’ bootstrap ci_mean replicated exactly | L5; L4 in Phase 2 |
| lps.py | X(5, q) for q = 13, 17, 29: the Cayley graph by breadth-first search, its structure, the exact girth, walk against reduction, injectivity, the spectrum, SHD-CCP’s Hurwitz product, the controls and the spread of a word set | L7 |
Scripts and tests
| File | What it does |
|---|---|
| run_claims.py | Runs L2, L3 (Python side), L5 and L7 and writes results/claims.json and .md; --dry runs the registered dry run into results/dry/. It runs every control, and an exact claim whose control passes is void |
| js_engram_keys.cjs | L2’s Node half: the engram/1 key of every type from Engram Mind’s Eye’s ttmpt_core_v1.js, loaded unchanged |
| traces_text.py, traces_geometry.py | Write the traces the browser core must reproduce; each has a --check that rebuilds them in memory and compares bytes |
| golden/make_unicode_v1.py, make_vocab_v0.py, make_vocab_v1.py, make_l1_instances_v1.py | Write the pins. Each has a --check that recomputes and compares; those that need cached data report “skipped” (exit 2), never “passed”, without it |
| tests/ | A pytest suite for every module, and bert_oracle.py: an independent NB written with Python’s own Unicode functions, which NB must match word for word under Python 3.13 |
The pins
| Pin | Value |
|---|---|
| Unicode 15.1 table | golden/unicode_15_1_v1.json: 142,624 bytes, SHA-256 30bed6fb…06712229, exported from CPython 3.13’s unicodedata 15.1.0, Unicode License v3. Before writing it, the script checks that the table alone reproduces str.lower and NFD on every code point |
| V0 “lex0” | golden/vocab_v0_lex0.txt: 8,192 entries, 55,648 bytes, SHA-256 df227056…9f9ca1ff. Trained on L1’s instance (a) (117,659 glosses, 1,711,206 words, 55,425 distinct) by Amendment 1’s algorithm: 5 specials, an alphabet of 64 code points in both forms (128 entries), then 8,059 merges, stopped at 8,192 entries. The alphabet is ASCII, so under V0 a word with a non-ASCII letter is [UNK] |
| V1 bert-base-uncased | vocab_v1.meta.json: revision 86b5e09, vocab.txt 231,508 bytes, SHA-256 07eced37…992038a3, 30,522 entries, Apache-2.0. The file sits in the cache, outside git; only its hash is committed. It is pinned, so L1’s second vocabulary cell is in force |
| L1’s instance lists | l1_instances_v1.meta.json: (a) 117,659, (b) 16,622, (c) 20,520, (d) 2,000 strings, each list pinned by its count and an order-sensitive SHA-256. Hashing is not using them: nothing was normalised or tokenized to make the pin |
SHD-CCP’s hurwitz.py | Imported read-only for L7(e) and refused unless its SHA-256 is cecb6dcc…f1b244e9 |
| WordNet 3.0, UD EWT, the stress set | Pinned in Phase 0 (Explainer 8) |
The traces for Phase 2
| File | What the browser core must reproduce |
|---|---|
| traces/normalise_v1.txt | NB on 88 hand-picked edge cases (Final_Sigma contexts, U+0130, Hangul, canonical ordering, CJK, controls, Co, Cn failing closed, invalid UTF-8, long words, the empty string) and 300 synthetic strings from Rng(8000 + i): input bytes, result, normalised text, and every word with its byte span |
| traces/wordpiece_v1.txt | WordPiece pieces with ids and byte spans on the 381 valid cases, under V0 and under V1, and each vocabulary’s id-stream length and SHA-256 |
| traces/address_v1.txt | The letter rule and its two controls on 200 cases from Rng(8300 + i), and the 13,767 words of the verb forest with their SHA-256 |
| traces/points_v1.txt | 300 words from Rng(8000 + i): each word’s D6 id and its exact points in H³, H², H² at t = 3/4 (with its greedy decode), F3, F3*, F2 and F2*, in lowest terms |
| traces/rank_v1.txt | 20 verb-forest queries from Rng(8100 + i): rank-list SHA-256, exact graph-edge and closure APs and neighbour ranks, in H³ and H² |
| results/l3f-python.txt | L3(f)’s Python side: the 2,000 sampled nouns with their words and points, and the SHA-256 of the canonical point list of all 82,115 |
Two families of modules are imported in place and never modified: Hyperbolic Oracles’ hpstep (prng, problems, decode3d) and Engram Mind’s Eye’s engram (ttmpt, address). Amendment 1 (item 6) and Amendment 2 (item 3) make the first the deciding implementation of the H³ tree: L3(e) in H³ is decided by hpstep’s decode_exact, not by this package’s faster integer decoder (placement in Explainer 3).
Checked twice before it counted
Before the decisive run, each track had an adversarial review: four reviewers, and two skeptics for every finding. Amendment 2 records that they worked by independent reimplementation, on unregistered data. Amendment 3 corrects that for the text track: its checks compared the Python NB and WordPiece with Python oracles over L1’s instances (a)–(c), and retrained V0 on (a) as registered. That is not L1’s metric, which compares runtimes, and it decided nothing.
The text-track review
Rebuilt independently: a naive V0 trainer rebuilt V0 byte for byte. An independent NB oracle agreed on every L1 instance and on 6.7 million code-point contexts. WordPiece agreed on every instance, for V0 and V1. No mismatch. (These L1 instances were not a decision: L1 compares the reference with Node and Chromium, which Phase 2 did; Explainer 10.)
Confirmed and fixed (20c3320): traces_text.py --check skipped the whole check when V1 was not cached; it now always compares the normaliser trace and the V0 lines. The guard against platform Unicode now covers every Unicode-dependent str method, called or referenced, in normalise, unicode_tables and wordpiece. L1’s four instance lists were pinned. make_unicode_v1.py --check compares the whole meta. bert_oracle.py states which control-character rule it follows.
The geometry-track review
Rebuilt independently: trees in Fractions, the flat arms, pessimistic ranking, the id codec and L7. They agreed without a mismatch, and the review found no code defect.
Confirmed and fixed (8d845c7): the integer decoder’s test used only tree points; it now runs on real off-tree points with forced ties. The runner’s L7(e) control was mislabelled: the registered control (doubled-coordinate products not divided by 2L) is now a module function with its own test, and the runner uses it; the product without SHD-CCP’s final halving stays as a reported second control. Map A reads NB punctuation from the pinned table, not from the interpreter. The H² denominator test covers n = 1–6, as its docstring says.
Amendment 2 sums up what the reviews confirmed as gaps in tests and pins; in every rebuild, the independent code agreed with the reference. All fixes were committed, and the dry run was repeated on the fixed code, before Amendment 2 and before the decisive run.
Amendment 2: a disclosure and an erratum
While the geometry modules were being written, a builder’s timing script ran L3’s certify and the prefix check of L3(d) over all 82,115 noun words, to measure their cost. In Amendment 2’s words: “Its outcome was neither reported nor looked at, and no code was changed after it.” Both checks are exact, deterministic and all-or-nothing, with nothing to tune, and the decisive run recomputed them. It is recorded under the common rule “Reporting”.
Amendment 1 said in a parenthesis that “BERT drops every C category”. That is wrong for google-research/bert, whose _is_control drops only Cc and Cf; it is Hugging Face transformers’ copy of the BasicTokenizer that drops every C category. The rule in force does not change: NB drops Cc, Cf and Co, and keeps Cn so that a token holding an unassigned code point fails closed. It is the stated rule, and no L1 instance contains a Co code point. Explainer 3’s Phase 0 text, “Cc, Cf”, described google’s BERT; it now states the rule in force, as Amendment 2 said it would.
Amendment 2 also lists the readings fixed in the code (for instance: L3’s truncation control gives every child one letter, the digit min(k, 4); a query without graph-edge neighbours is left out of the paired differences and counted, and there were none among the nouns or mammals; L7’s trivial eigenvalues are the top of the spectrum and, for a bipartite graph, the bottom). Nothing registered was changed.
L2 · engram/1 is not a token id
engram/1 is Engram Mind’s Eye’s 64-bit key for a text. D4 keeps it as a compatibility checksum, never as an input. L2 tests the reason: on WordNet’s lemmas, too many types share a key. supported
| Registered | As run |
|---|---|
| Instances | Every distinct lemma of the four WordNet index files, “_” read as a space, through NB, deduplicated: 147,306 strings before NB, 147,305 types after (two strings became one type; none failed closed, none was empty) |
| Metric | Collision share = types in a key class of size ≥ 2, over all types |
| Control | A 64-bit SHA-256-prefix key on the same types must give 0 collisions; a Python/Node table mismatch voids the test |
| Decision | Supported if the share is ≥ 0.01 and the control gives 0 collisions |
| Result | Value |
|---|---|
| Collision share (exact 912/1733) | 77,520 / 147,305 = 52.6% |
| Control: SHA-256-prefix key collisions | 0 |
| Python and Node key tables (SHA-256 of the table) | identical, fb871ccd…1c1f1379 |
| Key classes · of size ≥ 2 | 92,978 · 23,193 |
| Largest class = the zero key 0000000000000000 | 371 types (0.25%) |
| All-digit types, all on the zero key | 131 |
| Anagram classes (same letters A–Z, other characters ignored) · types in them | 6,666 · 15,025 |
| Reported, not decided: V0’s 8,192 entries sharing a key (exact 2137/4096) | 52.2%, in 1,345 classes |
The share is 52.6%, far above the 1% the claim needs, and the control gives no collision, so L2 is supported. In plain terms, more than half of WordNet’s lemma types cannot be told apart from some other type by their engram/1 key.
Why so many: the key keeps only parity
crystallize in ttmpt_core_v1.js upper-cases the text, skips every character that is not A–Z, and XORs a fixed 64-cell pattern for each remaining letter into an accumulator. So letter order does not matter, every non-letter is ignored, and a letter that occurs twice cancels itself. The key depends only on which letters occur an odd number of times.
- The zero key holds every type in which each letter occurs an even number of times, and every type without letters. Its first entries, sorted: “. 22”, “0”, “1”, “10”, “100”, “1000”, … (NB splits punctuation into words of its own, so the lemma .22 becomes the type “. 22”). Any type like “noon”, with every letter twice, lands there too.
- Anagram classes share a key because they have the same letters. Two from
claims.json: “' hood” and “hood”, which differ only in an apostrophe; and a class of 14 that runs from “. 22 caliber”, “. 22 calibre” and “. 38 caliber” to “caliber” and “calibre”: digits and punctuation do not count, and caliber and calibre use the same letters. - Parity classes go much further. The key cannot tell “tot” from “o”: the two t’s cancel. Any two types with the same set of odd-count letters collide, whatever their other letters.
L2’s prediction read: “Supported, with a share between 2% and 10%: anagram classes (dog/god), words in which every letter appears an even number of times and numerals (all on the zero key), and types that differ only in non-letters.” The share is 52.6%, five times the top of that band.
The prediction named the right mechanisms but not the main one. The anagram classes, which already include the numerals and the types that differ only in non-letters, hold 15,025 types: 10.2%, about the band’s top. The other 62,495 types in shared classes (77,520 − 15,025) share a key with types made of different letters, because the key keeps only the parity of each letter’s count. The prediction counted anagrams and the zero key, and missed that any two types with the same set of odd-count letters share a key. The decision does not depend on the prediction: the rule asks for at least 1%, and the miss is reported as a miss.
What L2 does not say: engram/1 keeps its role as a checksum and as Engram Mind’s Eye’s compatibility key (D4). The Lexicon’s token ids come from the vocabulary, and its addresses from the L3 rule (ids in Explainer 3).
L3 · An exact address for every noun
Under the L3 rule every WordNet noun synset gets a reduced word in the norm-5 tree, and every word an exact point in H³ and in H². All 82,115 pass every part decided in Phase 1. supported (Python side: (a)–(e) and (g))
The rule (Explainer 3): the spanning parent is the first @ or @i pointer; 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 base-5 digits of k.
| Part | What is checked, on every noun synset | Failures |
|---|---|---|
| (a) | Its word is distinct from every other synset’s | 0 |
| (b) | The word decodes back to the synset (inverse table lookup) | 0 |
| (c) | certifyWord: the integer quaternion has norm exactly 5len, right division returns the word, and the word is reduced (hpstep’s word_quaternion, right_divide, is_reduced) | 0 |
| (d) | u is a spanning-tree ancestor of v exactly when word(u) is a proper prefix of word(v), checked by walking every word through a trie of all words | 0 |
| (e) | The exact point lies on the sheet and decodes exactly back to the word: in H³ by hpstep’s decode_exact (the integer decoder agrees on 82,115/82,115), in H² at t = 11/13 with 0 decoding ties | 0 |
| (f) | Python and JavaScript give the same words and exact points | 0, in Phase 2 |
| (g) | The D6 id code round-trips every word it covers: id59 covers 74,630 words (≤ 25 letters), id64 78,550 (≤ 27); longer words are reported as not covered, not as failures | 0 |
The four controls broke, as they had to
| Control | Must | Measured |
|---|---|---|
| 1 · Zero-letter variant: a single child gets no letters | break injectivity | 11,978 nodes share a word |
| 2 · Truncation variant: children past the fifth folded into the fifth | break injectivity | 74,220 nodes share a word |
| 3 · Float placement with float decoding | fail on a word longer than 12 letters | 67,989 of 71,454 words fail |
| 4 · The H² tree at t = 3/4 | fail exact decoding | 19,796 of 82,115 words fail |
The controls show that the test can see failure. Without the max(1, ·) or with fixed branching, addresses collide. Floats do not survive WordNet’s depth: 95% of the words longer than 12 letters fail to decode, as spike S1 led the registration to expect. And the H³ boost does not work in the plane, as spike S2 found on synthetic words (S1, S2).
Word lengths, id coverage and bits
| Reported | Value |
|---|---|
| Longest word · mean length (exact 301,680/16,423) | 36 letters · 18.37 |
| Words of ≤ 25 letters (id59, kernel 0xA’s tile) | 74,630 = 90.88% |
| Words of ≤ 27 letters (id64) | 78,550 = 95.66% |
| Words of more than 12 letters | 71,454 |
| Nodes with more than 5 · more than 25 children · most children | 3,291 · 396 · 659 |
| Largest numerator / denominator per coordinate, H³ | 184 / 102 bits |
| Largest numerator / denominator per coordinate, H² | 252 / 142 bits |
The registration said that a larger minority of noun words than of verb words may pass 25 or 27 letters, and that the share would be reported. It is 9.1% beyond 25 letters (7,485 words) and 4.3% beyond 27 (3,565), against 0.04% and none for the verbs in spike S3. A word longer than 25 letters needs a continuation tile in SHD-CCP kernel 0xA (the proposal). Points cost more than spike S1’s depth-28 budget (139/79 bits on random words), because noun words reach 36 letters, and 736 alone takes 102 bits.
Timings (“~”, this container): the exact points of all nouns took 0.33 s in H³ and 0.45 s in H² with this package’s prefix-sharing builders; hpstep’s point_exact took 1.04 ms per point; hpstep’s exact decoding of all 82,115 words took 50.6 s, and the H² decoding 2.5 s. The whole of L3 took 86.5 s.
L3(f) asks whether Python and JavaScript give the same words and points. Phase 1 wrote the Python side: the canonical point list of all 82,115 nouns (one line per noun and tree, every coordinate in lowest terms) has SHA-256 eb22bf00689ec86da05f0f4ba6338abc0ba0a1549ada844a134cbce154a3ebc6, and the 2,000 sampled nodes, node i = Rng(1000 + i).below(82115), are written line by line in results/l3f-python.txt. This package’s H³ points equal hpstep’s point_exact on all 2,000. The browser core had to give the same hash and the same lines. In Phase 2 it did: Node’s canonical point list has this SHA-256 and all 2,000 lines are equal, so L3(f), and with it L3, is supported (Explainer 10).
L5 · Hyperbolic against flat
Does the training-free exact tree reconstruct the noun hierarchy better in hyperbolic space than the same construction at curvature 0? At d = 2 and 3, on both instance sets, by the registered rule: yes. supported
The arms and the rule
- H3, H2: the exact trees of L3, ranked by the exact Lorentz product.
- F3, F2: the same words, directions and step rule in R³ and R² with unit edges, ranked by exact squared distance. F3*, F2*: a flat fractal tree, the same directions with edge length (1/4)k into a word of k + 1 letters.
- S3 (control): H3 with words shuffled among synsets of equal word length, 20 permutations on the mammals and 5 on the nouns. K3 (control): content-hash words,
engram_core.encodeof the first 8 bytes of SHA-256 of the first lemma, 28 letters each. - Instances: the 1,176 synsets of the mammal spanning subtree, each a query against the other 1,175; and the 1,000-query noun sample, each against the other 82,114.
- Metric: graph-edge MAP (the neighbours are the spanning parent and the children), pessimistic ties. Closure MAP, mean rank, distortion and bits are reported. The effect is the mean paired AP difference with its 95% bootstrap interval.
- Decision: supported if the intervals of H3 − F3, H3 − F3*, H2 − F2 and H2 − F2* all lie above 0 on both sets; refuted if any lies entirely at or below 0; inconclusive otherwise. Controls: the intervals of H3 − S3 and H3 − K3 must lie above 0 on both sets, or the metric cannot see hierarchy and the test is void.
Every arm, both sets
MAP and distortion are rounded to 4 decimals; mean rank pools every (query, neighbour) pair. For S3 the graph-edge MAP is the mean over permutations and the other columns give the range over permutations. Distortion is registered for H3, H2, F3 and F2 only, and bits for the six construction arms.
The mammals: 1,176 nodes, 1,176 queries
| Arm | What it is | Graph-edge MAP | Closure MAP | Mean rank, graph-edge | Mean rank, closure | Distortion | Bits per node, mean / max |
|---|---|---|---|---|---|---|---|
| H3 | exact H³ tree (t = 3/4) | 0.6907 | 0.3059 | 2.91 | 66.89 | 0.1822 | 644.3 / 811 |
| H2 | exact H² tree (t = 11/13) | 0.7187 | 0.3063 | 2.74 | 68.49 | 0.1199 | 652.7 / 815 |
| F3 | flat R³, unit edges | 0.1099 | 0.0600 | 36.59 | 194.54 | 0.5938 | 8.8 / 12 |
| F2 | flat R², unit edges | 0.0422 | 0.0346 | 70.91 | 212.55 | 0.6052 | 107.0 / 167 |
| F3* | flat fractal R³, edges (1/4)k | 0.6420 | 0.2583 | 28.88 | 219.45 | — | 205.0 / 262 |
| F2* | flat fractal R², edges (1/4)k | 0.4081 | 0.1984 | 37.91 | 226.48 | — | 261.0 / 348 |
| S3 (20 perm.) | H3, words shuffled within each length | 0.0186 | 0.0246– 0.0298 | 441.68– 479.33 | 329.89– 368.43 | — | — |
| K3 | H3, content-hash words (28 letters) | 0.0068 | 0.0142 | 588.31 | 476.89 | — | — |
The nouns: 82,115 nodes, 1,000 queries
| Arm | What it is | Graph-edge MAP | Closure MAP | Mean rank, graph-edge | Mean rank, closure | Distortion | Bits per node, mean / max |
|---|---|---|---|---|---|---|---|
| H3 | exact H³ tree (t = 3/4) | 0.5679 | 0.1577 | 5.94 | 1,693.08 | 0.1955 | 405.3 / 811 |
| H2 | exact H² tree (t = 11/13) | 0.5901 | 0.1567 | 6.58 | 1,619.66 | 0.1301 | 426.1 / 887 |
| F3 | flat R³, unit edges | 0.0069 | 0.0023 | 1,870.43 | 14,152.42 | 0.7497 | 7.3 / 13 |
| F2 | flat R², unit edges | 0.0019 | 0.0010 | 3,609.77 | 18,351.35 | 0.7281 | 41.0 / 167 |
| F3* | flat fractal R³, edges (1/4)k | 0.5001 | 0.1348 | 79.44 | 11,304.14 | — | 125.0 / 262 |
| F2* | flat fractal R², edges (1/4)k | 0.3189 | 0.1074 | 104.32 | 14,817.30 | — | 135.6 / 348 |
| S3 (5 perm.) | H3, words shuffled within each length | 0.0005 | 0.0013– 0.0015 | 27,353.37– 30,091.75 | 20,509.00– 22,811.61 | — | — |
| K3 | H3, content-hash words (28 letters) | 0.0001 | 0.0003 | 41,535.42 | 40,482.33 | — | — |
The intervals
| Comparison | Role | Mammals: mean [95% CI] | Nouns: mean [95% CI] |
|---|---|---|---|
| H3 − F3 | registered comparison | 0.581 [0.562, 0.599] | 0.561 [0.538, 0.584] |
| H3 − F3* | registered comparison | 0.049 [0.042, 0.055] | 0.068 [0.062, 0.074] |
| H2 − F2 | registered comparison | 0.677 [0.659, 0.694] | 0.588 [0.565, 0.611] |
| H2 − F2* | registered comparison | 0.311 [0.297, 0.325] | 0.271 [0.257, 0.286] |
| H3 − S3 | control: must lie above 0 | 0.672 [0.653, 0.691] | 0.567 [0.544, 0.590] |
| H3 − K3 | control: must lie above 0 | 0.684 [0.664, 0.704] | 0.568 [0.544, 0.591] |
All eight registered intervals lie above 0, so L5 is supported. Both controls score far below H3 on both sets, so the metric does see the hierarchy and the test is not void: words shuffled within each length, or hashed from the lemma, keep almost nothing of it.
What it means, and what it does not
- It means that, given the same words, directions and step rule, the hyperbolic tree ranks each synset’s parent and children ahead of the other synsets better than either flat construction does, at d = 2 and d = 3, on the mammals and on the nouns, by an amount the bootstrap resolves.
- F3* comes close. The flat fractal tree, whose edges shrink by 1/4 per letter, reaches 0.6420 against H3’s 0.6907 on the mammals and 0.5001 against 0.5679 on the nouns. The margins, 0.049 and 0.068, are small, but their intervals ([0.042, 0.055] and [0.062, 0.074]) lie clearly above 0. Its graph-edge mean rank is ten to thirteen times H3’s (28.88 against 2.91; 79.44 against 5.94), which suggests that the neighbours it does not rank near the top fall far down the list.
- H2 slightly beats H3 on graph-edge MAP (0.7187 against 0.6907 on the mammals, 0.5901 against 0.5679 on the nouns), with lower distortion, while its graph-edge mean rank is lower on the mammals and higher on the nouns. No comparison between H2 and H3 was registered and no interval was computed for it, so this is an observation, not a finding.
- Closure MAP is much lower: 0.1577 (H3) and 0.1567 (H2) on the nouns, about 0.31 on the mammals. The closure protocol counts every ancestor and every descendant as a neighbour, and a distance-based tree is likely to put distant ones farther away than nearby siblings and cousins (an explanation, not measured here). The closure numbers are reported and decide nothing; they are never compared with graph-edge numbers (the two protocols in Explainer 7).
- Sala et al.’s 0.989 is not reached. The registration reports the nouns’ graph-edge MAP against Sala et al.’s combinatorial 0.989 in 2 dimensions at about 500 bits, and predicted that this rule falls short. It does: 0.5901 in H2 and 0.5679 in H3, on the 1,000-query sample. The expected cause is the virtual letters: under a node with more than 5 children, siblings that share a virtual prefix sit as close as the parent or closer (spike S3 on verbs: 0.9974 on one-letter edges, 0.32–0.43 on longer ones; Explainer 8). This comparison is not part of L5’s decision (baselines in Explainer 5).
The Common rules ask for fractional-tie values (each query’s AP averaged over every order inside each exact tie class) beside the pessimistic ones, never used to decide, and Phase 1 reported only the pessimistic ones: an omission Amendment 10 item 17 recorded. Phase 4 computed them for every arm above, with Phase 1’s own code and draws, in results/fractional-ties.md; every pessimistic value recomputed there equals the published one, and L5 stays decided as recorded. Where the exact tree ties, the difference is large: H3’s graph-edge MAP is 0.6907 pessimistic and 0.7701 fractional on the mammals (488 of the 1,176 queries depend on the order inside a tie class), and 0.5679 and 0.6377 on the nouns. H2 barely moves (0.7187 and 0.7189 on the mammals), and F3* not at all.
L7 · One tree, three readings
The same reduced word is an address, an exact H³ point and a vertex of SHD-CCP RFC 03’s LPS Ramanujan graph X(5, q). For q = 13, 17 and 29 every exact part holds and the spectra are Ramanujan. supported
- (a) The LPS map φq sends 1 ± 2i, 1 ± 2j, 1 ± 2k to 2×2 matrices mod q; the projective Cayley graph has q(q² − 1) vertices and is bipartite when (5|q) = −1, q(q² − 1)/2 when (5|q) = 1, and is always 6-regular, connected and inverse-closed.
- (b) Reducing a word’s quaternion mod q gives the vertex reached by walking the word, on 11,182 words per q: 10,000 random words from
Rng(1000 + i)and the L3 words of the 1,182 mammal closure-set synsets. - (c) Distinct reduced words of length ≤ r = ⌊(g − 1)/2⌋ reach distinct vertices, every such word checked.
- (d) Every eigenvalue other than ±6 has |λ| ≤ 2√5 − 10−9 (float64
eigvalshon the dense adjacency). - (e) Our word quaternion equals SHD-CCP’s
HurwitzQuaternionproduct in doubled coordinates, halved, on 2,182 words: 1,000 fromRng(2000 + i)and the 1,182 mammal addresses.
| q | ι | (5|q) | Vertices | Bipartite | Diameter | Girth g | r | Words ≤ r → vertices | (b) failures | Largest nontrivial |λ| | Margin to 2√5 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 13 | 5 | −1 | 2,184 = q(q²−1) | yes | 7 | 8 | 3 | 187 → 187 | 0 of 11,182 | 4.249721 | 0.222415 |
| 17 | 4 | −1 | 4,896 = q(q²−1) | yes | 9 | 8 | 3 | 187 → 187 | 0 of 11,182 | 4.308919 | 0.163217 |
| 29 | 12 | +1 | 12,180 = q(q²−1)/2 | no | 8 | 9 | 4 | 937 → 937 | 0 of 11,182 | 4.442016 | 0.030120 |
Every graph is 6-regular, connected and inverse-closed, with the expected vertex count. The words of length ≤ r include the empty word. The trivial eigenvalues are +6 once at every q and −6 once at q = 13 and 17, the bipartite graphs; at q = 29 the bottom of the spectrum is −4.4107. L7(e) holds on all 2,182 words (SHD-CCP’s hurwitz.py, SHA-256 cecb6dcc…f1b244e9, imported read-only). The smallest margin, 0.030120 at q = 29, is far above the registered 10−9. The dense eigenvalue computation took 0.25 s, 2.4 s and 43.9 s on this container (“~”). The girths, r and largest nontrivial |λ| match what spike S5 measured on synthetic words (Explainer 8).
The controls
| Control | Must | q = 13 | q = 17 | q = 29 |
|---|---|---|---|---|
| φ with ι = 2 | break (b) on a word | 10,867 of 11,182 | 10,877 of 11,182 | 10,879 of 11,182 |
| A 4-generator subset | fail 6-regularity | not 6-regular | not 6-regular | not 6-regular |
For (e), the registered control multiplies the doubled-coordinate generators as plain integer quaternions and compares without dividing by 2L: it differs on 2,182 of 2,182 words. SHD-CCP’s product without its final halving, reported as a second control, differs on all 2,182 too.
How the noun addresses spread over the vertices
| q | Vertices hit by the 82,115 noun addresses | Largest load | An even spread |
|---|---|---|---|
| 13 | 2,184 of 2,184 | 59 | 37.6 per vertex |
| 17 | 4,896 of 4,896 | 33 | 16.8 per vertex |
| 29 | 12,167 of 12,180 | 18 | 6.7 per vertex |
The vertex of a word is a cheap, well-spread key: every vertex is hit at q = 13 and 17, and all but 13 at q = 29, with the largest load at most twice the even share at q = 13 and 17 and under three times at q = 29. But words longer than r share vertices, and must, since 82,115 words land on at most 12,180 of them. LPS Cayley hashes also have known collision attacks. So the registration fixes the reduction as a shard key, never as an integrity check; integrity comes from SHA-256 and RFC 6962 manifests (Explainer 2, the RFC 03 proposal).
What this does not show
Three claims, and L3 on its Python side, are decided in Python, on WordNet. That is narrower than it may sound.
- Nothing about language models. No claim here is about an encoder, pretraining or a downstream task. Stage-2 to Stage-4 claims are registered by amendment before any code for them (Explainer 7).
- Only the Python side. The common rule says the browser core must reproduce the reference’s traces line for line before a claim decided in the reference is shown as holding in the browser. Byte identity across Python, Node and Chromium (L1), the same words and points in JavaScript (L3(f)) and identical exact rankings across engines (L4(a)) compare the reference with
lexicon_core.js; L4(b), the float64 test on noun queries, was decided with them in Phase 2 (Explainer 10). - One sense per synset, one parent per node. An address is one synset in the spanning tree, without context. The 2,213 nouns with several parents keep only their first
@or@iparent in the address (closure MAP still counts every ancestor).##pieces get orthographic addresses (map A). - L5 is against the same construction at curvature 0. It is not a comparison with learned embeddings (L6, Phase 4) or with published systems, it is decided on graph-edge MAP, and on the nouns it uses a 1,000-query sample.
- L7(d) is numerical. The spectra are float64 eigenvalues with a margin of at least 10−9, which the smallest margin, 0.030120, clears by far; the exact parts (a), (b), (c) and (e) are checked case by case.
- L2 is about token ids only. engram/1 keeps its role as a checksum. And V0’s alphabet is the 64 ASCII code points of the glosses, so under V0 a word with a non-ASCII letter is
[UNK]: a limit of V0’s coverage, which does not bear on L1’s byte identity. - Timings belong to this container. Every “~” number would move on another machine; no claim in Phase 1 is decided on time.
Phase 2, planned and done
The plan at the end of Phase 1: the browser core, lexicon_core.js, on the shared cores unchanged, would reproduce the reference’s traces line for line, and then decide L1, L3(f) and L4(a, b). Phase 2 has done both (Explainer 10).
- Reproduce the traces. The normaliser on 388 cases, WordPiece under V0 and V1 with both id-stream SHA-256s, the letter rule and the verb forest, 300 words’ exact points in every arm, and 20 queries’ rank lists and APs (chapter 3), as the common rule “Authority” requires.
- L1 in Node and in headless Chromium: identical normalised bytes, tokens, ids, byte offsets and id-stream SHA-256 against the reference on all four instance lists (117,659, 16,622, 20,520 and 2,000 strings), for V0 and, now that it is pinned, for V1. Its controls: the platform’s own normaliser, shortest-match WordPiece and accent stripping off must each differ (Explainer 3, Stage 0 in Explainer 7).
- L3(f): the same canonical point list SHA-256, eb22bf00…54a3ebc6, and the same 2,000 sampled lines.
- L4(a): identical rank lists, and MAP and mean rank equal as exact rationals, in H³ and H², on the mammals and noun queries 0–199. L4(b): a float64 inversion of an exactly strictly ordered pair on at least one of the 1,000 noun queries. L4’s controls: float32 ranking must invert, and an acosh evaluator with index tie-breaking must differ where exact ties exist.
Parity first: tests/parity-lexicon.cjs passed 18,667 of 18,667 lines in Node, 18,578 of them reproducing the five traces of chapter 3. Then one decisive run, on the code committed at a1fe9a8. L1 is supported in all four cells (V0 and V1, each in Node and in Chromium): 0 of 156,801 instances differ, and every id-stream SHA-256 is equal. L3(f) is supported: the canonical point list has the SHA-256 above, and all 2,000 sampled lines are equal. L4(a) is supported: every rank list and every exact MAP and mean rank is equal in Python and Node. L4(b) is supported: float64 inverts an exactly ordered pair in 997 of the 1,000 noun queries. Every control failed as required. The whole account is in Explainer 10.
Then Phase 3 decided L8–L11 (shards, manifests, the hardened importer, verification time), all supported (Explainer 11), and Phase 4 decided L6 and L4(c) (learned embeddings), all supported, L6(c) against its registered prediction (Explainer 12; the roadmap). The network is wider than in Phase 0: huggingface.co is reachable, which is how V1 was pinned, while osf.io file downloads still are not; BabyLM is also published on Hugging Face.