Contents
The pages
Phase 5 built the two pages the design promised (Explainer 3). Both run lexicon_core.js and the shared cores unchanged, read WordNet from script files rather than by fetch, so they open from file:// as well as over http, and check those files against the decisive runs’ records as they load. They show machinery the claims decided; they decide no claim.
The Lexicon in the Disk · 2D
Type a sentence and see its tokens, their V0 ids, their addresses and their exact points in the H² tree, drawn in the Poincaré disk through an exact chart. Click a point to decode it exactly; a precision panel shows the bits; paths through the lowest common ancestor are drawn; one of L6’s learned mammal tables can be drawn beside the exact tree.
The Lexicon in the Ball · 3D
Segments A and B as a BERT-style pair, each token at its exact point in the H³ tree in the Poincaré ball, with the frame of its quaternion. One address read three ways: the word, the exact point and its decoding, and the X(5, q) vertex (L7). Engram Mind’s Eye’s coupler binds A and B, as an integrity check only.
Both pages share a shard panel, which grows, signs and verifies a language shard with the core’s chain section as Explainer 11’s lab does, and an Engram Mind’s Eye session import. The manuals, The 2D Page Manual and The 3D Page Manual, explain every panel and how the pages are tested.
The six answers
The questions were: what have we made; what would SHD-CCP integration look like; how would a hyperbolic BERT work for our 2D and 3D systems; what are the alternatives; could language pre-processing data grow as SHD-CCP biochains; and which benchmarks would help. Each answer has its own explainer.
1 · What we built is exact geometry, not language learning
Exact quaternion addresses, an exact H³ tree to depth 28, hyperboloid tools, Merkle chains, the fence and a parity method. Before this system, no tokenizer, vocabulary, embeddings, encoder or language benchmark existed in any of the four repositories. engram/1 keeps only letter-count parity, so it cannot be a token id (L2: 52.6% of WordNet’s lemma types share a key); PolyStep cannot train an encoder.
2 · SHD-CCP: three layers, one bridge
A specification repository, the working Blackwell word and shdccp/2 stream, and prose that was never built. At least eight 64-bit layouts and no free Form ID. Integration: the Blackwell word only at the bridge, record kinds above it, golden vectors, proposals. Our tree is the LPS p = 5 tree that SHD-CCP’s planned X(5, q) overlay is a quotient of.
3 · A hyperbolic BERT, in two stages
Stage 1 is exact: pinned Unicode, WordPiece, a training-free address per WordNet synset, exact points in H³ and a new exact H² tree, exact ranking. Stage 2 is the best-supported route: a Euclidean encoder with the address as a hierarchy factor and a hyperbolic head. H² and H³ are factors, heads and views; Phase 5 built the views, the 2D and 3D pages.
4 · Every alternative has a role
Main routes, baselines, controls built to fail, later work and rejected ideas, each graded by its evidence. Fully hyperbolic encoders need a GPU; hyperbolic tokenization is an open gap; gradient-free training is for small heads; a Euclidean control at matched dimension is mandatory. Phase 4 ran that control for static embeddings: on the mammal closure, learned Lorentz beats learned Euclidean at d = 2 and 3 (closure MAP 0.88–0.97 against 0.16–0.23), and Euclidean is ahead at d = 50 (L6). Stage 2 ran it on WordNet’s 75,850 direct noun edges: Lorentz is ahead at d = 2 and 3 on HiT’s held-out multi-hop pairs and on HyperLex (L14).
5 · Language biochains: yes, as shards under a manifest
A biochain’s whole lineage is capped at 60 KB, so corpora become many unmodified shdccp/2 shards tied by an RFC 6962 manifest, with typed records, two privacy tiers and a hardened, attested importer that closes what verifyIntegrity misses. Phase 3 built it: 0 of 336 shard records differ from Owl Academy’s own (L8), and the verifier rejects all 450 registered tampers, four classes of which Owl’s verifyIntegrity accepts (L10).
6 · A benchmark ladder across three tracks
Stage 0 determinism and the tokenizer; Stage 1 WordNet hierarchy (here, decided in Phases 1–4); Stage 2 lexical semantics (here, L12–L15, registered by Amendment 13 and decided in one run); Stage 3 BabyLM and BLiMP; Stage 4 GLUE and MTEB (GPU). Browser, CPU and GPU tracks share one tokenizer record, data roots, seeds and metric code.
What this is
A new system, built the way Engram Mind’s Eye and Hyperbolic Oracles were: an analysis, measurement spikes, claims registered before any code that tests them, a Python reference, a browser core checked line for line against it, and pages that show the result.
Stage 1, the front end, takes text to exact, certified geometry. A pinned normaliser and WordPiece tokenizer give token ids. A training-free rule gives every WordNet noun synset a reduced word of the norm-5 quaternion tree as its address: ancestry becomes prefix order, and each word is an exact integer quaternion that right division unfolds. Each address becomes an exact point in H³ (Hyperbolic Oracles’ octahedral tree) and in H² (a new exact tree), and candidates are ranked by exact Lorentz products. Learned float64 embeddings, Lorentz against Euclidean at matched dimension, are snapped for certified storage. Corpus shards grow as unmodified SHD-CCP biochains under a new manifest.
Stage 2, the encoder, starts only after every Stage-1 claim is decided and reviewed: a small Euclidean BERT-style encoder that takes the address as a hierarchy factor, with a hyperbolic hierarchy head, on CPU at 1–10M parameters and then on a GPU.
Hyperbolic Oracles’ claim C1, “hyperbolic beats flat” for PolyStep optimisation, was refuted (0 supported, 12 refuted, 1 inconclusive of 13 cells). The literature finds clear gains from hyperbolic geometry on explicit hierarchies and modest or no gains on general language tasks. This system therefore bets on representation (trees in low dimension, where volume growth favours curvature) and on certification (exactness, invertibility, identical results in Python, Node and the browser), not on optimisation. Every hyperbolic claim has a matched Euclidean control, and encoder-level gains are predicted small or null at this scale.
What it stands on
Every core is loaded unchanged, by relative path, in Node and in the pages. Nothing here re-implements them.
| System | What the Lexicon uses |
|---|---|
| Hyperbolic Oracles | hyperbolic_core.js: the norm-5 tree (P), exact rationals (Q), the shared generator Rng, hyperboloid tools. decoder3d.js: the exact octahedral tree in H³, pointExact, decodeExact, nearestExact, certifyWord. fence.js: dyadic snapping of learned tables. twin3d.js: a frame per token on the 3D page. In Phase 4 the reference drew every training stream from the Python twin of Rng, hpstep.prng (copied line for line into numba, and replayed against it), and snapped the Lorentz tables by the rule of hpstep.fence’s dyadic, fence.js’s Python twin. |
| Engram Mind’s Eye | biochain_v1.js: the SHD-CCP codec, verbatim from Owl Academy, on which the Phase 3 grower runs. engram_core.js: verifyBiochain, importBiochain (L8(c)), the exact chain quaternion (the exact weave of L9(b)); in Phase 5, the pages read an Engram Mind’s Eye session or export through its importer (importAny), and the 3D page binds segments A and B with its Coupler. ttmpt_core_v1.js: engram/1, kept as a compatibility checksum. |
| The orbital core | scripts/geometric-build/orbital_core.js: SHA-256 and byte helpers for the browser core and, since Phase 3, for the grower’s leaves and the records. |
| SHD-CCP, BioChain-AI, Owl Academy | Read only. Their code runs unchanged from their checkouts for compatibility tests (in Phase 3, Owl’s and BioChain-AI’s growers and verifiers at 7f45f35 and c975161, and BioChain-AI’s identity code for ATTEST/1); what we would change is written as proposals. |
System map
Every part of the system and what feeds what: sources and existing systems on the left, then mathematics, then the pipeline’s stages, then the pages, data and code. Hover a box to light up its connections; click it for what it is and where it is explained.
Solid boxes exist now: the sources (with V1, pinned in Phase 1), the existing systems and the mathematics they already provide; Phase 0’s pins, spikes, preregistration, proposals and summary; Phase 1’s Python reference; Phase 2’s browser core, lexicon_core.js; Phase 3’s shards and manifests; Phase 4’s learned embeddings; and Phase 5’s 2D and 3D pages. What both built is marked “built in Python and JS”: stages A–E (normalise, tokenize, ids, address, placement), the exact H² tree and exact ranking, which the browser core reproduces line for line, and, from Phase 3, the records, the RFC 6962 manifest and the exact weave; Phase 4 added LBENCH/1, written by the reference, whose MAP hashes the core reproduces. Stage F, the learned embeddings, is “built in the Python reference”: the trainer runs only there, and the browser core re-ranks its snapped tables exactly, reported. Stage 2 added two boxes: the pinned lexical sets (HyperLex, the hypernymy suite, HiT, SimLex, MEN, WordSim-353, GloVe), and the lexical claims L12–L15 with their record and the Node re-evaluation (lexicon_stage2.js). The X(5, q) overlay was built in the reference and, in Phase 5, for display in the page engine, checked against the pages trace. Dashed boxes are designed or planned: stages G and H, and the ladder. A box turns solid when its phase ships.
Explainer library
One full explainer per topic. Each opens with its place on the map.
1 · What we have made, measured
Engram Mind’s Eye, Hyperbolic Oracles and the orbital core judged for language: what each gives, what is missing, engram/1’s limits, PolyStep’s, exact against float precision, and a live lab with one word’s key, address and exact point.
2 · SHD-CCP: three layers, eight layouts, one bridge
What SHD-CCP is in practice, the eight 64-bit layouts with a live decoder, Form exhaustion, the layout at each boundary, LPS p = 5 and X(5, q), the JS/Python divergences, golden vectors and the proposals.
3 · A hyperbolic BERT front end in H² and H³
Stages A–H, exact and float marked; the address rule and its virtual letters; the exact H³ and new exact H² trees; exact ranking; “The cat sat.” followed through; the encoder; and a live lab placing a toy hierarchy exactly in the disk and the ball.
4 · Growing language biochains
The 60 KB lineage cap, shards and records, the RFC 6962 manifest, the exact weave, two tiers, the hardened import and its costs, and a live lab that grows and verifies a shard in your browser.
5 · The alternatives, each with a role
Main routes, baselines, controls, later work and rejected ideas, each with its model of hyperbolic space, its evidence and grade, and its cost.
6 · Three compute tracks
Browser, CPU and GPU: what each builds and runs, the rules that make them comparable, where each stage can run given this environment, and receipts.
7 · The benchmark ladder
Stages 0–4 with datasets, metric definitions, graded baselines, controls and licences, and what runs here, what needs a wider network and what needs a GPU.
8 · Spikes and claims
How Phase 0 was ordered, the pins, each spike’s question, method, output and what it settled, and the registered claims, L1–L11 and, since Stage 2, L12–L15, with their rules and predictions.
9 · The Python reference and its results
What Phase 1 built and how it was checked: the normaliser on a pinned Unicode table, WordPiece with V0 and V1, the address rule and id codec, exact points in H³ and H², exact ranking, the flat arms and X(5, q); the two reviews and Amendment 2; and the one decisive run that supported L2, L5, L7 and L3’s Python side.
10 · The browser core and its parity
What Phase 2 built and how it was checked: lexicon_core.js on the shared cores unchanged, the pinned data as script files, every Phase 1 trace line reproduced in Node, the Node and Chromium runners, the review and Amendments 4 and 5; and the one decisive run that supported L1, L3(f) and L4(a, b).
11 · Language biochains, measured
What Phase 3 built and how it was checked: the synchronous grower in JS and Python, the records, the RFC 6962 corpus manifest, the exact weave and the hardened, ATTEST/1-signed verifier; the review and Amendments 7 and 8; and the one decisive run that supported L8, L9, L10 and L11, with what Amendment 8 changed before it.
12 · Learned geometry, measured
What Phase 4 built and how it was checked: the numpy float64 trainer, Lorentz against Euclidean at matched dimension, snapping to 2−32 and exact ranking, tuning and the frozen rates; the review and Amendments 10–12; the one decisive run that supported L6 and L4(c), L6(c) against its registered prediction; and the Node re-evaluation.
13 · The 2D page manual
Every panel of lexicon-2d.html: a sentence stage by stage, the named tree around a centre drawn through an exact chart, click to decode, the precision panel, paths through the lowest common ancestor, L6’s learned mammals, the shard and Engram panels, the data and its checks, how the page is tested, and what it is not.
14 · The 3D page manual
Every panel of lexicon-3d.html: segments A and B as a pair, the H³ tree in the Poincaré ball, a frame per token from its quaternion, one address read three ways (word, exact point, X(5, q) vertex), the coupler as an integrity check, and how the page is tested.
15 · The lexical claims, decided
What Stage 2 built and how it was checked: the pinned lexical sets, the is-a score G read with the maximum over senses, blind two-pass scoring, the certified order and its tie classes, word-level intervals, L14’s trainer on WordNet’s direct edges; Amendments 13–15, the dry run and its sealed values, tuning and the frozen rates; the one decisive run that decided L12–L15, with its two refuted parts; the independent check and the Node re-evaluation.
Proposals to other repositories
The SHD-CCP layout census, RFC 03 and LPS, a Lemma 15 note, kernel 0xA (passing the Ontology’s own lint), golden vectors, language biochains for BioChain-AI, and notes for Owl Academy. Never applied.
The analysis on one page
The six answers, the pipeline, 2D against 3D, the biochain design, the ladder, the claims and the roadmap in one self-contained page.
Roadmap
Nine phases, and Stage 2’s lexical claims between Phase 5 and the gate. Each ends with its code, its explainer, its nodes on the map moved from dashed to solid, its claims decided, and its tests passing. The encoder waits behind the Stage-1 gate.
| Phase | Delivers | Decides | Status |
|---|---|---|---|
| 0 · Analysis | The survey and design written up as eight explainers; the WordNet and UD EWT pins; spikes S1–S7 with captured outputs; PREREGISTRATION.md (L1–L11, D1–D12) committed alone, after the spikes and before any code; proposals for SHD-CCP, BioChain-AI and Owl Academy; this hub and the summary | — | done |
| 1 · Python reference | N_B on a pinned Unicode 15.1 table, WordPiece with V0 “lex0” (frozen) and V1 (pinned), L1’s instance loaders, WordNet, the address rule and id codec, exact H³ and H² points, exact ranking, the flat arms, the LPS overlay, traces for the browser core (reference/); Amendment 1 before any code; two adversarial reviews and their fixes; a dry run; Amendment 2; one decisive run (results) | L2, L3 (Python), L5, L7: all supported | done |
| 2 · Browser core | Amendment 4 before any code; lexicon_core.js on the shared cores unchanged, reproducing every line of the reference’s traces in Node; the pinned table and V0 as script files (data/); the reference’s half of L1 and L4 (run_claims.py --phase2) and the Node and Chromium runner (run_claims_js.cjs, through tests/l1-harness.html); an adversarial review and its fixes; a dry run; Amendment 5; one decisive run (results) | L1, L3(f), L4(a, b): all supported | done |
| 3 · Records and biochains | Amendment 7 before any code; the chain section of lexicon_core.js and its Python twin (chain.py, records.py, manifest.py, attest.py, verify.py): the synchronous grower, the records LVOCAB/1 to LGROW/1, the RFC 6962 manifest, the exact weave and the hardened, ATTEST/1-signed verifier; the chain trace, which the core reproduces (parity 19,991 lines); the normaliser spec and the Owl/BioChain-AI compatibility pin; the runner (run_claims_phase3.cjs with run_claims_phase3.py); an adversarial review; dry runs; Amendment 8; one decisive run (results). The SHDGEV01 golden-vector suites of the SHD-CCP proposal were not written; they decide no claim and are carried over | L8, L9, L10, L11: all supported | done |
| 4 · Learned embeddings | Amendment 10 before any code; the numpy float64 trainer (embed.py, its stream a numba copy of the shared Rng in stream.py), the exact evaluator of tables snapped to 2−32 (learned.py), the decisions (l6.py) and the runner (run_claims_phase4.py); the core’s exact ranking of snapped tables (SnapArm, evaluateSnapped) with the L6 trace (parity 22,586 lines); an adversarial review and its fixes; the dry run on the solid.n.01 closure set; registered tuning (240 runs); Amendment 11, the rates frozen; one decisive run (results); Amendment 12, an erratum; the Node re-evaluation of the measured tables (reported). The Stage-2 lexical claims the plan put here (HyperLex, the hypernymy suite, SimLex and the rest) were not registered in Phase 4; Amendment 13 registered them after Phase 5, as L12–L15 (Stage 2, below) | L6, L4(c): all supported, L6(c) against its prediction | done |
| 5 · The 2D and 3D pages | lexicon-2d.html (the exact H² tree in the Poincaré disk: a sentence’s tokens, addresses and points, exact decoding, the bits, paths through the lowest common ancestor) and lexicon-3d.html (the exact H³ tree in the ball: a frame per token from its quaternion, the X(5, q) vertex of each address, segments A and B bound by the coupler as an integrity check only); a shard panel and an Engram Mind’s Eye session import shared by both; the page engine assets/hl-pages.js on the core unchanged, with the pages’ WordNet data as script files and a trace from the reference (traces_pages.py); manuals 13 and 14; the engine checked in Node and both pages in Chromium at 1440, 1024 and 390 px | — | done |
| Stage 2 · Lexical semantics | Amendment 13 before any code: L12–L15, their definitions and the order of work; the pins of HyperLex, the hypernymy suite (BLESS, WBLESS), HiT’s WordNet multi-hop split, SimLex-999, MEN, WordSim-353 and GloVe 6B (hashes only); the modules stage2data.py, senses.py, wngraph.py, scores2.py, stats2.py, hit.py and glove.py, the trainer’s additions for WordNet’s direct edges and the runner run_claims_stage2.py (blind two-pass scoring, the decision wiring checked against Amendment 13’s text); an adversarial review; the dry run on WordNet’s verbs, its values on human-rated sets sealed; Amendment 14, the definitions after the dry run; registered tuning on HiT val (48 runs); Amendment 15, the rates frozen; one decisive run (results); the write-up: Explainer 15, an independent check of the record, the dry runs’ sealed files opened, and the Node re-evaluation (lexicon_stage2.js, beside lexicon_core.js, which stays unedited) | L12(a)–(c), L13, L14, L15(b) supported; L12(d), L15(a) refuted, as predicted | done |
| Stage-1 gate | A review with you of L1–L15, the results and what Phases 1–5 and Stage 2 built, before any encoder code is written | — | next |
| 6 · CPU encoder | 1–10M parameters; claims L16–L19 (the address factor on BLiMP, hierarchy heads on HiT-protocol F1, the Poincaré probe against the structural probe, PolyStep against MeZO and ZO-SGD; Amendment 13 item 18 gave them these numbers, since L12–L15 went to Stage 2) registered by amendment first; BabyLM strict-small (osf.io’s file downloads are blocked here; BabyLM is also on Hugging Face) | by amendment | planned |
| 7 · GPU track | BERT-mini/small with the factor and controls; BabyLM 100M; GLUE; HiT on MiniLM; an exploratory fully Lorentz arm; receipts verified here | by amendment | your GPU |
| 8 · Integration | engram/2 registered in Engram Mind’s Eye; proposals delivered; site and map updated | — | planned |
Claims ledger
Fifteen claims, registered in PREREGISTRATION.md before any code that tests them: L1–L11 in Phase 0, L12–L15 by Amendment 13 at the start of Stage 2. Each phase decides its claims in one run of runners committed beforehand: Phases 1 and 2 on 2026-11-05, Phases 3 and 4 on 2026-11-06, Stage 2 on 2026-11-08. Phase 1 supported L2, L5 and L7, and L3 on its Python side, parts (a)–(e) and (g). Phase 2 supported L1, L3(f), Python against JavaScript, which completes L3, and L4(a) and (b). Phase 3 supported L8 (for the JS grower and for the Python port), L9, L10 and L11; L11 on packages grown with engrams off, a reading Amendment 8 fixed before the run but after dry runs had put the engrams-on median near the bar. Phase 4 supported L6, all four parts, and L4(c), which completes L4. So L1–L11 are all supported, each in full. Three of their predictions were wrong, and they stay on record: L2’s band, L11’s band, and L6(c), predicted refuted and found supported. Stage 2 decided L12–L15 part by part: L12(a)–(c), L13(a)–(c), L14(a) and (b) and L15(b) supported, L12(d) and L15(a) refuted. Every part came out as its registered prediction said; some graded details did not, and they are on record too (below). Each claim has controls that must fail, a decision rule fixed in advance, and a prediction. Explainer 8 summarises them; Explainer 9, Explainer 10, Explainer 11, Explainer 12 and Explainer 15 report the runs. Tags: SUPPORTED and REFUTED by the registered decision rule.
| # | Claim | Prediction | Decided in | Status | Result |
|---|---|---|---|---|---|
| L1 | The front end (normaliser, WordPiece, ids, offsets) is byte-identical in Python, Node and Chromium | supported | Phase 2 | SUPPORTED | 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. Control 1, the platform’s own Unicode functions, differs on 725 of 20,520 stress cases in both runtimes; controls 2 and 3 fail too |
| L2 | engram/1 cannot be a token id: at least 1% of WordNet’s lemma types share their key | supported (2–10%) | Phase 1 | SUPPORTED | 52.6% of 147,305 types share a key (77,520); the SHA-256-prefix control has 0 collisions. The predicted 2–10% band was wrong |
| L3 | Every noun synset has an exact, invertible, certified address and exact points in H³ and H² | supported | Phases 1–2 | SUPPORTED | (a)–(e) and (g), Phase 1: 0 failures on all 82,115 nouns; all four controls fail. (f), Phase 2: Node’s canonical point list equals Python’s (SHA-256 eb22bf00…), and 2,000 of 2,000 sampled lines are equal |
| L4 | Exact ranking is identical across engines; float64 is not certifiable at WordNet depth; snapped tables rank within 0.001 MAP | supported | Phases 2, 4 | SUPPORTED | (a): every rank list, exact MAP and mean rank equal in Python and Node, 1,176 mammal and 200 noun queries, in H³ and H². (b): float64 inverts an exactly ordered adjacent pair in 997 of 1,000 noun queries (H³ 990, H² 993); both controls fail. (c), Phase 4: over L6’s 40 learned and edge-shuffled tables at d = 2 and 3, the largest |MAP(snapped to 2−32, exact) − MAP(float64)| is 9.37×10−6 (bar 0.001); largest snap displacement 1.565×10−3. Reported: a coarse 2−8 snap moves the Lorentz tables’ closure MAP by 0.40–0.60 |
| L5 | At d = 2 and 3 the exact hyperbolic tree beats the same construction at curvature 0 | supported | Phase 1 | SUPPORTED | All four intervals above 0 on both sets; the smallest, H³ − F3* on mammals, 0.049 [0.042, 0.055]. Noun graph-edge MAP: H³ 0.568, F3* 0.500, F3 0.007 |
| L6 | Learned Lorentz beats learned Euclidean at d = 2, 3, not at d = 50; the exact tree against learned Lorentz | (a, b, d) supported; (c) refuted by S3’s rule | Phase 4 | SUPPORTED | Mammal closure set, five seeds, rates frozen by Amendment 11. (a): Lorentz − Euclidean closure AP, every interval above 0 at d = 2 (means +0.716 to +0.752) and d = 3 (+0.728 to +0.752); closure MAP 0.88–0.91 against 0.16–0.17 (d = 2) and 0.95–0.97 against 0.22–0.23 (d = 3), so the predicted gap of at least 0.2 holds (0.726 and 0.742). (b): at d = 50 Euclidean is ahead, 0.99997 against 0.968, every interval entirely below 0 (about −0.032), which the rule counts as support. (c): exact H³ graph-edge MAP 0.690653 against learned Lorentz d = 3 0.458–0.477; every (exact − learned) interval’s lower end is at least 0.19. The prediction, refuted, was wrong (below). (d): learned Lorentz d = 3 closure MAP 0.950–0.971 against the exact tree’s 0.305408; lower ends at least 0.63. Controls 1 and 2 hold; L6 is not void |
| L7 | Address, H³ point and X(5, q) vertex are one tree read three ways (SHD-CCP RFC 03) | supported | Phase 1 | SUPPORTED | (a)–(e) hold for q = 13, 17, 29; Ramanujan margins 0.2224, 0.1632, 0.0301; SHD-CCP’s Hurwitz product, halved, equals the word quaternion |
| L8 | Language shards are Owl-valid biochains, field for field, in JS and Python | supported | Phase 3 | SUPPORTED | For the JS grower and the Python port: 0 of 336 records (148 C0 and 20 synthetic shards, engrams off and on) differ from Owl Academy’s own growBiochain in any of the fifteen fields; BioChain-AI’s grower gives the same; Owl’s and BioChain-AI’s verifyIntegrity accept every record; Engram’s importBiochain recreates every text byte for byte; the derived layers and the LPREP/1 strings are identical in Python and JS. Controls 1–3 show their weakness |
| L9 | The RFC 6962 manifest, its append-only growth, and the exact weave | supported | Phase 3 | SUPPORTED | The manifest over the 148 LPREP/1 hashes (root f567700d…) and eight synthetic lists, K = 1 to 1,001: every root and proof equal in JS and Python, every alteration detected, every wrong proof rejected. All 148 exact weaves exact (norm 528K, unfolding, 7 segment products). Controls: the shdccp/2 rule collides at K = 3, 7 and 1,001; an XOR summary misses swaps the weave detects |
| L10 | The hardened importer accepts every clean attested shard and rejects every registered tamper, identically in JS and Python | supported | Phase 3 | SUPPORTED | 50 clean and 450 tampered attested packages (T1–T9): 0 false accepts and 0 false rejects in JS and in Python, every verdict identical. Owl’s verifyIntegrity accepts 50 of 50 of each of T1, T2, T8 and T9; Python without the P1363-to-DER conversion accepts 0 of 126 valid signatures |
| L11 | A full shard verifies with every hardened check in a median of at most 250 ms | supported (50–150 ms) | Phase 3 | SUPPORTED | 147 full C0 shards, packages grown with engrams off: median 155.4 ms, 95% interval [154.2, 156.0], just above the predicted band; the step check holds 441/441. Amendment 8 fixed engrams off, and replaced the median-comparison control with that step check, after dry runs had put the engrams-on median at 243.5–265.5 ms and shown that the comparison could not resolve a 0.7–0.8 ms step. Reported: engrams on, 243.6 ms [240.2, 246.7] |
| L12 | On HyperLex’s nouns, the exact trees track graded type-of better than the same construction at curvature 0, through ancestry (b) and direction (c), and H³ as well as WordNet’s own graph (d) | (a)–(c) supported; (d) refuted, low side | Stage 2 | (a)–(c) SUPPORTED (d) REFUTED | 2,163 noun pairs, Spearman ρ by the is-a score G with the maximum over senses. (a): H³ 0.625 and H² 0.621 against F3 0.173, F3* 0.217, F2 0.055, F2* 0.211; every H − F interval above 0, the smallest +0.408 [+0.317, +0.503]. (b): G beats the depth gap, H³ +0.174 [+0.062, +0.293]. (c): G beats the symmetric score, H³ +0.399 [+0.309, +0.488]. (d): WordNet’s own graph scores 0.786; H³ − WN is −0.161 [−0.221, −0.112], entirely below the band ±0.02. (d) is flagged as registered after a partial preview (A13.20). Controls 1–4 fail as required |
| L13 | On BLESS and WBLESS, the exact trees detect hypernymy (a, b) and its direction (c) better than the same construction at curvature 0 | supported | Stage 2 | SUPPORTED | (a) BLESS test, 12,365 rows: AP H³ 0.789, H² 0.801, against 0.092–0.137 for the flat arms. (b) WBLESS test, 1,493 rows: 0.970 and 0.971 against 0.516–0.569. (c) Direction: H³ 1,170 of 1,194 pairs (0.980), H² 1,174 of 1,194 (0.983), against 0.438–0.628. All twelve H − F intervals above 0, the smallest lower end +0.304. Controls 1–3 fail as required; symmetric scores give a direction accuracy of exactly 0 |
| L14 | Trained on WordNet’s 75,850 direct noun edges, learned Lorentz beats learned Euclidean at d = 2 and 3 on HiT’s multi-hop test (a) and on HyperLex’s nouns (b) | supported (a larger gap in (a) than in (b)) | Stage 2 | SUPPORTED | Five seeds, rate 10 frozen by Amendment 15. (a) 29,383 test rows, per-row reciprocal rank: supported in all four (d, setting) cells, every seed’s interval above 0; mean RR with hard negatives, Lorentz 0.711–0.812 against Euclidean 0.318–0.366. (b) ρ on 2,153 HyperLex nouns: Lorentz 0.475–0.507 against Euclidean 0.112–0.265, every interval above 0. Controls 1–4 fail as required and the closure check passes. The predicted larger gap in (a) holds with hard negatives only |
| L15 | (a) At matched information, curvature 0 does as well as the exact trees on similarity (SimLex) and relatedness (MEN); (b) GloVe beats H³ on relatedness, and H³ beats GloVe on HyperLex | (a) refuted; (b) supported | Stage 2 | (a) REFUTED (b) SUPPORTED | (a) By the symmetric score: SimLex nouns H³ 0.589 against flat 0.191–0.363; MEN H³ 0.395 against 0.122–0.302. All eight hyperbolic gains have lower ends above the +0.02 bar, the smallest +0.034, so flat does not do as well. (b) GloVe − H³: MEN +0.366 [+0.276, +0.456], WordSim relatedness +0.585 [+0.285, +0.858]; H³ − GloVe on HyperLex +0.110 [+0.024, +0.193]. Controls 1–3 fail as required |
Phase 1 results
The order of work, one commit each: Amendment 1 fixed the open definitions before any code (29efe8a); the text track, with its pins (d50a43f); the geometry track and the claims runner, after its dry run (e51a866); fixes from two adversarial reviews, which reimplemented the reference independently on unregistered data with four reviewers per track and two skeptics per finding (8d845c7, 20c3320); Amendment 2 (88e63f7); then one decisive run of run_claims.py on that code, 5 minutes long (6af2a83). Every control failed, as required: a control that passes voids its claim. Every number below is in reference/results/claims.json.
| Claim | Measured | Controls (each must fail) |
|---|---|---|
| L2 | 147,306 lemma types, 147,305 after N_B. 77,520 of them (52.6%, exactly 912/1733) sit in a key class of size ≥ 2: 92,978 classes, 23,193 of size ≥ 2. The largest, 371 types, is the zero key, which holds all 131 all-digit types. 6,666 anagram classes. Reported: 52.2% of V0’s entries share a key | A SHA-256-prefix key: 0 collisions. Python’s and Node’s key tables are identical (SHA-256 fb871ccd…) |
| L3 | 82,115 noun synsets: 0 failures in each of (a)–(e) and (g). Words up to 36 letters, mean 18.37; 90.88% fit id59 (≤ 25 letters), 95.66% id64 (≤ 27). At most 184-bit numerators over 102-bit denominators per coordinate in H³, 252 over 142 in H². The canonical point list (SHA-256 eb22bf00…) and 2,000 sampled lines were kept for part (f), which Phase 2 decided (below) | Zero-letter rule: 11,978 nodes share a word. Truncation: 74,220. Float placement and decoding fail on 67,989 of the 71,454 words longer than 12 letters. H² at t = 3/4 fails exact decoding on 19,796 |
| L5 | Graph-edge MAP, mammals (1,176 nodes, every one a query): H³ 0.691, H² 0.719, F3 0.110, F2 0.042, F3* 0.642, F2* 0.408. Nouns (1,000 queries against 82,115): 0.568, 0.590, 0.007, 0.002, 0.500, 0.319. Intervals (paired AP, 95%), nouns: H³ − F3 0.561 [0.538, 0.584], H³ − F3* 0.068 [0.062, 0.074], H² − F2 0.588 [0.565, 0.611], H² − F2* 0.271 [0.257, 0.286] | Shuffled words (S3) score 0.019 and 0.0005, a content hash (K3) 0.007 and 0.0001; the H³ − S3 and H³ − K3 intervals lie far above 0 on both sets |
| L7 | q = 13, 17, 29: 2,184, 4,896 and 12,180 vertices, bipartite for 13 and 17; girths 8, 8, 9, so r = 3, 3, 4, and 187, 187 and 937 short words land on distinct vertices. Walk equals reduction on 10,000 random words and the 1,182 mammal addresses. Largest nontrivial |λ|: 4.2497, 4.3089, 4.4420 (2√5 = 4.4721). The 82,115 noun addresses reach every vertex for q = 13 and 17, and 12,167 of 12,180 for q = 29 | ι = 2 breaks the walk on 10,867 to 10,879 words per q; a 4-generator subset is not 6-regular; the doubled-coordinate product, not divided by 2L, differs on all 2,182 words tested |
L2’s predicted band was wrong. The registration predicted a share of 2–10%, from anagrams, words whose every letter appears an even number of times, and numerals. Keeping only the parity of each letter’s count merges far more than that: 52.6% of the types share a key. The decision needs at least 1%, so the miss does not change it.
L5 in context. The noun graph-edge MAP of the exact tree, 0.590 in H² and 0.568 in H³, falls short of Sala et al.’s 2-d combinatorial 0.989, as registered; the expected cause, virtual letters that put siblings as close as parents, was measured on verbs (spike S3), not on the nouns. Closure MAP is much lower (nouns: H³ 0.158, H² 0.157). The margin over F3* is small, 0.068 on nouns and 0.049 on mammals, but its interval lies clearly above 0. H² scores slightly above H³ on graph-edge MAP on both sets.
Amendment 2 recorded, before the decisive run, a disclosure: while the geometry modules were being written, a builder’s timing script ran L3’s certify and prefix checks over all the noun words; its outcome was not looked at and nothing was changed after it, and the decisive run recomputed both. It also recorded an erratum: google-research/bert drops only the Cc and Cf categories (Hugging Face’s copy drops every C category); the rule in force, which drops Cc, Cf and Co and fails closed on Cn, is unchanged.
Phase 2 results
The order of work, one commit each: Amendment 4 fixed how the three engines are run and compared, before lexicon_core.js or any Phase 2 runner existed (cda6d9a); the browser core, the pinned data as script files, the parity test and the two runners, after their dry run and an adversarial review (three reviewers, two skeptics per finding) that found no defect in N_B, WordPiece or the geometry and confirmed three gaps, all fixed (09e282d); Amendment 5 (a1fe9a8); then one decisive run on that code, run_claims.py --phase2 in 2 min 15 s and then run_claims_js.cjs in Node and Chromium in 6 min 52 s (648a6b6). Parity came first, as Amendment 4 requires: in Node, tests/parity-lexicon.cjs passed 18,667 of 18,667 lines (the build commit reports the same total in Chromium): 18,578 reproduce the five Phase 1 traces, and 89 check the pins, the data files, UTF-8, the reference tests’ hand-checked cases, the guard and the geometry; the runner refuses to go on otherwise. The engines: Python 3.13.18 (unicodedata 15.1.0), Node 22.23.4 (ICU 78.3, Unicode 17.0) and Chromium 153.0.8010.12 through Playwright 1.63.0. Every control failed, as required. Every number below is in reference/results/claims-phase2.json (the comparisons and decisions) and phase2-python.json (the reference’s side).
| Claim | Measured | Controls (each must fail) |
|---|---|---|
| L1 | 156,801 instances per cell: (a) 117,659 WordNet glosses, (b) 16,622 UD EWT sentences, (c) 20,520 stress cases, (d) 2,000 synthetic strings. In each of the four cells (V0 and V1, in Node and in Chromium), 0 instances differ from the reference in normalised bytes, pieces, ids or offsets, and every id-stream SHA-256 is equal (16 of 16). Reported: Hugging Face tokenizers 0.23.3 agrees on every gloss and every EWT sentence for V0 and V1, and differs on 28 stress cases (V1 only) and 29 synthetic strings (V0 and V1). In the examples kept, the reference writes a word-final sigma as ς where Hugging Face writes σ, and keeps one [UNK] for a word holding a code point unassigned in Unicode 15.1 (N_B fails it closed) where Hugging Face splits out a ‘;’ or ‘>’. Fertility on (a): V0 1.217, V1 1.107 | 1. The platform’s toLowerCase, NFD and \p{Mn} removal, as spike S6 ran it, differs from the reference on 725 of 20,520 stress cases in Node and in Chromium alike (S6 measured 725): U+0897, for one, is a mark new in Unicode 16.0, which the platform removes and the 15.1 table keeps. The core’s own table pipeline equals the reference on every case. 2. Shortest-match-first WordPiece differs on 117,659 of 117,659 glosses (V0 and V1). 3. N_B without accent stripping differs on 0 glosses and 7 of 16,622 EWT sentences |
| L3(f) | Node built the 82,115 noun words with lexicon_core.js’s address rule, the H³ points with decoder3d.js pointExact (t = 3/4) and the H² points with the core’s exact tree (t = 11/13). Its canonical point list (29,442,565 bytes) has Python’s SHA-256, eb22bf00689ec86d…, and all 2,000 sampled lines equal results/l3f-python.txt; 0.933 ms per node for both points | L3’s four controls, inherited from Phase 1, where all four failed (Amendment 5). Reported: one digit changed in one Node line makes exactly that line differ, a check of the comparison itself |
| L4(a) | Mammals (1,176 queries, each against the other 1,175) and noun queries 0–199 (each against the other 82,114), in H³ and H²: 0 differing rank lists, and the graph-edge and closure MAP and mean rank equal as exact rationals in Python and Node. Graph-edge MAP, mammals: 0.690653 (H³), 0.718723 (H²); nouns 0–199: 0.553253, 0.572214. Closure MAP: 0.305932, 0.306331, 0.138801, 0.138116. Chromium gives the same on the mammals (reported) | 2. Of the 488 mammal queries in H³ with an exact neighbour/non-neighbour tie, a float evaluator that sorts by acosh and breaks ties by node index gives a different AP on 487, in Python and in Node. Had it passed, it would have voided (a) and (b) (Amendment 5) |
| L4(b) | Each coordinate rounded to float64, the Lorentz key computed left to right: in 997 of the 1,000 noun queries an exactly ordered adjacent pair inverts, in H³ (990 queries; 4,978,009 inversions; 152,072 float ties of strictly ordered pairs) or in H² (993; 8,969,341; 1,715). In both trees the first inversion is in query 0’s first pair, and its deeper word has 25 letters. Decided by the reference; Node gives the same counts, query by query | 1. Float32 on the mammals in H³ inverts in 1,137 of 1,176 queries (902,886 keys are not finite), in Python and in Node. 2. As for (a): 487 of 488 tied queries |
What it shows. On the registered instances, the browser core gives the reference’s bytes exactly, for both vocabularies, in Node 22 and in Chromium 153, although both runtimes carry Unicode 17.0 and the reference 15.1: the pinned table decides, not the platform, and control 1 shows that the platform’s own functions would have differed on 725 stress cases. The JavaScript geometry gives Python’s words and exact points for every noun, and Python’s exact rankings. Float64 ranking of the same exact points is not certifiable at WordNet depth: it inverts an exact order in 997 of 1,000 noun queries, which is why every MAP and mean rank here is computed exactly. Every registered prediction for these parts held.
What it does not show. L1 holds for these four instance lists, two vocabularies, one Node release and one Chromium build, on one Linux machine; Firefox, Safari, other builds and other platforms were not run. L3(f) and the noun part of L4(a) ran in Node only, as registered; Chromium ran L4(a) on the mammals, reported. Hugging Face’s agreement is reported, not decided, and its examples show rules of N_B (the Final_Sigma context, failing closed) that Hugging Face does not apply. L4(b) concerns float64 copies of exact tree points: it says nothing about learned embeddings, which L4(c) and L6 test in Phase 4, or about any language model.
On the record. Amendment 5 disclosed, before the run, that the text builder timed N_B and WordPiece over instance (a) in Node and the geometry builder built every noun word and point in Node, both for times only, with nothing compared; the comparisons made while building and reviewing used the Phase 1 traces, the registered dry sets and seeds 70000 + i. The results’ headers read “PREREGISTRATION.md with Amendments 1-4”, the runners’ fixed label; both record HEAD a1fe9a8, which includes Amendment 5, and flag uncommitted changes in the folder (Explainer 10, chapter 2, says what that can and cannot mean). After the run, two gaps that blocked hosts had left were closed (5e1681c): the pinned Unicode 15.1 table equals the official UCD 15.1.0 files in every field (read from unicode-org’s unicodetools on GitHub, since unicode.org is blocked here), and the 34 outside numbers whose primary source had become reachable were read in it: 28 confirmed, 5 corrected and 1 not found in its cited paper. One correction is Amendment 6 (2f89ac1, 445a2e1): L6’s registered protocol is credited to Nickel and Kiela, but its 50 negatives, batch 50 and 20 burn-in epochs come from the authors’ released script (the paper uses 10 negatives and 10 burn-in epochs), and its 1,000 epochs are in neither (the script runs 1,500); so it is this project’s own, after the paper and the script. It is unchanged; L6 had not run then, and ran on that protocol in Phase 4.
Phase 3 results
The order of work, one commit each: Amendment 7 fixed the definitions before any record, grower port, manifest, verifier or runner existed (1ad40d0); a container restart cut the first build off during its dry run, and the work on disk was saved as it stood: the chain section of lexicon_core.js, the Python port, the pins, the chain trace and the runner (b822237); the runner and verdict changes that Amendment 8 records (8c51e08); the registered dry run on that code, in which all four claims were supported, L11 at 156.2 ms with engrams off and 229.4 ms with engrams on (25b48b3); Amendment 8 (6da04be), which also records the adversarial review: three reviewers, two skeptics per finding, and one finding confirmed, L11’s control; then one decisive run of run_claims_phase3.cjs on that code, 50 min 44 s long (865791f). The runner’s gate came first: tests/parity-lexicon.cjs passed 19,991 of 19,991 lines, 1,323 of them for the new chain trace, and the Owl Academy and BioChain-AI checkouts were unchanged at 7f45f35 and c975161. The engines: Node 22.23.4, and Python 3.13.18 with cryptography 50.0.1 and numpy 2.5.3. Every control showed its weakness, as required. Every number from the decisive run below is in reference/results/claims-phase3.json; the console output is phase3-console.txt. The dry run’s numbers are in reference/results/dry/claims-phase3.json, and Amendment 8’s in PREREGISTRATION.md.
| Claim | Measured | Controls (each must fail) |
|---|---|---|
| L8 | 168 shards: the 148 of C0 (WordNet’s noun glosses) and 20 synthetic shards from Rng(1000 + i), about 30% two-byte characters, each with at least one chunk whose crystal holds 0x80; each grown with engrams off and on, so 336 records per grower. 0 records from growSync, 0 from the Python port and 0 from BioChain-AI’s grower differ from Owl Academy’s growBiochain (scripts/biomesh.js at 7f45f35) in any of the fifteen fields. Owl’s and BioChain-AI’s verifyIntegrity accept every record, and Engram’s importBiochain recreates every text byte for byte. (d): LVOCAB/1 and LADDR/1 are equal in Python and JS (addrTableRoot 30b17bc3…, 8,192 rows), and no shard’s V0 id stream or LPREP/1 string differs. Reported: the crystal holds 0x80 in 189 of C0’s 12,378 chunks (1.527%) and in 32 of the synthetic shards’ 1,175; value (origBytes over shippedBytes), median 1.095 with engrams off and 0.466 with engrams on; median ms per shard, off / on: growSync 56 / 119.1, Python 54.8 / 278.2. Owl’s and BioChain-AI’s growers ran in four worker threads, contended; with its own engram layer Owl’s took a median 9.3 s a shard (70.5 ms with engrams off), and the pool 1,837.6 s, most of the run | 1. Python’s grower with BioChain-AI’s packet normalisation (0x80 written as 0x81) differs from Owl’s record on 20 of 20 synthetic shards, in the stream. 2. A grower that hashes leaves over binary bytes differs on 168 of 168 shards, and Owl’s verifyIntegrity rejects all 168 (leaf 0 mismatch). 3. One byte altered changes the leaf and the root on 168 of 168 |
| L9 | (a) The corpus manifest, an RFC 6962 tree over the SHA-256 of C0’s 148 LPREP/1 strings (engrams off), root f567700daafc85f8…, and synthetic lists of K = 1, 2, 3, 7, 84, 200, 1,000 and 1,001 leaves from Rng(1000 + j): every root, inclusion proof and consistency proof is equal in JS and Python; every inclusion proof verifies for its own leaf and position and fails for the wrong ones; every consistency proof verifies (every prefix size for the manifest and for K ≤ 200, 2,000 drawn for K = 1,000 and 1,001); no alteration goes undetected (739 on the manifest; every one for K ≤ 200, 2,000 drawn above). Proofs hold at most 8 hashes at K = 148 and 10 at K = 1,000 and 1,001. (b) Each of the 148 C0 shards’ exact weaves has norm exactly 528K, unfolds in order to its leaf prefixes and equals the product of its 7 segment sub-weaves, with identical components in JS and Python: 971–2,731 bits per component; median 45.9 ms (JS), 51.3 ms (Python) | 1. The shdccp/2 Merkle rule gives a list and the same list with its last leaf duplicated one root at K = 3, 7 and 1,001, in JS and in Python. 2. An XOR summary of the leaf prefixes misses every adjacent swap tested, each of which the weave detects (199 of 199 at K = 200) |
| L10 | 50 clean packages (C0 shards drawn from Rng(1000 + i), 55 draws), each LPREP/1 attested in BioChain-AI’s ATTEST/1 format with a P-256 key made in WebCrypto for this run, and 50 tampered packages in each of T1–T9. JS and Python accept all 50 clean ones and reject all 450 tampered ones, naming the same failing check: T1 leaves; T2 crystal; T3 and T6 commitment; T4 (a revoked key) and T5 (another shard’s attestation) attestation; T7 leaves (48) or canonical (2); T8 weaves; T9 canonical. The two verdicts are reported apart: T4 and T5 are self-consistent and not authentic; T1, T2 and T6–T9 authentic and not self-consistent; T3 neither. T6’s 26 Tier-P twins, checked with their own salts, are all accepted. Identity 0xAE3502AC6FFBA237 by BioChain-AI’s own computeIdentityId; the registry snapshot (phase3-registry.json) holds public JWKs only. Median verification per package: 135.4 ms (JS), 131.5 ms (Python) | 1. Owl’s verifyIntegrity, run from the Owl checkout, accepts 50 of 50 of each of T1, T2, T8 and T9: the gaps only the hardened checks close. 2. Python without the P1363-to-DER conversion accepts 0 of the run’s 126 valid signatures |
| L11 | Every C0 shard of at least 59,000 bytes (147), its package grown with engrams off (Amendment 8 item 1), verified with every hardened check in Node, single-threaded, 3 repetitions, the first discarded: median 155.4 ms per shard, 95% bootstrap interval [154.2, 156.0], against the bar of 250 ms. By step (median ms): canonical encoding 78.9, derived layers 46.4, weaves 13.3, crystal 7.2, leaves 4.6, commitment 1.8, parity 1.1, attestation 0.7, inclusion 0.2, consistency 0.1. The session (LVOCAB/1, LADDR/1 recomputed from WordNet, the registry) takes 1,303.1 ms once, so 1,000 shards take about 156.7 s. Reported: the same shards’ engrams-on packages, 243.6 ms [240.2, 246.7]; LADDR/1 recomputed inside each verification (the literal reading), 1,350.2 ms; Python, 195.9 ms [192.5, 199.1] | The step check (Amendment 8 item 2): 441 of 441 timed full verifications ran and passed the attestation check inside the timed window, and 441 of 441 attestation-skipped ones recorded it as skipped; it holds. The registered comparison of the medians, reported: skipped 153.5 ms against 155.4 ms, faster; paired difference 1.9 ms [0.4, 3.0], skipped faster on 89 of 147 shards; the step itself takes 0.7 ms, against about 5.5 ms of spread in one verification |
What it shows. Language data can grow as unmodified SHD-CCP biochains. On the registered shards the Lexicon’s synchronous grower, in JS and in its Python port, writes Owl Academy’s own records field for field, including the chunks whose crystal holds 0x80, where BioChain-AI’s Python kernel normalisation parts from Owl (L8’s control 1); both projects’ verifiers and Engram’s importer accept them. Many shards can be tied under one RFC 6962 manifest whose roots and proofs are identical in both languages and whose growth is checked append-only, where the shdccp/2 Merkle rule lets a duplicated last leaf through (L9’s control 1). The hardened, attested verifier rejects every registered tamper in both languages with the same verdicts, among them four classes that Owl’s verifyIntegrity accepted in all 200 cases, and verifies a full shard, grown with engrams off (Amendment 8, below), in about 155 ms in Node, about 157 s for 1,000 shards with the session (engrams-on packages: 243.6 ms, reported). Every registered decision came out as predicted.
What it does not show. It holds for these shards (WordNet 3.0’s English noun glosses, and 20 synthetic shards for the multi-byte cases), for Owl Academy and BioChain-AI at the pinned commits, and for one Node release and one Python build on one Linux container; L11’s time is single-threaded Node on this container, not a browser or another machine. The tampers are the nine registered classes, 50 records each, not an adversary’s search, and the keys were made for the run: no real key registry, revocation service or published corpus was involved, and nothing was sent to Firestore. Tier P was exercised only through T6. LBENCH/1 waited for Phase 4. The exact weave is the Lexicon’s own record field and a proposal for shdccp/3; shdccp/2 still carries the float weave, which the grower reproduces. Nothing here bears on whether hyperbolic geometry helps a language model.
Against prediction, and on the record. L11’s median, 155.4 ms, is just above the predicted 50–150 ms; the canonical-encoding check (78.9 ms) and the derived layers (46.4 ms) take most of it. The decision needs the interval’s upper end at or below 250 ms, so the miss does not change it. Amendment 8, written after the dry runs and before the decisive run, changed three things. (1) The packages of L10 and L11 and the manifest of L9(a) are grown with engrams off, the Lexicon’s default for corpora (D4; Explainer 3); the registration did not say which. This is disclosed plainly: the runner had first read it the other way, and those dry runs put L11’s median on engrams-on packages at 243.5–265.5 ms, near the bar, against 157–182 ms with engrams off; the reading was fixed after seeing that. In the decisive run the engrams-on packages, reported, took 243.6 ms, interval [240.2, 246.7]: under the bar by 3.3 ms at the interval’s upper end, where the engrams-off packages leave 94 ms. (2) L11’s registered control, “skipped must be faster”, read as a comparison of medians, could not resolve a 0.7–0.8 ms step against 10–28 ms of noise in the dry runs: it failed by chance with correct code and passed with the skip ignored. It was replaced by the verifier’s own record of its steps; the comparison is reported. (3) The two verdicts follow Explainer 4’s Phase 0 definitions: self-consistent is steps 1–6 and 8, authentic step 7, the signature; the code as first built had counted the inclusion and consistency checks as authenticity (changed in both languages in 8c51e08). Amendment 8 also disclosed that the builders timed verb shards (dry data) and hashed C0’s texts against their pins, and that no C0 shard was grown, verified or timed before the decisive run. The results’ header reads “PREREGISTRATION.md with Amendments 1-7”, the runner’s fixed label; it records HEAD 6da04be, which includes Amendment 8, and one uncommitted path, the run’s own console file. Amendment 9, an erratum written with this write-up, records that label, two READING texts in the record that predate Amendment 8 (the decision read the step check, as item 2 says), and the dry run’s HEAD; it changes no rule and no result.
Phase 4 results
The order of work, one commit each: Amendment 10 fixed the definitions before any trainer, evaluator or runner existed, in three parts: the protocol (positives, non-neighbours, draw order, initialisation, schedule, loss and both steps), the numerics (binary64 throughout, no BLAS, the snap and the exact keys) and the statistics (the intervals and the decision mechanics); it read the registered tuning as rate k on seed block k, 240 runs, chose the solid.n.01 closure set as dry data, and recorded an omission: Phases 1 and 2 never reported the fractional-tie values the Common rules ask for (43265cf). Then the code, built on synthetic graphs and unregistered seeds (272a50d); fixes from an adversarial review, four reviewers with independent reimplementations of the trainer and the evaluator and two skeptics per finding, which found no defect in the stream, the trainer or the decisions and confirmed seven minor findings, all fixed, among them the Euclidean snap, now exactly ⌊232x + 1/2⌋ (e0477fb); the registered dry run on that code, tuning in 5,867 s (78c661d) and the measure step in 2,833 s (a780bb5), whose verdicts were all supported and whose record an independent check of about 29,700 comparisons found equal in every decision, interval and hash (77 reported diagnostic values differed by at most 2 ulps, as their binary64 reading allows); registered tuning on the mammals, 240 runs in 6,089 s, whose replay with hpstep.prng.Rng ended in the run’s state (7c1806c); Amendment 11, which froze the rates (515a4a1); then one decisive run of run_claims_phase4.py --measure at that commit, 3,051 s on four workers (b6f3b9d). Amendment 12, an erratum (5c846c5), and the Node re-evaluation (09a8afa) followed.
The instance is the mammal closure set: 1,182 synsets and 6,542 closure edges. Every run trains for 1,000 epochs in batches of 50, with 50 negatives per positive drawn with replacement from the anchor’s non-neighbours, 20 burn-in epochs at lr/10, a softmax over −d with the positive inside and the batch-mean loss: Lorentz by Riemannian SGD with the exact exp map, Euclidean by SGD on the squared distance. Amendment 10 item 15 says which constant comes from Nickel and Kiela’s papers, which from their released script and which is this project’s own. The frozen rates: Lorentz 1 at every d; Euclidean 0.1 at d = 2, 3 and 5, 1 at d = 10 and 3 at d = 50. The engine: Python 3.13.18 with numpy 2.5.3 and numba 0.68.1, one environment for every job; two tuning jobs, retrained in the same pool as the measured runs, gave tuning’s float tables bit for bit, and the replay of the measured run (Lorentz, d = 3, seed 0) with hpstep.prng.Rng ended in the run’s state. Both must-fail controls (the label shuffle and edge-shuffled training) showed their weakness, as required; the floors (control 3) are reported only; and L6 is not void. Every number from the decisive run below is in reference/results/claims-phase4.json (readable as claims-phase4.md); tuning’s are in tuning.json, the Node re-evaluation’s in l6-node.md, and the dry run’s in reference/results/dry/claims-phase4.json.
| Claim | Measured (per seed: paired per-query AP, 95% bootstrap interval) | Controls (each must show its weakness) |
|---|---|---|
| L6(a) | Closure, Lorentz − Euclidean, 1,182 queries. d = 2: means +0.7159 to +0.7524, lower ends at least +0.6990; d = 3: +0.7284 to +0.7523, at least +0.7112. Every interval lies above 0 in all five seeds at both d. Closure MAP, exact on the snapped tables: Lorentz 0.876–0.910 and Euclidean 0.157–0.173 at d = 2; 0.950–0.971 and 0.219–0.226 at d = 3. The predicted gap of at least 0.2 holds: the mean MAP difference is 0.7256 (d = 2) and 0.7424 (d = 3) | 1. Label shuffle: one permutation, P = Rng(7), computed for the first time in this run, relabels each of the 316 trained tables (the 216 finite tuning tables, the 50 measured and the 50 edge-shuffled); the largest relabelled closure MAP is 0.018803, against the bar of 1/20, so the evaluator does not leak. Reported: under 200 further permutations no measured table went above 0.0443. 2. Edge-shuffled training (6,542 random pairs from Rng(2000 + s)) scores closure MAP 0.0129–0.0161 and graph-edge 0.0049–0.0098; every true − shuffled interval lies above 0 in all 50 cells and seeds, for closure (lower ends at least 0.132) and graph-edge (0.174). 3. Untrained floors, reported: closure 0.0132–0.0165, graph-edge 0.0053–0.0094, beside a random ranking’s expected 0.014957 and 0.007320 |
| L6(b) | Closure at d = 50, Lorentz − Euclidean: means −0.0313 to −0.0328, every interval entirely below 0 (upper ends at most −0.0268). Euclidean’s closure MAP is 0.999971–0.999977, Lorentz’s 0.967176–0.968667. The rule counts an interval entirely below 0 as support: at d = 50 the Lorentz advantage is not just gone, Euclidean is ahead | |
| L6(c) | Graph-edge, exact H³ − learned Lorentz d = 3, 1,176 queries: means +0.2138 to +0.2324, lower ends at least +0.1916 (the rule needs ≥ −0.01 in every seed). The exact arm’s graph-edge MAP is 0.690653, Phase 1’s value on the same queries; learned Lorentz d = 3 reaches 0.458–0.477. Supported, against the registered prediction of refuted | |
| L6(d) | Closure, learned Lorentz d = 3 − exact H³: means +0.6445 to +0.6655, lower ends at least +0.6301. Learned closure MAP 0.950–0.971 against the exact tree’s 0.305408 | |
| L4(c) | 40 tables, the 20 measured and 20 edge-shuffled at d = 2 and 3, seeds 0–4: each snapped to 2−32 and ranked exactly, against float64 ranking of the unsnapped table, closure and graph-edge. Largest |ΔMAP| 9.37×10−6 (learned Lorentz d = 2, seed 1); 0 tables above 1/1000. Only eight learned Lorentz tables move at all; the Euclidean and edge-shuffled ones keep their float MAP exactly. Largest snap displacement 1.565×10−3 (a hyperbolic distance); no exact tie in any snapped table and no float tie in any float table. Reported: snapped to 2−8, the learned Lorentz tables’ closure MAP moves by 0.40–0.60 and their graph-edge MAP by 0.026–0.085, the Euclidean ones’ by at most 0.0068 | L4’s own, read to cover (c) (Amendment 10 item 10): control 2 showed its weakness in Phase 2 on the same evaluator, rank._ap_and_ranks (487 of 488 tied queries). No control was added |
What it shows. On the WordNet mammal closure, at the protocol Amendment 10 fixed and the rates tuning chose, learned Lorentz embeddings rank the hierarchy far better than learned Euclidean ones at matched low dimension: about 0.72–0.75 more closure AP per query at d = 2 and 3, with every seed’s interval above 0. At d = 50 the order reverses, and Euclidean reaches a closure MAP of 0.99997. The training-free exact H³ tree keeps direct parents and children better than learned Lorentz d = 3 (graph-edge MAP 0.691 against about 0.46), while the learned table ranks the whole closure far better (about 0.96 against 0.305). Learned tables snapped to 2−32 and ranked exactly lose almost nothing: the largest change in MAP is 9.37×10−6, about a hundred times under the bar, where a coarse 2−8 snap costs the Lorentz tables up to 0.60. Node, with lexicon_core.js unchanged, re-ranked the 50 measured snapped tables and the exact arm and found every exact MAP, LBENCH/1 hash, mean rank and tie count equal, and 0 of 118,200 per-query APs different; so the browser may show L6 and L4(c) as holding (Common rules, “Authority”).
What it does not show. It holds for one instance, the 1,182 mammal synsets, one protocol, one tuning grid, five seeds, and one Python build on one Linux container; each rate was tuned per cell on closure MAP alone. That tuning ran on the same mammals (seeds 9000–9023), so it showed Lorentz against Euclidean closure MAP before any measured run (Amendment 10 item 14), which is why all code and the dry run came first. The learned tables are trained on the closure and scored on it, so (a), (b) and (d) measure how well each geometry fits the relation it was trained on, not generalisation to held-out edges. (c) compares the exact tree with learned Lorentz d = 3 only, as registered; the learned Euclidean tables at d = 10 and 50, reported, reach graph-edge MAPs of 0.65–0.68 and 0.85. The geoopt cross-check of D9 was not run: torch could not be installed through the proxy, and a 60-digit decimal oracle and finite-difference gradients in the tests stand in its place. Nothing here is a language model, and the Stage-2 lexical claims the plan listed for this phase (HyperLex, the hypernymy suite, SimLex and the rest) were not registered in Phase 4; Amendment 13 registered them after Phase 5, before any code for them, and Stage 2 decided them (below).
Against prediction, and on the record. L6(c)’s prediction was wrong. It was registered as refuted by a rule applied to spike S3: supported only if the exact tree’s graph-edge MAP on the verb forest reached 0.90, and S3 measured 0.6309. The rule assumed that learned embeddings keep graph edges, so that the exact tree, held back by its virtual letters, would fall below them. Trained on the closure, the learned Lorentz tables rank ancestors and descendants alike, and direct parents and children reach a graph-edge MAP of only 0.43–0.48 at every d, well under the exact tree’s 0.691. The decision follows the rule, not the prediction: (c) is supported. The other predictions held, and (a)’s gap, at least 0.2, held by a wide margin. Amendment 11, the lr-freeze amendment, gave settings.json’s SHA-256 (058e1900…) and every tuning run, and disclosed that the A10.17 supplement had ranked Phase 1’s arms on the mammal spanning subtree before tuning: A10.17 required that computation and A10.14’s order forbade ranking the mammal sets before tuning. It trained nothing, evaluated no L6 table, did not rank the closure set and did not compute P; its values decide nothing. Amendment 12, an erratum written with this write-up, corrects one sentence of Amendment 11: the closest tuning choice is Euclidean d = 50 (0.000133 between rates 3 and 1), not Lorentz d = 2 (0.000857); it changes no rule and no result. The A10.17 supplement (fractional-ties.md, deciding nothing) gives the fractional-tie values Phases 1 and 2 left out, beside the pessimistic ones they published, which it recomputed equal: H³ graph-edge MAP on the mammal spanning subtree is 0.6907 pessimistic and 0.7701 fractional. L6’s exact arm has 47,375 exact ties: its graph-edge MAP is 0.6907 pessimistic and 0.7701 fractional, its closure MAP 0.3054 and 0.3305. The learned and edge-shuffled tables have no exact tie, so their fractional and pessimistic values are equal. Timing. The decisive run took 3,051 s on four workers, 2,893 s of it in the pool that trained and evaluated the tables, about 45–350 s of training per Lorentz run and 30–273 s per Euclidean run from d = 2 to 50; tuning took 6,089 s, the dry run 5,867 s and 2,833 s, and the Node re-evaluation 117 s. Each run is single-threaded; four ran at once.
Stage 2 results
Stage 2 is the benchmark ladder’s Stage 2, lexical semantics: four claims on human-rated and human-labelled sets, registered by Amendment 13 after Phase 5. Explainer 15 tells the whole story. The order of work, one commit each: Amendment 13 registered L12–L15, their definitions and the order of work before any Stage-2 module existed (b3a5003); the code, built on synthetic data, WordNet’s verbs and unregistered seeds (613721d), with the fixes of an adversarial review, the reported analyses of Amendment 13 item 11 and the decision wiring (e91e02d, 841b90c); the dry run on WordNet’s verbs, its values on human-rated sets sealed in a file outside the repository (05d467d); Amendment 14, the definitions after the dry run, which changed no definition (513e079); one code commit and the dry run rerun on it (9550eea, 5acbbb7); a test fix (93a5a8e); the timing projection (b2ba411); registered tuning of L14 on HiT’s validation split, 48 runs (60345b4); Amendment 15, which froze the learning rate at 10 in every cell, the top of the grid (6b6ec09); then one decisive run of run_claims_stage2.py --decisive at that commit, 16,673 s on four workers (5d32f47).
The run scored blind. Pass 1 read only the word columns and wrote, for every instance, arm, score, sense rule and table, a file of tie-class codes: 1,635 files, 172,892,141 lines. Pass 2 then opened the gold, ran the count checks and decided. The arms: the exact trees H³ and H²; the same construction at curvature 0 (F3 and F2 on the lattice, F3* and F2* fractal); the controls K3, S-full and W; WordNet’s own graph, WN; GloVe 6B; and, for L14, learned Lorentz and Euclidean tables of the 74,401 nouns joined by WordNet’s 75,850 direct edges, trained by Amendment 10’s protocol for 1,000 epochs at d = 2 and 3, seeds 0–4. A pair is scored by the is-a score G, the depth gap Dep° or the symmetric score Sym, with the maximum over senses, and ordered exactly. Before writing its record, the run checked its 141 decided comparisons and 321 control values against Amendment 13’s own text and against their recomputation from the files; all matched. 40 of the 42 training runs converged; the two that did not are the pre-flight retrains at rate 0.03, which repeat tuning’s runs bit for bit, as Amendment 13 item 10.9 expects. Every number below is in reference/results/claims-stage2.json (readable as claims-stage2.md); the console is stage2-console.txt, tuning’s numbers are in tuning-stage2.json and Amendment 15, and the dry run’s visible record is reference/results/dry/claims-stage2.json.
| Part | Verdict | Measured (estimate [95% interval]) | Controls (each must fail) |
|---|---|---|---|
| L12(a) | SUPPORTED | HyperLex nouns, 2,163 pairs, Spearman ρ by G: H³ 0.624924, H² 0.620716; F3 0.173168, F3* 0.216920, F2 0.054840, F2* 0.211128. H³ − F3 +0.452 [+0.366, +0.537]; H³ − F3* +0.408 [+0.317, +0.503]; H² − F2 +0.566 [+0.468, +0.653]; H² − F2* +0.410 [+0.313, +0.507]. Intervals are word-level: words, not rows, are resampled | 1. Hierarchy removed: H³ − K3 +0.527 [+0.397, +0.645]; H³ − S-full-18, the strongest of 20 permutations, +0.531 [+0.433, +0.623]. 2. Senses scrambled: H³ − W-10 +0.577 [+0.473, +0.673]. 3. Roles reversed: +0.723 [+0.606, +0.827]. 4. Gold shuffled: over 20 permutations, |mean ρ| at most 0.0141 for each of the seven arms, against the band 0.0240. All fail as required |
| L12(b) | SUPPORTED | G − Dep°: H³ +0.174 [+0.062, +0.293]; H² +0.168 [+0.055, +0.287]. The tree carries ancestry beyond depth | |
| L12(c) | SUPPORTED | G − Sym: H³ +0.399 [+0.309, +0.488]; H² +0.410 [+0.320, +0.498]. The tree carries direction beyond similarity | |
| L12(d) | REFUTED, low side | H³ − WN −0.161 [−0.221, −0.112], entirely below the band [−0.02, +0.02]: WordNet’s own graph, read by the same score, reaches 0.785527. Flagged in the record as registered after a partial preview (A13 item 20) | |
| L13(a) | SUPPORTED | BLESS test, 12,365 rows, 1,194 of them positive (share 0.097): AP H³ 0.789, H² 0.801; F3 0.106, F3* 0.137, F2 0.092, F2* 0.122. H − F +0.653 to +0.709, lower ends at least +0.624. Intervals resample the 200 BLESS concepts | 1. H³ − K3, − S-full* and − W* above 0 on each part, lower ends at least +0.309. 2. Labels shuffled: the mean AP over 20 permutations is at most the share of positives + 1/50 for all six arms on both sets (largest 0.0981 against 0.1166 on BLESS, 0.5201 against 0.5317 on WBLESS). 3. Sym on H³ and GloVe give a direction accuracy of exactly 0. All fail as required |
| L13(b) | SUPPORTED | WBLESS test, 1,493 rows (share 0.512): AP H³ 0.970, H² 0.971; the flat arms 0.516–0.569. H − F +0.401 to +0.455, lower ends at least +0.362 | |
| L13(c) | SUPPORTED | Direction on BLESS’s positives, the hypernym being the more general word: H³ 0.980 (exactly 195/199), H² 0.983 (587/597); F3 0.628, F3* 0.603, F2 0.518, F2* 0.438. H − F +0.352 to +0.545, lower ends at least +0.304 | |
| L14(a) | SUPPORTED, all four cells | HiT’s WordNet multi-hop test, 29,383 rows, each a child, its held-out ancestor and 10 random or 10 hard negatives; per-row reciprocal rank. Lorentz − Euclidean per seed: d = 2 random +0.280 to +0.316, hard +0.446 to +0.487; d = 3 random +0.178 to +0.222, hard +0.382 to +0.409. In every cell all 5 seeds are present with lower ends above 0 (the smallest +0.175). Mean RR: Lorentz 0.948–0.964 (random) and 0.711–0.812 (hard); Euclidean 0.640–0.786 and 0.318–0.366 | 1. Within-row label shuffle: mean RR at most 0.2784 over all 88 trained tables, against the band 0.2945. 2. Point relabelling: macro mean at most 0.2874 over all 88, same band. 3. Edge-shuffled training: at every d, seed and metric at least one cell lies above 0; one cell, Euclidean d = 3, seed 0, hard negatives, is “true ≈ shuffled” (−0.0069 [−0.0118, −0.0022]). 4. Gold shuffled: |mean ρ| at most 0.0107, band 0.0241. The closure check scores RR = 1 on every test row in both settings. All as required; L14 is not void |
| L14(b) | SUPPORTED, d = 2 and 3 | HyperLex nouns within the 74,401, 2,153 pairs: ρ Lorentz 0.475–0.490 (d = 2) and 0.486–0.507 (d = 3); Euclidean 0.112–0.204 and 0.199–0.265. Lorentz − Euclidean +0.285 to +0.366 and +0.221 to +0.293 per seed, every lower end above 0 (the smallest +0.127) | |
| L15(a) | REFUTED | By Sym. SimLex-999 nouns, 666 pairs: H³ 0.589, H² 0.583; F3 0.337, F3* 0.363, F2 0.191, F2* 0.361. MEN noun pairs, 2,005: H³ 0.395, H² 0.400; F3 0.156, F3* 0.302, F2 0.122, F2* 0.295. The eight hyperbolic gains are +0.222 to +0.391 (SimLex) and +0.093 to +0.278 (MEN), and every lower end lies above the +0.02 bar (the smallest, MEN H³ − F3*, +0.034): curvature 0 does not do as well | 1. On SimLex and MEN, H³ − K3, − S-full* and − W* lie above 0, lower ends at least +0.239. 2. Gold shuffled: all 100 arm and set means within their bands. 3. GloVe’s vectors shuffled among its words: means −0.0056, −0.0063 and +0.0023, within their bands. All fail as required |
| L15(b) | SUPPORTED | GloVe 6B 300-d cosine − H³ by Sym: MEN +0.366 [+0.276, +0.456] (ρ 0.761 against 0.395); WordSim-353 relatedness, 245 pairs, +0.585 [+0.285, +0.858] (0.580 against −0.004). H³ − GloVe on HyperLex within GloVe, 2,162 pairs: +0.110 [+0.024, +0.193] (0.226 against 0.116) |
What it shows. Read by the is-a score with the maximum over senses, the training-free exact trees track human type-of ratings on HyperLex’s nouns far better than the same construction at curvature 0 (ρ 0.62 against 0.05–0.22), and they detect hypernymy and its direction on BLESS and WBLESS far better too. The score carries ancestry beyond depth and direction beyond similarity. WordNet’s own graph, read the same way, still does better on HyperLex (0.786 against 0.625), so L12(d) is refuted. The reported chain of arms shows where that gap opens: WordNet’s spanning tree with unit edges scores 0.739, the letter tree with its virtual letters 0.734, and the letter tree placed in H³ 0.625 (the undirected graph metric scores 0.716). So 0.109 of the 0.161 opens in the embedding, not in the tree. With the same WordNet information on both sides, curvature also helps on similarity and relatedness (L15(a), refuted as predicted), while GloVe beats H³ on relatedness and H³ beats GloVe on HyperLex (L15(b)). Trained on WordNet’s direct edges alone, learned Lorentz beats learned Euclidean at d = 2 and 3 on held-out multi-hop ancestors and on HyperLex (L14).
What it does not show. Every arm reads WordNet, and HyperLex’s TYPE, most of BLESS’s positives and all of HiT were built from it: these claims decide what curvature and learning do with the same information, not lexical knowledge beyond WordNet (A13 item 21). Nouns only; one sense per word, chosen by the maximum over senses, without context. On BLESS the flat arms sit near chance (F2’s AP, 0.092, is below the share of positives, 0.097), so L13 measures the exact trees against a near-chance baseline. L14 is one protocol, 1,000 epochs and five seeds, at a rate, 10, that is the grid’s top in every cell, where tuning’s scores were still rising (Amendment 15). The word-level intervals are wider than the spread they estimate (1.57–1.82 times it in Amendment 14’s synthetic model), so the refutations of L12(d) and L15(a) are conservative. Literature numbers are orientation only. Nothing here is a language model.
Every part came out as predicted: L12(a)–(c) supported and (d) refuted on the low side; L13(a)–(c) supported; L14(a) and (b) supported; L15(a) refuted (predicted “at least on SimLex”; it is refuted on MEN too) and (b) supported. Graded details, right and wrong. Right: ρ(H³) on HyperLex between 0.45 and 0.70 (0.625), and every flat arm at least 0.10 below it (the smallest gap is 0.408). Wrong: the width of L12(d)’s interval, a word-level half-width predicted at 0.015–0.026 and measured at 0.054. Its estimate, −0.161, is also far beyond the part of the shortfall the prediction sized: 0.02–0.04 from the 46 hyp pairs whose closure link is not a spanning one, plus a loss to the embedding’s bends that it left unsized. Wrong: L13’s “F* is the likeliest inconclusive cell of (c)”; both F* cells lie well above 0 (lower ends +0.344 and +0.514), and F2* picks the right direction on fewer than half the pairs (523 of 1,194). Half right: L14’s “a larger gap in (a) than in (b)” holds with hard negatives (+0.382 to +0.487 against +0.221 to +0.366) and not with random ones (+0.178 to +0.316), and the two gaps are in different units, RR and ρ. Wrong: L15’s “MEN’s word reuse widens its intervals”; none of MEN’s four (a) intervals is wider than its SimLex twin (widths 0.121–0.170 against 0.209–0.258), since MEN’s three times as many rows outweigh its reuse. Explainer 15 grades every one of these.
Disclosed before the run. L12(d) was registered after a partial preview from counts (A13 item 20), and the record flags it. Tuning showed Lorentz ahead of Euclidean on HiT’s validation split before any measured run (Amendment 15 item 3). The dry run’s L15 control 1 did not fail as required; Amendment 14 traced it to size, a 29-row verb stand-in for MEN, and changed nothing. Two registered choices kept L14 from being void. Control 2 decides on the macro mean, which weights each positive synset once: the per-row mean would have crossed the band in 21 of the 88 tables, 5 of them measured, and the macro mean crossed it in none. Control 3 asks for one cell above 0 at each d, seed and metric, and the Euclidean cell above is “true ≈ shuffled”, so Amendment 10’s every-cell reading would have voided (a). Amendment 13 registered both choices, with their reasons, before any code. A tie reading. WordNet’s graph splits HyperLex’s pairs into only 13 tie classes. Amendment 13 item 7 registered average ranks; with every tie broken against the gold, WN would score 0.496 and H³ 0.621 (the record’s reported tie bounds), so the sign of L12(d) rests on that registered reading.
The independent check. Code written apart from the reference, importing none of its statistics, scores or runner, recomputed every decided value of L12–L15 from the pass-1 code files and the gold, after checking each file’s SHA-256 against the manifest. Every exact ρ, AP and accuracy is equal; every interval end is equal to six decimals and every estimate bit for bit; L13’s interval ends are equal bit for bit when the terms of AP are summed as numpy sums them (1–2 ulp apart with math.fsum). All 1,635 code and side files, the 90 loss files, the 1,848 LBENCH/1 receipts, the 42 trained runs, the 20 floors and the 48 tuning tables match the record, and a separate scorer reproduced L14’s 216 code files byte for byte from the snapped tables. No value or verdict differs. One wording does: Amendment 14 says an interval’s estimate is the exact difference rounded once to binary64, but L14’s per-row intervals report rank.ci_mean’s float64 mean, as Amendment 13 item 7 registered (1–2 ulp apart in 24 of 60 estimates). Amendment 16, an erratum written with this write-up, records it and changes no rule and no result.
The Node re-evaluation (A13 item 1). lexicon_stage2.js re-renders Stage 2’s code files in Node from the pinned word columns, WordNet and the committed snapped tables alone, with exact rationals and square roots at 1,024 bits. Amendment 13 item 1 named lexicon_core.js; the new file sits beside it, uses only its exports and leaves it unedited (decision D4 of the integration overhaul), and Amendment 16 records the file name as an erratum. It reproduces the trace reference/traces/stage2_v1.txt (3,129 lines, from Rng(8000 + i)) line for line, and all 106 decision files of A13 item 14 (66 exact-arm files and the 20 measured tables on HiT’s test and on HyperLex), 12,685,235 lines, byte for byte by the SHA-256 of their text, with every count and every value that took the 240-digit path equal; 624 further files on the same instances match as well. The gzip bytes differ, since Node’s zlib is not Python’s, so the comparison is the text’s SHA-256, the receipts’ itemScoresSha. Not re-rendered, since only controls read them: the files of L14’s edge-shuffled and tuning tables and of its relabelled points, and GloVe’s files for the controls 3 of L13 and L15; the independent check reproduced them in Python. Every decision file is reproduced, so the browser may show L12–L15’s verdicts as holding (A13 item 1). tests/parity-stage2.cjs runs both checks.
The dry runs’ sealed files (A13 item 13), opened after the decisive run: both hash to the SHA-256s their visible records give (7ba50e01… and 9c9eac2c…), and the rerun holds every value of the first. The dry L15 control 1 failed on the 29-row MEN stand-in alone, and all three of its legs held on SimLex’s verbs, as Amendment 14’s size diagnosis expected; on the registered sets all six legs lie above 0.
Timing. The decisive run took 16,673 s on four workers (the record’s timings.total_s; the console’s last line, written after the record, says 16,684 s): 13,272 s training the 42 runs, 371 s scoring the exact arms, 1,754 s scoring the learned tables and 1,151 s for pass 2. Pass 1 certified 147,634,222 values, about 3.7×10−5 s each. Tuning ran in three starts, the second cut short by a container suspension, and its record shows which runs were reused (Amendment 15 item 5).
Findings of the spikes
Measured in Phase 0 on data disjoint from every registered instance. They are COMPUTED facts that shaped the design and the predictions; they decide no claim. Explainer 8 quotes their outputs.
| Finding | Measured | Spike |
|---|---|---|
| Float64 ranking of exact H³ tree points is not certifiable at WordNet depth | first inversion at depth 10 (straight) and 12 (random); float32 at 5; exact decoding 840/840 | S1 |
| An exact H² tree exists with rational Pythagorean directions | t = 11/13 (τ = ln 12) decodes 500/500 at every depth 2–28; t = 3/4 only 226/500 at depth 12; 1.28–2.38× H³’s bits | S2 |
| Fixed branching costs MAP: virtual letters put siblings as close as parents | verb graph-edge MAP 0.6309 (0.9974 on one-letter edges, 0.32–0.43 on longer); reproduced exactly in Python | S3 |
| Lexicon shards are Owl’s own biochains, and Owl’s verifier misses tampering | 126/126 field for field; accepts leaves and root deleted, a changed crystal, an altered chainId | S4 |
| Our tree reduces to SHD-CCP’s planned X(5, q) overlay | 2,184 / 4,896 / 12,180 vertices; girths 8, 8, 9; Ramanujan; Hurwitz products equal, 1,000/1,000 | S5 |
| The runtimes disagree on Unicode; pinned tables fix it | Node and Chromium 17.0, Python 15.1; a 15.1 table matches Python on all 1,112,064 code points; 20,520-case stress set | S6 |
| ATTEST/1 crosses languages only through a padded P1363–DER conversion | 0/200 raw, 200/200 converted; verify about 0.2 ms | S7 |
Decisions
Fixed before registration and part of what is tested (PREREGISTRATION.md, “Fixed design inputs”).
| # | Decision |
|---|---|
| D1 | A new folder that loads the shared cores unchanged by relative path |
| D2 | Exact first: tokenizer, ids, addresses, points, rankings and hashes are exact; learning in float64; learned tables stored as dyadic snaps |
| D3 | The octahedral H³ tree (t = 3/4) is the primary exact store; a new exact H² tree (t = 11/13) serves the 2D system; the float H² tree only draws |
| D4 | Token id, address and engram are separate; engram/1 is a compatibility checksum; V0 decides L1, and V1 is a second cell once pinned (it was pinned in Phase 1) |
| D5 | The normaliser runs on pinned Unicode 15.1 tables and fails closed; N1 is the fallback |
| D6 | The L3 address rule and the bijective 59/64-bit id |
| D7 | The Blackwell word only at the Owl/BioChain bridge; record kinds above the word |
| D8 | Shards of at most 60,000 bytes in unmodified shdccp/2; RFC 6962 manifests; two tiers |
| D9 | Authorities: the Python reference (exact claims), Owl’s and BioChain’s JavaScript (compatibility), the numpy trainer (embeddings) |
| D10 | The three tracks share the tokenizer record, data roots, generator, metric code, budgets and receipts |
| D11 | No model code before its claims are registered; PolyStep only for small heads |
| D12 | The other repositories are read only; their Python runs as python3 -B -I |
The network was widened at the start of Phase 1: huggingface.co (with its large-file store), the osf.io API, zenodo.org, arxiv.org and aclanthology.org are reachable, which let V1 be pinned; osf.io’s file downloads still redirect to a blocked store, and BabyLM is also on Hugging Face. Run the GPU track on your own hardware or a rented GPU from Phase 7. Kernel Form ID 0xA. No shards published to Firestore this round. Proposals sent after Phase 3, with measured numbers.
How the folder grows
The rule of Hyperbolic Oracles and Engram Mind’s Eye: every module ships with five things.
- The code, in
reference/(Python) or beside this page (browser). - A full explainer in
explainers/, built onassets/hl.css, opening with its focused chart (<div data-hl-map="focus" data-node="…">). - A node on the system map in
assets/hl-map.js, with its edges and its explainer. - A row in the claims ledger for anything it claims, registered before the code that tests it.
- Tests, added to
tests/all.cjs, and a line in the folder’sREADME.md.
Before committing, run node "Pages/Hyperbolic Lexicon/tests/all.cjs": it checks this folder and every core it loads.
| Path | Holds |
|---|---|
| index.html, summary.html | This hub; the analysis on one page |
| explainers/ | One full explainer per topic |
| lexicon-2d.html, lexicon-3d.html | The 2D and 3D pages (Phase 5) |
| assets/hl.css, assets/hl-map.js | Shared style; the system map |
| assets/hl-pages.js, hl-panels.js, hl-app.css, lexicon-2d.*, lexicon-3d.* | The pages’ engine, their shared panels (shard, Engram, checks) and style, and each page’s own script and style (Phase 5) |
| lexicon_core.js, data/ | The browser core (Phase 2; its chain section, Phase 3; the exact ranking of snapped tables, Phase 4); the pinned Unicode table and V0 as script files for the pages, L6’s view for Explainer 12, the pages’ WordNet data (Phase 5), and Stage 2’s view for Explainer 15 (data/stage2_view_v1.js, written by reference/golden/make_stage2_view_v1.py) |
| lexicon_stage2.js | Stage 2’s Node re-evaluation (A13 item 1): exact rationals and 1,024-bit square roots that re-render the decisive code files; beside lexicon_core.js, which it loads and leaves unedited |
| reference/ | The Python reference (Phase 1; the chain modules, Phase 3; the trainer and the L6 modules, Phase 4): pins, modules, tests, traces for the browser core (the pages’ trace, Phase 5), the claims runners (Phases 1–4 and Stage 2), the Node re-evaluation of L6 and their results; settings.json and settings-stage2.json, the frozen learning rates |
| spikes/ | S1–S7 and their captured outputs; the L1 stress set |
| proposals/ | Documents for the other repositories, never applied |
| tests/ | parity-lexicon.cjs, chain-lexicon.cjs, bridges-lexicon.cjs, pages-lexicon.cjs (the page engine in Node), pages-chromium-2d.cjs and pages-chromium-3d.cjs (the pages in Chromium), parity-stage2.cjs (Stage 2’s trace and decisive code files in Node), links.cjs, spikes.cjs, all.cjs; l1-harness.html, the page the Phase 2 runner opens in Chromium |
| README.md, PREREGISTRATION.md | The plan and file map; the claims fixed in advance |
Glossary
- Address
- A reduced word of the norm-5 quaternion tree given to a WordNet synset or a token by the L3 rule. Ancestry is prefix order; the word is an integer quaternion of norm 5length.
- Norm-5 tree
- The 6-regular tree generated by 1±2i, 1±2j, 1±2k (the Lubotzky–Phillips–Sarnak set for p = 5): 6 children at the root, 5 after.
- Virtual letters
- The extra letters a child needs when its parent has more than 5 children: max(1, ⌈log₅ c⌉) letters per child. They make siblings as close as parents (spike S3).
- H², H³
- The hyperbolic plane and 3-space, here as the hyperboloid model; the 2D and 3D systems.
- Exact point
- A point of the hyperboloid with rational coordinates; in the octahedral tree an integer vector over 7n.
- Exact chart
- How the pages draw: an isometry of H² or H³, computed exactly in BigInt, that moves the chosen centre to the origin; only the last step, to the disk or the ball on screen, is in floats. Every value the panels show is exact.
- Graph-edge and closure MAP
- Mean average precision when a node’s neighbours are its parent and children (graph-edge), or all its ancestors and descendants (closure). Ties count against the query.
- N_B
- The registered normaliser: BERT’s BasicTokenizer steps on a pinned Unicode 15.1 table, with byte spans, failing closed on code points unassigned in 15.1 (Amendment 1).
- V0, V1
- The two vocabularies of L1. V0 “lex0”: 8,192 WordPiece entries trained here on WordNet’s glosses and frozen by hash; it decides. V1: bert-base-uncased’s 30,522 entries, pinned at a Hugging Face revision; the second cell.
- WordPiece
- BERT’s subword tokenizer: greedy longest match, with “##” marking continuations.
- Parity
- The browser core regenerating the reference’s trace files line for line (
tests/parity-lexicon.cjs; for Stage 2,tests/parity-stage2.cjs, which also re-renders the decisive code files); required before a claim decided in the reference is shown as holding in the browser. - G, Dep°, Sym
- Stage 2’s scores of an ordered sense pair (s, t), with r the distance from the base point o: the is-a score G = r(s) − r(t) − d(s, t), at most 0, and 0 exactly when t lies on a geodesic from o to s; the symmetric score Sym = −d(s, t); and Dep°, the depth gap r(s) − r(t) of the senses G chose. A word pair takes the maximum over its senses (A13 item 5).
- Word-level interval
- Stage 2’s bootstrap for a difference of ρ: it resamples words, not rows, and weights each pair by how often both its words were drawn, because one word appears in many pairs. Wider than a row bootstrap.
- Inversion
- In L4(b), an adjacent pair of candidates whose exact keys are strictly increasing and whose float keys are strictly decreasing.
- engram/1
- Owl Academy’s 64-bit token key: the XOR of fixed letter grids, so only the parity of each letter’s count. Kept here as a checksum.
- SHD-CCP
- The Symbolic High Dimensional Context Compression Protocol: a 64-bit tile format and, in practice, the
shdccp/2stream of Owl Academy and BioChain-AI. - Blackwell word
- The 64-bit layout every working SHD-CCP codec uses: form 63..60, parity 59, spin 58..56, quat32 55..24, payload16 23..8, freq 7..3, amp 2..0.
- Biochain
- A text of at most 60,000 bytes grown into a
shdccp/2stream with SHA-256 leaves, a Merkle root and a chiral weave, recreated losslessly. - RFC 6962 tree
- The Certificate Transparency Merkle tree: domain-separated leaves and nodes, no duplication, inclusion and consistency proofs.
- ATTEST/1
- BioChain-AI’s signed commitment: ECDSA P-256 over “ATTEST/1|keyId|keyVector|SHA256(commitment)|epochToken”.
- Records
- The typed commitments above the word (D7), each a pipe-joined string hashed with SHA-256: LVOCAB/1 (the vocabulary and normaliser), LADDR/1 (the address table and its root), LPREP/1 (one shard), LCORPUS/1 (the manifest) and LGROW/1 (its growth), built in Phase 3; LBENCH/1 (one benchmark receipt per evaluated table: instance, arm, geometry, d, seed, rate, protocol, settings, table hashes and the exact MAPs’ hashes), built in Phase 4 (Amendment 10 item 12).
- Snapped table
- A learned float64 table rounded to the 2−32 grid: a Lorentz row through its Poincaré point by fence.js’s
dyadicrule, a Euclidean row coordinate by coordinate. Its points are exact, so it is ranked exactly and named by a hash (L4(c); Amendment 10 item 6). - Exact weave
engram_core.chainQuaternionover the first 8 bytes of each leaf hash: an integer quaternion of norm 528K that unfolds, in order, to those prefixes (L9(b)). The order-sensitive summary proposed in place of the float chiral weave.- Self-consistent, authentic
- The hardened verifier’s two verdicts (Explainer 4; Amendment 8 item 3). Self-consistent: every check but the signature passes, so the record, its derived layers and its place in the manifest agree. Authentic: the ATTEST/1 signature verifies against a registered, unrevoked key.
- Tier S, Tier P
- A Tier-S shard’s text travels in its stream; a Tier-P shard’s public LPREP/1 carries a salted root in place of its chainId, for text whose licence does not allow it to travel.
- X(5, q)
- The LPS Ramanujan graph: the norm-5 tree reduced mod a prime q, planned by SHD-CCP RFC 03 as an overlay.
- Stage-1 gate
- The review with you after Phase 5 and Stage 2, and next now: no encoder code until every registered claim is decided (L1–L11 since Phase 4, L12–L15 since Stage 2) and reviewed.