Hyperbolic Lexicon · Explainer 10 · Phase 2

The Browser Core and Its Parity

Phase 2 built the browser core, lexicon_core.js, on the shared cores unchanged, and made it reproduce every line of the Python reference’s traces before anything was decided. How the engines are run and compared was fixed before any code; the disclosures, readings and review were recorded before any decisive run. Then one run decided L1, L3(f), L4(a) and L4(b): all four are supported under their registered rules, and every control showed its weakness. On this page you can rerun the trace parity in your own browser and put your own text through the front end.

The four decisions Run the parity Try the front end What this does not show Claims ledger
decided: L1, L3(f), L4(a, b) · all supported L1: 0 of 156,801 instances differ, in 4 cells parity before the run: 18,667/18,667 lines float64 inverts on 997 of 1,000 noun queries
Contents
  1. Where this sits
  2. How Phase 2 was ordered
  3. What lexicon_core.js holds
  4. The parity, in your browser
  5. A live front end
  6. L1 · One front end, three engines
  7. L3(f) · The same points in JavaScript
  8. L4(a) · The same exact rankings
  9. L4(b) · Float64 is not certifiable
  10. What this does not show
  11. Phase 3, planned and done
01

Where this sits

The Python reference decides the exact claims. The browser core must reproduce it line for line before a claim decided there is shown as holding in a browser (the common rule “Authority”). Phase 2 built that core and decided the claims that compare engines. This page’s focus node is the core.

The core is one file, lexicon_core.js, with two data wrappers in data/. Around it sit the parity runner tests/parity-lexicon.cjs, the page Chromium opens, tests/l1-harness.html, the reference’s half of the run, run_claims.py --phase2 (with lexicon/phase2.py), and the Node and Chromium runner run_claims_js.cjs. Every number on this page comes from results/claims-phase2.json (the engines’ side and the decisions; summarised in claims-phase2.md), results/phase2-python.json (the reference’s side, L4(b), the reported metrics and the per-query lists; summarised in phase2-python.md), the console log phase2-console.txt, a commit message, PREREGISTRATION.md, spike S6’s output (s6_unicode_wordpiece_output.txt), results/claims.json (Phase 1), the files themselves (sizes and line counts), the core’s own source, or a rerun of tests/parity-lexicon.cjs or of the lab in chapter 4 (the per-file line counts, the 18,578/89 split and the lab’s expected counts, which the results record only as 18,667 lines in all). Where this page and those files differ, the files win.

How to read this page

supported means what the registered decision rule says, and nothing more. For L1, L3(f) and L4(a), all exact, it means every case passed and every control showed its weakness on at least one case. For L4(b) it means at least one float64 inversion occurred, and it is decided by the reference: Node’s counts are reported beside it. Chromium’s run of L4(a) on the mammals is reported, not decisive. A prediction was written with each claim; it is not part of the rule.

Timings belong to this container and change from machine to machine; this page adds “~” where it uses one.

Browser core
lexicon_core.js: one UMD module that runs the front end and the geometry in a page or in Node, a line-by-line twin of the reference’s modules, on Hyperbolic Oracles’ and the orbital core’s JavaScript loaded unchanged.
Trace parity
Regenerating each line of the reference’s trace files (reference/traces/, seeds 8000 + i, which no claim uses) from its inputs or seeds and comparing it with the reference’s line, character for character. Amendment 4 item 8 requires all of it in Node before any decisive run.
Record
L1’s unit of comparison (Amendment 4 item 2): an instance’s normalised text as UTF-8 hex, a tab, then its pieces separated by spaces, each id,start,end,hex. An instance differs in a runtime when its record’s SHA-256 differs from Python’s.
Id stream
Per instance set and vocabulary, over the instances in order: LEB128 of the number of ids, then LEB128 of each id (Amendment 1 item 2). L1 compares its SHA-256.
Cell
One vocabulary in one runtime: V0 in Node, V0 in Chromium, V1 in Node, V1 in Chromium. L1 is decided per cell.
Inversion
For L4(b): two candidates adjacent in the exact order whose exact keys strictly increase while their float64 keys strictly decrease (chapter 9).
Dry run
The runners on data no claim uses: every seed moved up by 3000, the verb forest in place of the nouns, Rng(4000 + i) strings and repository Markdown in place of L1’s instances (Amendment 4 item 7). It decides nothing.
Decisive run
The one run on the registered instances that decides: python3 -B run_claims.py --phase2, then node run_claims_js.cjs, on the code committed at a1fe9a8.

The four decisions at a glance

ClaimWhat it saysDecisionResultControls that must show their weakness
L1The front end gives identical normalised bytes, token strings, ids, byte offsets and id-stream SHA-256 in Python, Node and Chromium, for each pinned vocabularysupported
all 4 cells
In each cell (V0 and V1, in Node and in Chromium), 0 of 156,801 instances differ and every id stream is equalThe platform’s own normaliser differs on 725 of 20,520 stress cases in each runtime; shortest-match WordPiece and NB without accent stripping differ too
L3(f)Python and JavaScript give the same words and exact points for every noun synsetsupportedNode’s canonical point list of all 82,115 nouns has Python’s SHA-256, and 2,000 of 2,000 sampled lines are equalPhase 1’s four L3 controls, all broken as required
L4(a)Exact ranking gives identical rank lists, and MAP and mean rank equal as exact rationals, in Python and JS, in H³ and H²supported0 differing rank lists over the 1,176 mammal queries and noun queries 0–199, in both trees, and every exact value equalControl 2 (below) applies to both parts, and showed its weakness
L4(b)Float64 ranking of the same exact points is not certifiable: at least one noun query inverts an exactly strictly ordered adjacent pairsupported
by the reference
997 of 1,000 noun queries invert in H³ or H² (H³ 990, H² 993); Node’s counts are the same, query by queryFloat32 inverts on 1,137 of 1,176 mammal queries; the acosh evaluator’s AP differs on 487 of 488 tied queries

With L3(f), L3 is decided on all seven parts: (a)–(e) and (g) were supported on the Python side in Phase 1 (Explainer 9), and (f) holds now, so under its all-or-nothing rule L3 is supported. Left open by Phase 2: L8–L11, which Phase 3 decided, all supported (chapter 11; 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.

02

How Phase 2 was ordered

How to compare first, then code, a review and a dry run, then an amendment, then one decisive run on the code as committed. Seven commits on 2026-11-05 (times in UTC, from git) record the order.

  1. cda6d9a · 17:31 · Amendment 4, before any code for its claims. Written before lexicon_core.js or any Phase 2 runner existed, with no result of L1, L3(f) or L4 known. It fixed the three engines, L1’s record and comparison, its controls and reported metrics, how Node builds L3(f)’s words and points, L4(a)’s rank-list comparison in H³ and H², L4(b)’s float64 key and its two controls, the dry runs, and the trace parity required before anything else. Nothing registered was changed.
  2. 09e282d · 19:29 · The core, its parity and the runners, after their dry run. The core and its data wrappers; the parity runner at 18,667 of 18,667 lines in Node (the commit message adds “also in Chromium”; no committed file records that count); run_claims.py --phase2 and run_claims_js.cjs; the registered dry run, every cell run (results/dry/, started 19:18:27); and an adversarial review whose confirmed findings were fixed. “No decisive run has been made.”
  3. a1fe9a8 · 19:29 · Amendment 5, before any decisive run: the disclosures, the readings fixed in the code, the dry run’s environment and the review. “No result of these claims was known.”
  4. The decisive run · started 19:29:58. Once, on the code at a1fe9a8: the reference’s half in 2 min 15 s, then Node and Chromium in 6 min 52 s (“~”). The JavaScript runner first reran the parity and the data checks, and refuses to go on if any line fails or is skipped.
  5. 648a6b6 · 19:41 · The results, as they came out: claims-phase2.json and .md, phase2-python.json and .md, and the console log. Every case is reported, and no UD EWT text is in a committed file (digests, counts and offsets only).
  6. 5e1681c · 20:47 · Two gaps the blocked hosts had left, closed. The pinned Unicode 15.1 table was checked field by field against the official UCD 15.1.0 files (unicode-org/unicodetools at b9144701, through GitHub, since unicode.org is blocked here): equal in every field (ucd_15_1_v1.meta.json). And the 34 outside numbers whose primary source had become reachable were read in it: 28 confirmed, 5 corrected, 1 not found in its cited paper (the dated note in Explainer 7).
  7. 2f89ac1 and 445a2e1 · 20:47 · Amendment 6, an erratum. L6’s training protocol is credited to Nickel & Kiela, but the paper samples 10 negatives with a burn-in of 10 epochs; the 50 negatives, batch 50 and 20 burn-in epochs come from the authors’ released script. The protocol is therefore this project’s own, after the paper and the script, and stays exactly as registered; L6 had not run then (it ran under that protocol in Phase 4: Explainer 12). The second commit corrects the amendment’s last sentence.

What Amendment 4 fixed

ItemWhat it fixes
1 · enginesPython is the Phase 1 reference, the authority. Node 22 runs lexicon_core.js on hyperbolic_core.js, decoder3d.js and orbital_core.js, loaded unchanged by relative path. Chromium is Playwright’s, headless, loading the core, the cores and the pinned data from a page served over HTTP from the repository root. Every result records the versions
2 · L1’s recordThe record and the comparison by its SHA-256 (records themselves compared and kept when a digest differs); Node loads the four instance lists with its own JavaScript loaders and must match their pins before it runs; Chromium receives Node’s bytes
3 · L1’s controlsControl 1 as spike S6 ran it, in Node and in Chromium; controls 2 and 3 in the reference. Reported: agreement with Hugging Face tokenizers and the tokenizer metrics
4 · L3(f)Node builds the noun words with the core’s rule, the H³ points with decoder3d.js pointExact and the H² points with the core’s tree; the canonical list must have Phase 1’s SHA-256 and the 2,000 sampled lines must equal results/l3f-python.txt
5 · L4(a)Rank lists for every mammal query and noun queries 0–199, in H³ and H², in Python and Node; equal means every rank list’s SHA-256 and every exact MAP and mean rank. The mammal part also runs in Chromium, reported
6 · L4(b)Each coordinate correctly rounded to float64; the key x0·y0 − x1·y1 − x2·y2 (− x3·y3) left to right, without fused multiply-add; what an inversion is; the float32 and acosh controls. Decided by the reference, Node reported
7 · dry runsL1 on Rng(4000 + i) strings and the repository Markdown; L3(f) on the verb forest; L4 on the verb forest with Rng(4000).sample(13767, 200)
8 · orderBefore any decisive run, tests/parity-lexicon.cjs reproduces every Phase 1 trace line for line in Node, and the runners are committed after their dry runs

What Amendment 5 recorded

  • Disclosures. While building, the text builder timed NB and WordPiece over instance (a) in Node, and the geometry builder built all noun words and points in Node to time them: times only, nothing compared or printed. The builders and the reviewers compared the JavaScript with Python only on the Phase 1 traces, the registered dry sets and strings from unregistered seeds (70000 + i), and hashed L1’s instance lists against their pins.
  • Readings fixed in the code (each marked READING). An empty normalised text is written -, so an instance with no words has the record - TAB -; a list’s digest is the SHA-256 of its per-instance digests, each followed by LF. The decisive run refuses to start without V1 or with any trace line skipped. Control 1 is decided per runtime against the reference’s per-case SHA-256 of S6’s R(s). No UD EWT text enters a committed file. A passing L4 control 2 would void both (a) and (b). For L4(b) an infinite key takes part in comparisons, a NaN key is neither an inversion nor a tie, and non-finite keys are counted. Hugging Face agreement compares token strings only.
  • The review. Three reviewers, two skeptics for every finding, probing the core and the runners independently on unregistered data. They found no defect in NB, WordPiece or the geometry, and confirmed three gaps, all fixed before the amendment: the guard against platform Unicode missed a call made through a computed name; L1 could be decided without its V1 cells; and UD EWT text could reach the committed JSON.

Two labels to note

The started field of claims-phase2.json (and the “Run” time in its .md), 19:39:05, is stamped when the runner assembles its results, after every claim has run (run_claims_js.cjs builds that record last). It is the run’s end: the reference’s half started at 19:29:58 and took 2 min 15 s, and 6 min 52 s after that is 19:39:05.

Both result files record HEAD a1fe9a8 and that the folder had uncommitted changes when they ran (reference_uncommitted_changes and system_uncommitted_changes are true). They do not say which files. No commit since a1fe9a8 has changed a file the runners load. The only additions under reference/ since then are the UCD check, its meta file and its test (5e1681c), which no runner loads, and the run’s own results (648a6b6). The JavaScript runner records its flag at the end of the run, when results/phase2-python.json and .md, just written by the reference’s half and committed only in 648a6b6, were untracked; that alone makes system_uncommitted_changes true. For the reference’s flag, recorded as its run started, nothing recorded shows which files changed.

03

What lexicon_core.js holds

One UMD module of 1,595 lines at the end of Phase 2 (version string lexicon-browser-1); Phase 3 added its chain section, which brings it to 2,928 (Explainer 11), and Phase 4 the exact ranking of snapped learned tables (SnapArm, evaluateSnapped) and the L6 trace, which bring it to 3,205 (Explainer 12). The text half is a twin of the reference’s normalise.py and wordpiece.py; the geometry half a twin of address.py, h3tree.py, h2exact.py, flat.py and rank.py. It runs no claim itself.

PartWhat it holdsTwin ofMain exports
PinsThe SHA-256 and size of the Unicode table (142,624 bytes, 30bed6fb…), V0 (55,648 bytes, 8,192 entries, df227056…) and V1 (231,508 bytes, 30,522 entries, 07eced37…, revision 86b5e09). A file is refused unless it is the pin; the parity runner checks that these equal the meta filesgolden/*.meta.jsonPINS, tablesFromText, vocabFromText
Bytes and UTF-8The strict decoder of Unicode Table 3-7, which reports the first ill-formed sequence where CPython’s UnicodeDecodeError.start does; the encoder; hex; SHA-256 through the orbital corenormalise.pydecodeUtf8, utf8, hex, sha256Hex, InvalidUTF8
The pinned tableCategories, lowercase mappings, canonical decompositions (Hangul algorithmic), combining classes, the two Final_Sigma sets and whitespace, read from the table alone; one flag byte per code pointunicode_tables.pytables, FLAGS
NBBERT’s BasicTokenizer on the table: drop Cc, Cf and Co (and U+0000, U+FFFD); split on whitespace and around CJK ideographs; fail a token holding an unassigned code point closed, as one [UNK]; lowercase with Final_Sigma; NFD with canonical ordering; drop Mn; split punctuation; keep byte spans. Also N1, the registered fallbacknormalise.pynb, n1, NB
WordPieceGreedy longest-match-first on code points, [UNK] beyond 100 code points; shortest-match-first for L1’s control 2wordpiece.pyVocab, wordpiece, encodeNb, encode
Ids and recordsUnsigned LEB128, the id stream, L1’s record, the per-instance and list digestswordpiece.py, phase2.pyleb128, idStream, record, recordSha256, listDigest
L1’s control 1platformNormalise, spike S6’s platform normaliser verbatim, the one call into the platform’s Unicode in the file; and S6’s R(s) on the table, for comparisonphase2.pyplatformNormalise, tableLowerNfdDropMn
Trace lines and parityEach trace line regenerated from its case’s bytes or its seed, and compared; text and geometry sectionstraces_text.py, traces_geometry.pyparitySections, runParity
Forests and addressesThe spanning forest and closure, the L3 rule and its zero-letter and truncation controls, certifyWord, the D6 id codec (id59, id64), the prefix check, map Awordnet.py, address.pyforestOf, childWord, certify, wordId, idWord, mapA
Exact pointsH³ by decoder3d.js pointExact (t = 3/4) and by integer frames over 7n, with an integer decoder; D3’s exact H² tree (t = 11/13) with exact greedy decoding; the flat arms F3, F2, F3*, F2*h3tree.py, h2exact.py, flat.pyh3PointExact, h3Points, H2Tree, FlatTree
Exact rankingArms as integer columns over one denominator, integer Lorentz keys, rank lists and their SHA-256, pessimistic AP, MAP and mean rank as exact rationalsrank.pyArm, rankQuery, mapExact, meanRank
L4(b)’s floatsCorrect rounding to float64 (then float32 for control 1), the left-to-right key, inversions and float ties, control 2’s acosh evaluatorphase2.pyfloatCols, floatKeys, floatQuery, acoshAp
L3(f)The canonical point list: one line per noun and tree, every coordinate in lowest termsrun_claims.pycanonicalPointList

The cores it loads, unchanged

CoreFromWhat the core uses
orbital_core.jsscripts/geometric-buildSHA-256 and toHex
hyperbolic_core.jsPages/Hyperbolic OraclesExact rationals Q over BigInt, the norm-5 tree P, and the shared generator Rng, the twin of hpstep’s prng
decoder3d.jsPages/Hyperbolic OraclesTreeEmbedding3D: the exact H³ tree (pointExact, decodeExact), and its float point and decode for L3’s control 3

In a page they load in that order, then the two data files, then the core (the data files may also come after it: they are read on first use). In Node the core requires them by relative path. If any is missing, the core throws at once rather than run on something else.

The data wrappers

A page opened from file:// cannot fetch the files beside it. So make_js_data_v1.cjs writes each pinned file’s exact text into a script that registers it on LexiconData: data/unicode_15_1_v1.js (157,238 bytes, holding the 142,624-byte table) and data/vocab_v0_lex0.js (97,475 bytes, holding V0’s 55,648 bytes, one entry per line). Both sources are ASCII, so a page’s charset cannot change them. The core hashes the text again on first use and refuses it unless it is the pin. At the decisive run, make_js_data_v1.cjs --check rebuilt both wrappers and found them equal (exit 0), and both texts had their pins’ SHA-256.

V1 has no wrapper. bert-base-uncased’s vocab.txt sits in the cache, outside git, with only its hash committed. Node reads it from ~/.cache/hyperbolic-lexicon; Chromium receives its bytes from Node through the harness and refuses them unless they are the pin. In this page, V1 runs only if you give it the file (chapter 4).

The guard against platform Unicode

D5 says NB reads only the pinned table. Node 22.23.4 and Chromium 153 carry Unicode 17.0; the table is 15.1. One toLowerCase inside NB would bring 17.0 in, which is exactly what control 1 measures (chapter 6). So the parity runner reads lexicon_core.js with its comments blanked and fails if anything outside platformNormalise reaches the platform’s Unicode:

RuleWhat it catches
nameA forbidden name in the code: normalize, toLowerCase, toUpperCase, the two locale case functions, localeCompare, Intl, TextDecoder, trim, \p{, \P{, \s, \S, RegExp, String.prototype, codePointAt, isWellFormed, toWellFormed (18 in all)
literalA forbidden name inside a string, template or regex literal: a call by name, s["toLowerCase"]()
regex flagsA regular expression with the u, v or i flag (Unicode properties, Unicode case folding)
computed callAny call through a computed member, x[…](…), whose name cannot be read
string indexA computed member whose index holds a string, x["toLower" + "Case"]: a name built where it is used
indirecteval, Function and Reflect

The guard has controls of its own: a line planted for each rule must be caught by that rule, and a comment that names toLowerCase must not count. It also checks that platformNormalise is spike S6’s, verbatim. The scanner is lexical, and its comment says what lies beyond it: a name assembled elsewhere and read through a plain variable index that is not called where it is read. The core has no computed member access with a string index, no computed call and none of the indirect forms. Amendment 5’s review found the gap it had then, a call through a computed name, and it was closed before the decisive run.

04

The parity, in your browser

The core’s own parity functions, on the reference’s own trace files, in the browser you are reading this in. What can run in a page runs line for line; what needs WordNet or V1 is reported as skipped, never as passed.

Before the decisive run, tests/parity-lexicon.cjs passed 18,667 of 18,667 lines in Node, as Amendment 4 item 8 requires. Of those, 18,578 regenerate trace lines and 89 are other checks: the pins, the data wrappers, the UTF-8 decoder against an independent Table 3-7 scanner, hand-checked behaviour, the guard, the geometry tests and the trace check’s own controls. The lab below runs the trace sections through LexiconCore.paritySections, the function the Node runner calls, with no WordNet object: WordNet reaches the core only in Node, read from the pinned archive in the cache, which is not in the repository. So the verb-forest lines of address_v1.txt and the rank lines of rank_v1.txt cannot run here.

Lab · the trace parity, rerun in this page
Loading the core…
Trace fileWhat its lines holdLines in NodeHere: passfailskippedFirst failing line,
or why skipped
normalise_v1.txtNB on 88 hand-picked cases and 300 from Rng(8000 + i): result, normalised text, each word and its byte span; and the table’s pin in the header389–––not run yet
wordpiece_v1.txt (V0)V0’s pieces, ids and byte spans on the 381 valid cases, the header, and the id stream’s length and SHA-256383–––not run yet
wordpiece_v1.txt (V1)The same under V1383–––not run yet
address_v1.txtThe letter rule and its two controls on 200 cases from Rng(8300 + i) (no WordNet needed), and the 13,767 verb words (WordNet needed)14,014–––not run yet
points_v1.txt300 words from Rng(8000 + i): each D6 id and the exact points in H³, H², H² at t = 3/4 with its decode, F3, F3*, F2 and F2*, in lowest terms3,004–––not run yet
rank_v1.txt20 verb-forest queries: rank-list SHA-256 and exact APs and ranks in H³ and H² (WordNet needed)405–––not run yet
The first lines of each section, as the core reports them
Run the parity first.

The button fetches the five trace files from ../reference/traces/ (about 1.1 MB) and hands them to the core; each line is rebuilt from its own inputs or seeds, and only the expected text is read from the trace. Browsers do not let a page opened from file:// fetch the files beside it, so over file:// the lab says so and stops: serve the repository root over HTTP (for example python3 -m http.server from it) and open this page there. Without V1, expect 4,027 lines to pass and 14,550 to be skipped (the V1 section skips its 382 data lines; its header check needs V1 itself and is not counted, so the two add up to 18,577 of the 18,578); with V1’s vocab.txt loaded (refused unless its SHA-256 is the pin), 4,410 and 14,168. A failing line would be shown with its first differing character.

What this lab is, and is not

It is the Authority rule made visible: the same functions that decided L1 in Chromium, on the traces that were checked before the decisive run. It touches no registered instance and decides nothing. A pass here says your browser’s JavaScript gives the reference’s lines on these cases; L1’s cells were decided in Chromium 153 on 156,801 instances (chapter 6).

05

A live front end

NB, WordPiece, the id stream and L1’s record, on whatever you type, by the functions that decided L1. Beside them, control 1: the platform’s own normaliser, which the pinned table keeps out.

Lab · your text through NB and WordPiece
Vocabulary
Loading the core…

NB’s words

#WordInput bytesFrom the inputCode points of the word

WordPiece pieces and ids

PieceIdInput bytesFrom the input

The record (Amendment 4 item 2) and the id stream

Control 1: the platform’s normaliser against the table

Byte spans are [start, end) in the input’s UTF-8. Control 1 compares spike S6’s two functions on the whole string: the platform’s toLowerCase(), normalize('NFD') and removal of \p{Mn}, against the same three steps on the pinned 15.1 table. That is not NB: nothing is dropped, nothing is split into words and nothing fails closed. Your browser’s own Unicode decides the left-hand side, so what differs depends on its version.

Try it
  • The cat sat on the mat. Seven words; the full stop is a word of its own, bytes 22–23. Under V0 each word is one piece (the = 136, cat = 1057, sat = 1591, …, “.” = 17).
  • ΟΔΟΣ ΣΟΦΙΑΣ. The capital sigma at each word’s end lowercases to the final form ς (Final_Sigma), the others to σ. V0’s alphabet is ASCII, so both words are [UNK]; with V1 loaded they split into ο ##δ ##ος and σ ##ο ##φ ##ια ##ς.
  • İstanbul café naïve. U+0130 lowercases to i and U+0307, and NFD with the Mn removal strips that mark and the accents: istanbul cafe naive. V0 splits them (is ##tan ##b ##ul …); V1 keeps each whole.
  • AʕΣ (U+0041 U+0295 U+03A3). In 15.1, U+0295 is a cased letter, so the sigma is final: ς. A Unicode 17.0 platform, where U+0295 is no longer cased, gives σ. Control 1 differs here.
  • a, U+0897, b c. U+0897 is unassigned in 15.1, so NB fails that whole word closed: one [UNK] over bytes 0–5. A platform with Unicode 16.0 or later knows U+0897 as a combining mark and drops it. Control 1 differs here too.
  • 東京 tokenizer. Each CJK ideograph becomes a word of its own. V0 has neither; V1 has both.
06

L1 · One front end, three engines

On every instance, the Python reference, Node 22 and headless Chromium give identical normalised text bytes, token strings, ids, byte offsets and id-stream SHA-256, for each pinned vocabulary. In all four cells nothing differs, and all three controls show their weakness. supported

RegisteredAs run
Instances(a) every WordNet 3.0 gloss, 117,659; (b) every # text = sentence of UD English EWT, 16,622; (c) the Unicode stress set, 20,520; (d) 2,000 synthetic strings from Rng(1000 + i). 156,801 in all. Node loaded each list itself and matched its pin and Python’s input (bc86a44d…, 2bdf1644…, 3ccd5076…, aabb7bef…); Chromium received Node’s bytes
VocabulariesV0 “lex0” (8,192 entries, df227056…) and V1 bert-base-uncased (30,522, 07eced37…), pinned, so both cells are in force
MetricInstances whose record’s SHA-256 differs from Python’s, and the equality of each id stream, per set, vocabulary and runtime
DecisionPer cell: supported if no instance differs and every id stream is equal; refuted by any difference; void if a control passes

The four cells

CellInstancesDifferingId streams differingControls 1 / 2 / 3Decision
V0 · Node156,80100show their weaknesssupported
V0 · Chromium156,80100show their weaknesssupported
V1 · Node156,80100show their weaknesssupported
V1 · Chromium156,80100show their weaknesssupported

Per instance set: the digests both runtimes matched

SetInstancesV0: record list · id streamV1: record list · id streamNode, sChromium, s
(a) glosses117,659defa6cc3… · 87493312…7aa8d14f… · afa37940…15.812
(b) EWT sentences16,6225b60a59e… · 88dd74b7…027e76a4… · 1ca97639…2.11.9
(c) stress cases20,520ec446444… · a97e775d…2849500c… · ebb579b2…0.50.4
(d) synthetic2,00083916d1a… · d59109f0…5fbea5ff… · ad34b5bf…0.30.3

Each digest is Python’s, and Node and Chromium gave the same one (the full values are in phase2-python.json). The seconds are for both vocabularies together (“~”; Chromium’s are measured in the page). Chromium reported no page errors.

The engines

EngineVersionIts own UnicodeWhat it ran
Python3.13.18unicodedata 15.1.0The reference, the authority; NB reads only the pinned table (30bed6fb…). Hugging Face tokenizers 0.23.3 for the reported agreement; numpy 2.5.3 for L4(b)’s float keys (float64, and float32 in its control 1)
Nodev22.23.4 (V8 12.4.254.21-node.57)ICU 78.3, Unicode 17.0, CLDR 48.0lexicon_core.js, on linux x64
Chromium153.0.8010.12, headless, through Playwright 1.63.0No ICU version exposed to pages; the newest of three markers assigned in the page: U+20C1, new in 17.0tests/l1-harness.html, served from the repository root over HTTP

Both JavaScript runtimes, through their own functions, lowercase U+0130 to 0069 0307, give 03B1 03C2 for a final sigma, and decompose U+1E9B U+0323 to 017F 0323 0307. Their platform Unicode is 17.0, and the core does not read it.

The controls

ControlMustMeasured
1 · The platform’s normaliser (S6’s toLowerCase().normalize('NFD') minus \p{Mn}) against the reference’s R(s), on (c)differ on at least one case, in each runtimeNode 725 of 20,520
Chromium 725 of 20,520
2 · WordPiece shortest-match-firstdiffer on at least one instance of (a)117,659 of 117,659
(V0 and V1)
3 · NB without accent stripping (lowercase kept, NFD and Mn removal skipped)differ on at least one instance of (a) or (b)(a) 0 of 117,659
(b) 7 of 16,622
(V0 and V1)
  • Control 1’s 725 cases. In each runtime the core’s table pipeline gave the reference’s per-case list exactly (eca96dd8…, 0 cases differing), while the platform’s functions differed on 725. The run reports the count and the first three cases, 2, 5 and 6: U+0897, U+1ACF and U+1AD0 alone, each dropped by the platform as a combining mark and kept by the table, where it is unassigned. It does not break the count down. Spike S6, in the same runtime versions, broke the same total down: 143 of the 9,990 divergent code points alone and 143 in ASCII context, 392 of 444 Final_Sigma cases, 47 of 71 canonical-ordering cases, and none of the 10 U+0130 or 15 Hangul cases (S6’s output, Explainer 8). The registration quoted S6’s 725, and the decisive run found 725 again in both runtimes. Python’s own unicodedata gives the same R(s) as the table on all 20,520 cases (reported, never decisive).
  • Control 2 changes every gloss. “that”, the first word of WordNet’s first gloss (entity.n.01), is one V0 piece under longest match (id 181) and t ##h ##a ##t under shortest match.
  • Control 3 changes no gloss and 7 EWT sentences, under either vocabulary. The rule asks for one case, so it shows its weakness; the margin is thin because almost nothing in the glosses and EWT changes under NFD and Mn removal. The sentences are not quoted: L1’s Data line keeps UD EWT text out of committed files, so the JSON keeps each example’s index, first differing offset, lengths and SHA-256s, and the text goes to the cache.

Reported, not decisive

The tokenizer metrics come from the reference, per set and vocabulary. Fertility is pieces per NB word, the continued-word rate the share of words split into two or more pieces, bytes per piece counts input bytes, and the Rényi efficiency is at α = 2.5 over the vocabulary’s entries.

SetVocabWordsPiecesFertilityContinued
words
Bytes per
piece
Rényi
efficiency
[UNK]
rate
Fail-closed
words
Hugging Face
differs
(a)V01,711,2062,082,4841.21700.14724.250.46930.000000 / 117,659
(a)V11,711,2061,893,7801.10670.06564.670.39510.000000 / 117,659
(b)V0273,473340,1071.24370.16653.650.51120.001700 / 16,622
(b)V1273,473291,9451.06750.04634.250.42430.000000 / 16,622
(c)V020,57820,5821.00020.00015.030.00080.995720,4120 / 20,520
(c)V120,57820,6751.00470.00275.010.00200.987920,41228 / 20,520
(d)V07,2547,2541.00000.000026.260.00290.984436929 / 2,000
(d)V17,2547,3301.01050.004425.990.00940.943736929 / 2,000

The stress set is built from code points on which the runtimes disagree: 20,412 of its 20,578 words hold a code point that is unassigned (Cn) in 15.1 and fail closed, so nearly every piece is [UNK]. In (d), 217 words are longer than BERT’s 100-code-point limit and are [UNK] for that reason. On real text, V1 needs fewer pieces per word than V0 (1.1067 against 1.2170 on the glosses, 1.0675 against 1.2437 on EWT). V0 has no [UNK] on the glosses it was trained on, and 582 [UNK] pieces on EWT (a rate of 0.0017): words with a code point outside its 64-character ASCII alphabet.

Hugging Face. tokenizers 0.23.3, as BertWordPieceTokenizer on the same vocabulary file (lowercase, accents stripped, text cleaned, CJK handled, no special tokens), compared by token strings only: it agrees with the reference on every gloss and every EWT sentence, under V0 and under V1. It differs on 28 stress cases under V1 (none under V0) and on 29 synthetic strings under each vocabulary. The results keep three examples of each:

  • Stress cases, V1: all three are Final_Sigma. Where NB, as CPython’s str.lower, gives the final ς (ο ##δ ##ος; a ##ς .), Hugging Face gives σ (ο ##δ ##ο ##σ; a ##σ .). Under V0 both give [UNK] for these Greek words, since V0’s alphabet is ASCII, so they agree.
  • Synthetic strings, V0 and V1: where the reference has one [UNK], Hugging Face has [UNK], then “;” or “>”, then [UNK]. That fits NB’s order of steps: a whitespace token holding a code point unassigned in 15.1 fails closed as a whole (step 4) before punctuation is split (step 6). The results do not give the cause.

This agreement is reported and never decisive: L1 compares the reference with Node and Chromium, not with Hugging Face.

The prediction read: “Supported in both runtimes, and all three controls fail. Because the tables are data, the platform’s Unicode version (Node: Unicode 17.0, ICU 78.3; Python: 15.1.0) cannot leak in.” It held: the platform’s Unicode is visibly different (control 1), and none of it reached the records. The named risk points, the Final_Sigma context, U+0130 and canonical ordering, are all in the stress set and in the traces.

07

L3(f) · The same points in JavaScript

Python and JavaScript give the same words and the same exact points for all 82,115 noun synsets. With it, L3 is decided on all seven parts. supported

Node built the noun words with the core’s address rule from the archive read by golden/wordnet_v1.cjs, the H³ points with decoder3d.js’s own pointExact (t = 3/4), and the H² points with the core’s exact tree (D3, t = 11/13), as Amendment 4 item 4 orders. It then wrote the canonical point list, one line per noun and tree with every coordinate in lowest terms, and compared it with Phase 1’s.

CheckedResult
Canonical point list, all 82,115 nouns (29,442,565 bytes): Node’s SHA-256 against Python’sequal
Sampled lines (word, H³ line, H² line) for node i = Rng(1000 + i).below(82115), against results/l3f-python.txt2,000 of 2,000 equal
A check of the comparison (reported, not a registered control): one digit changed in one Node line must make exactly that line differcaught
Time (“~”): the words; both points of every node; L3(f) in all85 ms; 76.6 s, 0.933 ms per node; 76.7 s

The shared SHA-256 is eb22bf00689ec86da05f0f4ba6338abc0ba0a1549ada844a134cbce154a3ebc6, the value Phase 1 wrote. Because the H³ points come from decoder3d.js itself, not from a port, this also shows that Hyperbolic Oracles’ JavaScript tree gives the reference’s H³ points on every noun word, up to 36 letters. In Phase 1 the reference’s own H³ points had matched hpstep’s point_exact on the 2,000 sampled nodes.

L3(f) has no controls of its own: Amendment 5 has it inherit Phase 1’s, all of which failed as required. The zero-letter variant gave 11,978 nodes a shared word; the truncation variant 74,220; float placement and decoding failed on 67,989 of the 71,454 words longer than 12 letters; and the H² tree at t = 3/4 failed exact decoding on 19,796 words (Explainer 9).

08

L4(a) · The same exact rankings

Ranking every candidate by the exact Lorentz product of the L3 points gives the same rank lists in Python and Node, and the same MAP and mean rank as exact rationals, in H³ and H². supported

SetTreeQueries ×
candidates
Rank lists
differing
Graph-edge
MAP
Closure
MAP
Graph-edge
mean rank
Closure
mean rank
Rank lists
digest
mammalsH31,176 × 1,17500.6906530.3059326837/2350
= 2.909
435817/6515
= 66.894
6426f70f…
mammalsH21,176 × 1,17500.7187230.3063316431/2350
= 2.737
446213/6515
= 68.490
05872a21…
nouns 0–199H3200 × 82,11400.5532530.138801631/156
= 4.045
3818875/2362
= 1,616.797
5d5d9caf…
nouns 0–199H2200 × 82,11400.5722140.1381161273/312
= 4.080
1841521/1181
= 1,559.290
c2ca9411…

“Equal” here is stronger than equal floats. The mammals’ graph-edge MAP in H³ is 51819432553492217484042834552823/75029592323216949894417221280000 in both languages, and the closure MAPs have numerators and denominators of 529 to 741 digits; each value was compared whole, and so were the digests of the per-query AP lists. No query lacked neighbours in either set. Node took 1.7, 1.9, 28.3 and 35.2 s for the four rows (“~”).

  • Chromium ran the mammal part (reported): 0 differing rank lists and every exact value equal, in both trees, in 1.4 and 1.5 s.
  • A cross-check with Phase 1. The mammal values equal L5’s H3 and H2 rows in results/claims.json. The noun MAPs here (0.5533 in H³, 0.5722 in H²) are over queries 0–199 only, so they differ from L5’s 0.5679 and 0.5901 over all 1,000 queries; they are not a second estimate of anything (Explainer 9).
  • Control 2 bears on (a) too. Amendment 5 reads a passing control 2 as voiding both parts of L4. It showed its weakness (chapter 9), so (a) is not void.
  • Fractional ties, reported since Phase 4. The Common rules ask for fractional-tie values beside the pessimistic ones, deciding nothing, and Phase 2 reported only the pessimistic ones (Amendment 10 item 17). Phase 4 computed them from these rank lists with Phase 2’s own code and draws, in results/fractional-ties.md: on the mammals H³’s graph-edge MAP is 0.690653 pessimistic and 0.770081 fractional (488 of the 1,176 queries depend on the order inside a tie class), H²’s 0.718723 and 0.718915; on nouns 0–199, H³’s is 0.553253 and 0.618918. L4(a) stays decided as recorded.
09

L4(b) · Float64 is not certifiable

Round the same exact points to float64, rank by the float Lorentz product, and at WordNet’s depth the order breaks: on 997 of the 1,000 noun queries, some exactly ordered adjacent pair comes out inverted. supported (decided by the reference; Node’s counts are the same)

What an inversion is

Take one query and put the other 82,114 nouns in exact order: by exact key, then by synset offset. Walk the 82,113 adjacent pairs. A pair whose exact keys strictly increase while their float64 keys strictly decrease is an inversion; a strictly ordered pair whose float keys come out equal is a float tie, counted but not an inversion. The float key is x0·y0 − x1·y1 − x2·y2 (− x3·y3), each coordinate first rounded once to the nearest float64, then evaluated left to right in IEEE-754 double without fused multiply-add (Amendment 4 item 6). A query counts if it has at least one inversion in H³ or in H².

The first inversion

In both trees it is in the first query of the sample, 01984245 (a 25-letter word), at the very first pair of its exact order: 01982650 (24 letters), then 01983048 (25 letters). Their float keys are −1.847 × 1018 and −1.303 × 1019 in H³, and −9.04 × 1032 and −1.43 × 1034 in H²: the nearer candidate gets the larger key. The exact Lorentz product of two points on the sheet is the cosh of their distance, never below 1, so these negative values are rounding error alone. The key subtracts products that agree in their leading digits, and float64 keeps 53 bits of each.

Reported, per tree (1,000 noun queries)H³H²
Queries with an inversion990993
Inversions in all4,978,0098,969,341
Inversions per query, on average (of 82,113 adjacent pairs)4,9788,969
Float ties of strictly ordered pairs (queries with one)152,072 (982)1,715 (345)
Non-finite float keys00
Deeper word at each query’s first inversion: shortest / median / longest, letters11 / 18 / 359 / 18 / 35
Queries whose first inversion has a deeper word of 12 letters or fewer11111
Node: queries whose counts differ from Python’s00
Time (“~”): Python; Node19.0 s; 86.8 s25.3 s; 109.4 s

Together, 997 queries invert in H³ or H²: from the per-query lists in phase2-python.json, 986 in both, 4 in H³ only and 7 in H² only. Three queries invert in neither tree. The rule needs one, so L4(b) is supported; the claim is that float64 ranking here cannot be certified, and nearly every query shows it.

L4(b): the deeper word at each query’s first float64 inversion For each noun query with an inversion (990 of the 1,000 in H3, 993 in H2), the length in letters of the deeper word of its first inverted pair, counted per length. H2’s first inversions start at 9 letters, H3’s at 11; both peak between 14 and 18 letters and run out to 35. H³: 990 queriesH²: 993 queries 0 25 50 75 100 10 15 20 25 30 35 Deeper word of 9 letters: H³ 0 queries, H² 3 queries Deeper word of 10 letters: H³ 0 queries, H² 17 queries Deeper word of 11 letters: H³ 2 queries, H² 34 queries Deeper word of 12 letters: H³ 9 queries, H² 57 queries Deeper word of 13 letters: H³ 48 queries, H² 54 queries Deeper word of 14 letters: H³ 83 queries, H² 69 queries Deeper word of 15 letters: H³ 99 queries, H² 81 queries Deeper word of 16 letters: H³ 91 queries, H² 81 queries Deeper word of 17 letters: H³ 93 queries, H² 86 queries Deeper word of 18 letters: H³ 99 queries, H² 93 queries Deeper word of 19 letters: H³ 66 queries, H² 62 queries Deeper word of 20 letters: H³ 53 queries, H² 44 queries Deeper word of 21 letters: H³ 52 queries, H² 60 queries Deeper word of 22 letters: H³ 63 queries, H² 58 queries Deeper word of 23 letters: H³ 49 queries, H² 42 queries Deeper word of 24 letters: H³ 60 queries, H² 32 queries Deeper word of 25 letters: H³ 33 queries, H² 36 queries Deeper word of 26 letters: H³ 29 queries, H² 26 queries Deeper word of 27 letters: H³ 21 queries, H² 18 queries Deeper word of 28 letters: H³ 16 queries, H² 17 queries Deeper word of 29 letters: H³ 9 queries, H² 9 queries Deeper word of 30 letters: H³ 5 queries, H² 4 queries Deeper word of 31 letters: H³ 6 queries, H² 6 queries Deeper word of 32 letters: H³ 1 query, H² 0 queries Deeper word of 33 letters: H³ 2 queries, H² 3 queries Deeper word of 34 letters: H³ 0 queries, H² 0 queries Deeper word of 35 letters: H³ 1 query, H² 1 query queries letters in the deeper word of the first inverted pair
For each query that inverts, the length of the deeper word in its first inverted pair, counted per length: H³ (990 queries) and H² (993). H²’s first inversions start at 9 letters and H³’s at 11; both peak between about 14 and 18 letters, and both reach 35. Noun words run to 36 letters. Hover a length for its counts; the table below holds them.
The counts behind the chart
Letters in the deeper wordH³ queriesH² queries
903
10017
11234
12957
134854
148369
159981
169181
179386
189993
196662
205344
215260
226358
234942
246032
253336
262926
272118
281617
2999
3054
3166
3210
3323
3400
3511

Why H² inverts more often

H² inverts on more queries (993 against 990), with nearly twice as many inversions, and it has more inversions than H³ on 971 of the 1,000 queries (from the per-query lists). Its first inversions also come earlier: at 9 letters at the shortest, and at 12 letters or fewer on 111 queries against H³’s 11. A likely reason, which the run does not measure: each letter boosts by a factor of 12 in D3’s H² tree (t = 11/13) against 7 in the H³ tree (t = 3/4), so at the same word length the H² coordinates are larger (in Phase 1, at most 252/142 bits per coordinate against 184/102), and the key’s cancellation throws away more of float64’s 53 bits. The first inverted pair fits that reading: the same two synsets get float keys near 1033 in H² and near 1018 in H³. H³, for its part, has far more float ties (152,072 against 1,715); the results do not say why.

The registration predicted (b) from spike S1, which saw float64 first invert at depth 10 on straight paths and 12 on random words, in H³ (Explainer 8). On the nouns, the earliest first inversion in H³ has an 11-letter deeper word.

The controls

ControlMustMeasured (Python; Node the same)
1 · Float32: the mammal points rounded to float64, then float32, the key in float32 arithmetic, every mammal query in H³show at least one inversion, or (b) is void1,137 of 1,176 queries
2 · A float evaluator sorting by float64 acosh(max(1, key)), then node index, on every mammal query in H³ with an exact neighbour/non-neighbour tiegive a different AP from the pessimistic exact one on at least one (N/A, not void, if there is no tie)487 of 488 tied queries
  • Float32 fails badly at mammal depth: 200,369 inversions and 212 float ties, and 902,886 of the 1,381,800 keys (1,176 queries × 1,175 candidates) are not finite, since float32 overflows above about 3.4 × 1038. Each query’s first inversion has a deeper word of 20 to 29 letters (median 25). Node, rounding with Math.fround after each operation, reproduced every query’s counts and the first inversion.
  • The acosh evaluator. 488 of the 1,176 mammal queries have an exact tie between a graph-edge neighbour and a non-neighbour; the registration predicted such ties (spike S1 found them wherever virtual letters occur), and they are there. On 487 of the 488 the evaluator’s AP differs. The three kept examples: 01874434, exact pessimistic AP 791/810 = 0.977 against 0.233; 01876326, 7/10 against 0.253; 01877134, 9/10 against 0.166. With exact distances, breaking ties by index could not give a lower AP than the pessimistic rule, so these much lower values mean float rounding moved the order too. The control asks only that the APs differ.

The prediction was “(a) and (b) supported”, with control 2 expected to apply. Both held.

10

What this does not show

Four exact results, on one machine, about one front end and one geometry. That is narrower than it may sound.

  • Three engines, one machine. Python 3.13.18, Node 22.23.4 and Chromium 153.0.8010.12, on this container (linux x64). Not Firefox, Safari or another browser engine, not another operating system or processor, not another version. The pinned table is meant to make the platform’s Unicode irrelevant, and control 1 shows that it would otherwise matter; another engine is a new test.
  • Byte identity, not tokenizer quality. L1 says the same bytes, pieces, ids and offsets come out everywhere. It says nothing about how good V0 or V1 is. V0’s alphabet is ASCII, so under V0 any word with a non-ASCII letter is [UNK], identically in every engine.
  • Hugging Face is reported. Its agreement compares token strings only and decides nothing; its 28 and 29 differences are explained here only through the examples the results keep.
  • L4(a)’s reach. On the nouns it uses queries 0–199 of the sample, each against all 82,114 other nouns; Python and Node are the decisive pair, and Chromium ran only the mammals, reported.
  • L4(b) is about this float formula. It shows that rounding these exact points to float64 and evaluating the Lorentz product left to right cannot be trusted to keep their order. It does not test other float formulas or learned embeddings: L4(c), on L6’s learned tables snapped to the 2−32 grid, was decided in Phase 4: supported, with the largest change in MAP 9.37×10−6 (Explainer 12).
  • The guard is lexical. It reads the core’s source, not its behaviour; what it cannot see is stated in its comment (chapter 3). The behavioural evidence is L1 itself: 725 cases on which the platform differs, and 0 on which the core does.
  • The labs on this page run the trace lines that need neither WordNet nor V1, and the front end on your own text. They demonstrate the core in your browser and decide nothing.
  • Timings belong to this container. Every “~” number would move on another machine; no claim here is decided on time (L11, in Phase 3, was: Explainer 11).
11

Phase 3, planned and done

The plan at the end of Phase 2: records and biochains, that is, the synchronous grower in JavaScript and Python, the records, RFC 6962 manifests, the exact weave and the hardened, attested importer, to decide L8–L11. Phase 3 has built them and decided all four (Explainer 11).

  1. L8 · Language shards are Owl-valid biochains. Our JS grower (the biochain_v1.js codec with the orbital core’s SHA-256) and a Python port must each give, field for field, the record Owl Academy’s own growBiochain gives, on C0’s 148 shards and 20 synthetic shards; Owl’s and BioChain-AI’s verifyIntegrity must accept every record; and the derived layers (the V0 id stream and its SHA-256, addrTableRoot) and the LPREP/1 strings must be identical in Python and JS. The id stream there is the function L1 has just compared (the records in Explainer 4).
  2. L9 · The corpus manifest and the exact weave. LCORPUS/1 as an RFC 6962 tree over the shards, with inclusion proofs, consistency proofs (LGROW/1 append-only) and every registered alteration detected; each shard’s exact norm-5 weave (the manifest, the weave).
  3. L10 · The hardened, attested import. In JS (WebCrypto) and Python, 50 clean attested records accepted and 450 tampered ones in nine classes rejected, naming the failing check, with identical verdicts in both languages (verification).
  4. L11 · Verification is cheap enough. A full C0 shard verified with every hardened check in a median of at most 250 ms in Node, single-threaded, on this container.
What Phase 3 found

Amendment 7 fixed the definitions before any code. The chain section of lexicon_core.js and its Python port in reference/lexicon/ were then built (a container restart cut the first build off; the work on disk was kept and committed, b822237), reviewed and dry-run, and Amendment 8 was written before the decisive run. Parity first: tests/parity-lexicon.cjs, now with the chain trace, passed 19,991 of 19,991 lines. Then one decisive run, on the code committed at 6da04be, 50 min 44 s long. L8 is supported for the JS grower and the Python port: 0 of 336 records differ from Owl Academy’s own growBiochain in any of the fifteen fields, and the V0 id stream that L1 compared is identical in Python and JS on every shard. L9 is supported: every root and proof is equal in JS and Python, every alteration is detected, and all 148 exact weaves are exact. L10 is supported: 0 false accepts and 0 false rejects of 500 attested packages in each language, with identical verdicts. L11 is supported: a median 155.4 ms per full C0 shard, 95% interval [154.2, 156.0], against the 250 ms bar, on packages grown with engrams off, a reading Amendment 8 fixed after dry runs had put the engrams-on median at 243.5–265.5 ms (in the decisive run, engrams-on packages took 243.6 ms, reported). Every control showed its weakness, L11’s as Amendment 8 replaced it.

Then Phase 4 decided L6 and L4(c) (learned embeddings, with L6’s protocol as Amendment 6 attributes it), all supported, L6(c) against its registered prediction (Explainer 12), and Phase 5 brings the 2D and 3D pages (the roadmap).