What we have built, judged for language; what SHD-CCP integration would look like; a staged hyperbolic BERT front end for our 2D (H²) and 3D (H³) systems; whether language data can grow as SHD-CCP biochains; and the benchmarks that would show whether any of it works. Phase 1 built the exact Python reference and decided three claims and L3’s Python side; Phase 2 built the browser core and decided L1, L3(f) and L4(a, b); Phase 3 grew language shards as biochains in JavaScript and Python and decided L8–L11, L11 on packages grown with engrams off, a reading Amendment 8 fixed after the dry runs; Phase 4 trained Lorentz and Euclidean embeddings of the WordNet mammals and decided L6 and L4(c), L6(c) against its registered prediction, so all eleven claims registered in Phase 0 are supported. Phase 5 built the 2D and 3D pages. Stage 2 registered four lexical claims, L12–L15, and decided them in one run: the exact trees beat curvature 0 on HyperLex, BLESS, WBLESS, SimLex and MEN, learned Lorentz beats learned Euclidean on WordNet’s direct edges, and WordNet’s own graph still beats the exact H³ tree on HyperLex.
Engram Mind’s Eye and Hyperbolic Oracles give exact quaternion addresses, an exact tree in H³ to depth 28, hyperboloid tools, Merkle chains, an outlier fence and a method that checks browser code against Python line for line. Before Phase 1, none of the four repositories had a subword tokenizer, a vocabulary or a language benchmark; none had learned embeddings until Phase 4 trained static ones, and none has an encoder. The engram/1 key keeps only the parity of each letter’s count, so LISTEN = SILENT and every number lands on the zero key: it cannot be a token id. PolyStep is gradient-free and trained 48 parameters at most; its “hyperbolic beats flat” claim was refuted.
A specification repository (RFC 01 tile, a Kernel Ontology, golden vectors; no chain format), the working Blackwell word and shdccp/2 stream in Owl Academy and BioChain-AI, and prose that was never built. At least eight 64-bit layouts exist: the check word 9841D88D8B003CEA reads as Form 9, 8 or 13 depending on the reader, and every Form value is already claimed. Integration means the Blackwell word only where we hand data to Owl Academy and BioChain-AI, record kinds above the word, golden vectors, and proposals instead of edits. The strongest link is mathematical: our tree’s generators 1±2i, 1±2j, 1±2k are the Lubotzky–Phillips–Sarnak set for p = 5, so SHD-CCP’s planned X(5, q) overlay is a quotient of the tree our addresses already live on.
Stage 1 is exact and needs no training: pinned Unicode, WordPiece, a training-free address for every WordNet synset in the quaternion tree, exact points in H³ and in a new exact H² tree, exact ranking. Stage 2 follows the best-supported route in the literature: a Euclidean encoder that takes the address as a hierarchy factor, with a hyperbolic hierarchy head. H² and H³ are far below language-model width, so they serve as factors, heads and views, not as the main embedding.
Main routes, baselines, controls built to fail, later work and rejected ideas. Fully hyperbolic encoders (HyboNet, HyperCore, HELM) need a GPU. No published work applies hyperbolic geometry at the tokenizer level, an open gap. Gradient-free methods fine-tune heads; they do not pretrain. A Euclidean control at matched dimension is mandatory: one study found flat embeddings catching up from about 50 dimensions.
A biochain’s whole lineage is capped at 60 KB, because each growth step regrows all its text. So a corpus becomes many unmodified shdccp/2 shards, each one a biochain Owl Academy already accepts, tied together by an append-only RFC 6962 manifest, with typed signed records, two privacy tiers, and a stricter importer that closes what Owl’s verifier misses.
Stage 0 checks determinism and the tokenizer, Stage 1 WordNet hierarchy reconstruction, Stage 2 lexical semantics, Stage 3 small-scale pretraining (BabyLM, BLiMP), Stage 4 sentence tasks (GLUE, MTEB). Browser, CPU and GPU tracks share one tokenizer record, the data roots, the seeds and the metric code, so their results compare.
Exact stages compute in integers and rationals and give the same bytes in Python, Node and the browser. Float stages learn, and store what they learn as exact dyadic snapshots.
Each WordNet noun synset’s spanning parent is its first hypernym pointer. A child of a node with c children takes max(1, ⌈log₅ c⌉) letters of the tree, so ancestry becomes prefix order and every address is an exact integer quaternion that right division unfolds. Nodes with more than five children need extra “virtual” letters, and those put siblings as close as parents: on WordNet’s verb forest the exact tree’s graph-edge MAP is 0.6309 (spike S3), against 0.9974 on edges that need one letter.
decoder3d.jsWhat Owl’s verifyIntegrity does today (spike S4) | The hardened importer | Measured in Phase 3 (L10, 50 packages a class) |
|---|---|---|
| Accepts a record with its leaf hashes and Merkle root deleted | Leaves and root are mandatory and recomputed | T1: Owl accepts 50 of 50; rejected at leaves, 50 of 50 |
| Accepts a changed crystal or checksum (parity re-fixed) | Recomputes each chunk’s crystal and compares | T2, a crystal changed: Owl accepts 50 of 50; rejected at the crystal check, 50 of 50 |
| Accepts an altered chainId | Recomputes chainId and the weaves | T8: Owl accepts 50 of 50; rejected at the weaves, 50 of 50 |
| Accepts 3.55% of single-bit residual flips (they decode the same) | Re-encodes each chunk and requires the stored bytes | T9: Owl accepts 50 of 50; rejected at the re-encode (canonical) check, 50 of 50 |
| Never checks a signature on import | Verifies the ATTEST/1 ECDSA signature; reports self-consistent and authentic separately | T4 (a revoked key) and T5 (another shard’s signature): rejected at the attestation, 50 of 50 each, still self-consistent |
Shards grown here equal Owl Academy’s own biochains field for field: 336 of 336 records in Phase 3 (WordNet’s 148 noun shards and 20 synthetic ones, engrams off and on; L8), after 126 of 126 in spike S4. The RFC 6962 manifest over the 148 shards, and synthetic lists of up to 1,001 entries, detected every alteration and proved inclusion in at most 8 hashes at 148 entries and 10 at 1,000 and 1,001 (L9; spike S4: 14 at 10,000), where the current Merkle rule gives a list and the same list with its last element repeated the same root (at K = 3, 7 and 1,001 in L9’s control). Plaintext is chained only for text whose licence allows it; restricted corpora publish salted commitments and are checked by audit (Phase 3 tested the salted format with public test salts; the audits are not built).
| Stage | Question | Benchmarks | Runs |
|---|---|---|---|
| 0 | Is the front end deterministic, and is the tokenizer sane? | Byte identity in Python, Node and Chromium; engram/1 collisions; fertility, bytes per token, Rényi efficiency (gates, not goals) | here |
| 1 | Does the geometry hold the hierarchy? | WordNet nouns (82,115) and mammals: graph-edge and closure MAP, mean rank, bits per node, against a Euclidean control | here |
| 2 | Does it carry lexical meaning? | HyperLex, the hypernymy suite, SimLex, WordSim, MEN, HiT’s WordNet multi-hop split, GloVe (SemEval-2018 Task 9 not decided) | here decided: L12–L15 (pinned copies replace the unreachable hosts) |
| 3 | Does small pretraining learn grammar? | BabyLM 10M and 100M words (from Hugging Face); BLiMP scored with a pinned rule and pipeline | here GPU |
| 4 | Does the encoder help on sentences? | GLUE (BERT-Tiny 64.2 to ELECTRA-Small 77.4), a cheap MTEB subset, SentEval probes | GPU |
Registered before any code that tests them, each with controls that must fail and a rule fixed in advance: L1–L11 in Phase 0, L12–L15 by Amendment 13 at the start of Stage 2. Predictions are on record. Phase 1 decided L2, L5, L7 and L3’s Python side, Phase 2 L1, L3(f) and L4(a, b), Phase 3 L8–L11 and Phase 4 L6 and L4(c): all eleven are supported. Three predicted values were wrong, and they stay on record: L2’s 2–10% share, L11’s 50–150 ms median, and L6(c), predicted refuted and found supported. Stage 2 decided L12–L15 part by part: nine parts supported and two refuted, L12(d) and L15(a), each as predicted.
| # | Claim | Prediction | Decision |
|---|---|---|---|
| L1 | The front end is byte-identical in Python, Node and Chromium | supported | supported in all four cells |
| L2 | engram/1 cannot be a token id: ≥ 1% of WordNet’s lemma types share a key | supported at 2–10% | supported at 52.6% |
| L3 | Every noun synset has an exact, invertible, certified address and points in H³ and H² | supported | supported (f) in Phase 2 |
| L4 | Exact ranking agrees across engines; float64 is not certifiable at WordNet depth | supported | supported (a, b) in Phase 2, (c) in Phase 4 |
| L5 | The exact hyperbolic tree beats the same construction at curvature 0 | supported | supported |
| L6 | Learned Lorentz beats learned Euclidean at d = 2, 3, not at 50; the exact tree against learned | mostly supported (c) refuted | supported, (c) against its prediction |
| L7 | Address, H³ point and X(5, q) vertex are one tree read three ways | supported | supported |
| L8 | Language shards are Owl-valid biochains in JS and Python | supported | supported for both growers |
| L9 | The RFC 6962 manifest, its growth, and the exact weave | supported | supported |
| L10 | The hardened importer rejects every registered tamper, identically in JS and Python | supported | supported |
| L11 | A full shard verifies with every check in a median of at most 250 ms | supported at 50–150 ms | supported at 155.4 ms, engrams off (Amendment 8) |
| L12 | On HyperLex’s nouns the exact trees track graded type-of better than curvature 0, through ancestry and direction; H³ as well as WordNet’s own graph | (a)–(c) supported (d) refuted | (a)–(c) supported (d) refuted, low side |
| L13 | On BLESS and WBLESS the exact trees detect hypernymy and its direction better than curvature 0 | supported | supported |
| L14 | Trained on WordNet’s direct edges, learned Lorentz beats learned Euclidean at d = 2, 3 on HiT’s multi-hop test and on HyperLex | supported | supported |
| L15 | (a) Curvature 0 does as well on similarity and relatedness; (b) GloVe beats H³ on relatedness, H³ beats GloVe on HyperLex | (a) refuted (b) supported | (a) refuted (b) supported |
The open definitions were fixed by Amendment 1 before any code. The reference was then built in Python, reviewed twice by independent reimplementation (four reviewers per track, two skeptics per finding; on unregistered data, except that the text track’s checks also compared Python with Python oracles on L1’s instances, which decides nothing, as Amendment 3 records), dry-run, and amended once more (Amendment 2) before one decisive run on 2026-11-05, on the code committed at 88e63f7: 5 minutes on this container. All four claims run are supported under their registered rules, and every control failed as it had to.
| Claim | Decision | Key numbers | Controls that must fail |
|---|---|---|---|
| L2 | supported | 77,520 of 147,305 lemma types (52.6%) share their engram/1 key with another type. 92,978 key classes, 23,193 of them with two or more types; the largest, 371 types, is the zero key, which holds all 131 all-digit types. The Python and Node key tables are identical. | A 64-bit SHA-256-prefix key: 0 collisions |
| L3 | supported Python side | 0 failures in parts (a)–(e) and (g) on all 82,115 noun synsets. Words reach 36 letters; 90.88% fit 25 letters (id59) and 95.66% fit 27 (id64). At most 184/102 bits per coordinate (numerator/denominator) in H³, 252/142 in H². | Zero-letter rule: 11,978 nodes share a word; truncation: 74,220; float decoding fails on 67,989 of the 71,454 words over 12 letters; H² at t = 3/4: 19,796 decoding failures |
| L5 | supported | Graph-edge MAP on the mammals (1,176 queries) and the nouns (1,000): H3 0.6907 and 0.5679, H2 0.7187 and 0.5901, against flat F3 0.1099 and 0.0069 and fractal F3* 0.6420 and 0.5001. All eight registered intervals lie above 0; the smallest, H3 − F3* on the mammals, is 0.049 [0.042, 0.055]. | Permuted words (S3): 0.0186 and 0.0005; content-hash words (K3): 0.0068 and 0.0001, far below H3 on both sets |
| L7 | supported | X(5, q) for q = 13, 17, 29: 2,184, 4,896 and 12,180 vertices; girths 8, 8, 9; walk equals reduction and no collision up to length r; largest nontrivial |λ| 4.2497, 4.3089, 4.4420, so the Ramanujan margin to 2√5 falls to 0.0301 at q = 29. SHD-CCP’s Hurwitz product, halved, equals the tree’s quaternion. | ι = 2 breaks the walk on about 10,870 of 11,182 words at each q; the 4-generator subset is not 6-regular; the product not divided by 2L differs on every word |
Disclosed in Amendment 2. During development a builder’s timing script ran L3’s certify and prefix check over the noun words; its outcome was not looked at, and nothing was changed after it. The same amendment corrects a parenthesis of Amendment 1: google-research/bert drops only the categories Cc and Cf (Hugging Face’s copy drops every C category); the rule in force, Cc, Cf and Co dropped and Cn failing closed, is unchanged.
Left open by Phase 1. L1 (byte identity in Python, Node and Chromium), L3(f) (Python against JavaScript) and L4(a, b) needed the browser core, lexicon_core.js; Phase 2 decided them (below). The full account is Explainer 9 (explainers/reference.html); every number above is in reference/results/claims.json.
Amendment 4 fixed how the three engines are run and compared before any code. The browser core, lexicon_core.js, was then built on the shared cores unchanged, with the pinned data as script files, a parity test and two runners; an adversarial review (three reviewers, two skeptics per finding) found no defect in N_B, WordPiece or the geometry, and the three gaps it confirmed were fixed. Amendment 5 recorded the disclosures, readings, environment and review, and one decisive run followed on 2026-11-05, on the code committed at a1fe9a8: the Python half in 2 min 15 s, then run_claims_js.cjs, which reran the parity first (18,667 of 18,667 lines in Node, as at 09e282d; 18,578 of them the five Phase 1 traces) and then ran Node and Chromium, 6 min 52 s in all. The engines: Python 3.13.18 (Unicode 15.1.0), Node 22.23.4 (ICU 78.3, Unicode 17.0) and Chromium 153.0.8010.12. All four parts are supported under their registered rules, and every control failed as it had to.
| Claim | Decision | Key numbers | Controls that must fail |
|---|---|---|---|
| L1 | supported in all four cells | V0 and V1, each in Node and in Chromium: 0 of 156,801 instances differ from the reference in normalised bytes, pieces, ids or offsets (117,659 glosses, 16,622 UD EWT sentences, 20,520 stress cases, 2,000 synthetic strings), and every id-stream SHA-256 is equal. Reported: Hugging Face tokenizers 0.23.3 agrees on every gloss and EWT sentence, and differs on 28 stress cases (V1) and 29 synthetic strings (V0 and V1); in the examples the results keep, N_B writes a word-final ς, and keeps one [UNK] for a word holding a code point unassigned in Unicode 15.1 (it fails the word closed) where Hugging Face splits out punctuation. | The platform’s toLowerCase, NFD and \p{Mn} removal differs on 725 of the 20,520 stress cases, in Node and Chromium alike; shortest-match-first WordPiece on 117,659 of 117,659 glosses; no accent stripping on 7 of 16,622 EWT sentences |
| L3(f) | supported (completes L3) | Node’s canonical point list of the 82,115 nouns has Python’s SHA-256 (eb22bf00…), and all 2,000 sampled lines equal results/l3f-python.txt. | L3’s four controls, all of which failed in Phase 1 |
| L4(a) | supported | Every rank list, and every exact MAP and mean rank, is equal in Python and Node for the 1,176 mammal queries and noun queries 0–199, in H³ and H²; the mammals also in Chromium. Graph-edge MAP on the mammals: 0.690653 in H³, 0.718723 in H². | An acosh evaluator with node-index ties gives a different AP on 487 of the 488 tied mammal queries |
| L4(b) | supported (decided by the reference) | 997 of 1,000 noun queries have a float64 inversion of an exactly ordered adjacent pair: H³ 990 (4,978,009 inversions, 152,072 float ties), H² 993 (8,969,341 and 1,715). Node reproduces the counts. | Float32 on the mammals in H³ inverts in 1,137 of 1,176 queries (902,886 keys not finite) |
Left open by Phase 2. L8–L11, which Phase 3 decided, and L6 and L4(c), which Phase 4 decided (both below). The full account is Explainer 10 (explainers/browser-core.html); every number above is in reference/results/claims-phase2.json and phase2-python.json.
Amendment 7 fixed the definitions before any code: the exact record strings, L8’s synthetic shards, the RFC 6962 conventions, L10’s packages, keys and draws, and L11’s timing. The grower, the records, the manifest, the exact weave and the hardened verifier were then built as a chain section of lexicon_core.js and a Python port in reference/lexicon/ (a container restart cut the first build off; the work on disk was kept and committed, b822237), reviewed (three reviewers, two skeptics per finding; one finding confirmed, L11’s control) and dry-run. Amendment 8 followed, and then one decisive run on 2026-11-06, on the code committed at 6da04be: 50 min 44 s, after a parity rerun (19,991 of 19,991 lines, the chain trace included) and a check that Owl Academy (7f45f35) and BioChain-AI (c975161) were unchanged. All four claims are supported under their registered rules, and every control showed its weakness.
| Claim | Decision | Key numbers | Controls that must fail |
|---|---|---|---|
| L8 | supported for the JS grower and the Python port | 0 of 336 records (148 C0 shards and 20 synthetic ones, 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, and the V0 id stream, addrTableRoot and LPREP/1 strings are identical in Python and JS. Reported: 1.527% of C0’s chunks hold the byte 0x80; value (text over shipped bytes) 1.095 with engrams off, 0.466 on; our grower took a median 56 ms a shard with engrams off and 119.1 ms on, while Owl’s and BioChain-AI’s, at about 9.3 s a shard with their own engram layer, kept the worker pool busy for 1,837.6 s. | BioChain-AI’s 0x80 normalisation differs on 20 of 20 synthetic shards (the stream only); leaves over binary bytes differ on 168 of 168 and Owl rejects all 168; one altered byte changes leaf and root on 168 of 168 |
| L9 | supported | The RFC 6962 manifest over the 148 LPREP/1 hashes (root f567700d…) and synthetic lists of K = 1, 2, 3, 7, 84, 200, 1,000 and 1,001 entries: every root and proof equal in JS and Python, every alteration detected, every proof for a wrong leaf or position rejected; inclusion proofs of at most 8 hashes at K = 148 and 10 at K = 1,000 and 1,001. All 148 exact weaves exact: norm 528K, unfolding in order, the product of their 7 segments. | The shdccp/2 rule collides at K = 3, 7 and 1,001; an XOR summary misses adjacent swaps that the weave detects |
| L10 | supported | 50 clean and 450 tampered attested packages (T1–T9, 50 each): 0 false accepts and 0 false rejects in JS (WebCrypto) and in Python, and identical verdicts on all 500. The keys were made for the run; the registry snapshot holds public JWKs only. | Owl’s verifyIntegrity accepts 50 of 50 in each of T1, T2, T8 and T9, the gaps only the hardened checks close; Python without the P1363-to-DER conversion accepts 0 of 126 valid signatures |
| L11 | supported on engrams-off packages | The hardened verification of the 147 full C0 shards: median 155.4 ms, 95% interval [154.2, 156.0], against a 250 ms bar (about 156.7 s for 1,000 shards). Reported: engrams-on packages 243.6 ms; LADDR/1 recomputed inside each verification (the literal reading) 1,350.2 ms; the session (LADDR/1 once) 1,303.1 ms; Python 195.9 ms. | Amendment 8’s step check: the attestation ran inside the timed window in 441 of 441 full verifications and was skipped in 441 of 441 control ones. Reported, the registered comparison of medians: skipped faster, paired difference 1.9 ms [0.4, 3.0] |
Left open by Phase 3. L6 and L4(c), the learned embeddings, which Phase 4 decided (below). The full account is Explainer 11 (explainers/chains.html); every number from the decisive run above is in reference/results/claims-phase3.json and claims-phase3.md, and the run’s log in phase3-console.txt; Amendment 8’s dry-run figures are in PREREGISTRATION.md.
Amendment 10 fixed the definitions before any code: the training protocol, binary64 numerics, the snap to 2−32 and exact ranking, the statistics, and tuning read as rate k on seed block k, 240 runs. The trainer (embed.py, numpy float64, its draws a numba copy of the shared generator replayed against hpstep.prng), the exact evaluator of snapped tables (learned.py), the decisions (l6.py), the runner and the browser core’s exact ranking of snapped tables (SnapArm, evaluateSnapped) were then built on synthetic data, reviewed (four reviewers with independent reimplementations, two skeptics per finding; seven minor findings fixed, among them the Euclidean snap, now exactly ⌊232x + 1/2⌋) and dry-run on the solid.n.01 closure set. Registered tuning (240 runs, 6,089 s), on the mammals and so a preview of L6(a) and (b) at seeds 9000–9023, chose the rates Amendment 11 froze: Lorentz 1 at every d; Euclidean 0.1 at d = 2, 3 and 5, 1 at d = 10 and 3 at d = 50. One decisive run followed on 2026-11-06, at 515a4a1: 3,051 s on 4 workers. On the mammal closure set (1,182 synsets, 6,542 closure edges), on seeds 0–4, every run trained for 1,000 epochs in batches of 50, with 50 negatives per positive, 20 burn-in epochs and a softmax over −d with the positive inside, by Riemannian SGD with the exact exp map (Lorentz) or SGD on the squared distance (Euclidean); every table was snapped to 2−32 and ranked exactly. All five decisions are supported under their registered rules; both must-fail controls showed their weakness, and the floors are reported.
| Claim | Decision | Key numbers | Controls that must fail |
|---|---|---|---|
| L6(a) | supported | Closure, learned Lorentz − learned Euclidean per-query AP: every interval above 0 in all five seeds, means +0.716 to +0.752 at d = 2 and +0.728 to +0.752 at d = 3. Closure MAP 0.876–0.910 against 0.157–0.173 at d = 2, and 0.950–0.971 against 0.219–0.226 at d = 3, so the predicted gap of at least 0.2 holds (0.726 and 0.742). | Label shuffle (P = Rng(7), computed first in this run): the largest relabelled closure MAP over 316 tables is 0.018803, under the 0.05 bar, so the evaluator does not leak. Edge-shuffled training scores below true training in all 50 cell–seed pairs, for closure and graph-edge. Floors, reported: a random ranking expects closure 0.014957 and graph-edge 0.007320. L6 is not void. |
| L6(b) | supported | At d = 50 Euclidean is ahead: closure MAP 0.99997 against Lorentz’s 0.967–0.969, every interval entirely below 0 (about −0.032), which the rule counts as support. | |
| L6(c) | supported, against its prediction | Graph-edge MAP: the exact H³ tree 0.690653 against learned Lorentz d = 3 0.458–0.477; every (exact − learned) interval’s lower end is at least 0.19. | |
| L6(d) | supported | Closure MAP: learned Lorentz d = 3 0.950–0.971 against the exact tree’s 0.305408; every lower end at least 0.63. | |
| L4(c) | supported (completes L4) | Over 40 tables (the measured and edge-shuffled ones at d = 2 and 3), the largest |MAP(snapped to 2−32, exact) − MAP(float64)| is 9.37×10−6, against a bar of 0.001; the largest snap displacement is 1.565×10−3 (a hyperbolic distance). Reported: snapped to 2−8, the learned Lorentz tables’ closure MAP moves by up to 0.60. | L4’s control 2, read to cover (c), showed its weakness in Phase 2 on the same evaluator (487 of 488 tied queries); none was added |
Amendments 10–12. Amendment 10 came before any code and recorded that Phases 1 and 2 never reported fractional-tie values; Amendment 11, after tuning and before any measured run, froze the rates in reference/settings.json (SHA-256 058e1900…), gave every tuning run and disclosed that the supplement computing those values had ranked Phase 1’s mammal spanning subtree before tuning, which Amendment 10 item 17 required and item 14’s order forbade; and Amendment 12, an erratum, corrects Amendment 11’s closest tuning choice (Euclidean d = 50, 0.000133 between its two best rates, not Lorentz d = 2, 0.000857), changing no result.
Reported, deciding nothing. Node, with lexicon_core.js unchanged, re-ranked the 50 measured tables and the exact arm: every exact MAP, receipt hash, mean rank and tie count is equal, and 0 of 118,200 per-query APs differ. The fractional-tie values are now reported (reference/results/fractional-ties.md): the exact H³ tree’s graph-edge MAP on the mammals is 0.6907 pessimistic and 0.7701 fractional, its closure MAP in this run 0.3054 and 0.3305. The geoopt cross-check was not run, since torch could not be installed through the proxy; a 60-digit decimal oracle and finite-difference gradients in the tests stand in its place.
Not done in Phase 4. The Stage-2 lexical claims the roadmap listed for this phase (HyperLex, the hypernymy suite, SimLex and the rest) were not registered then; Amendment 13 registered them after Phase 5, and Stage 2 decided them (below). The full account is Explainer 12 (explainers/learned.html); every number from the decisive run above is in reference/results/claims-phase4.json and claims-phase4.md, tuning’s in tuning.json and the Node re-evaluation’s in l6-node.md.
lexicon-2d.html draws the exact H² tree in the Poincaré disk and lexicon-3d.html the exact H³ tree in the Poincaré ball: a sentence’s tokens, ids, addresses and exact points, exact decoding, the bits exactness costs, the X(5, q) vertex of an address, and a language shard grown, signed and verified in the browser. They run lexicon_core.js unchanged and decide no claim.
Stage 2 is the benchmark ladder’s Stage 2, lexical semantics, not the encoder stage of answer 3. Amendment 13 registered four claims after Phase 5, before any Stage-2 code. The code was built on synthetic data and WordNet’s verbs, reviewed, and dry-run with its values on human-rated sets sealed; Amendment 14 recorded the dry run and changed no definition; registered tuning on HiT’s validation split chose the rate 10, the grid’s top, in every cell, and Amendment 15 froze it. One decisive run followed on 2026-11-08, at 6b6ec09: 16,673 s on 4 workers. It scored blind in two passes (1,635 code files, then the gold), read every pair by the is-a score G, the depth gap Dep° or the symmetric Sym with the maximum over senses, and checked its 141 decided comparisons and 321 control values against Amendment 13’s own text. Intervals are 95% bootstraps; for ρ they resample words, not rows.
| Part | Decision | Key numbers |
|---|---|---|
| L12(a) | supported | HyperLex, 2,163 noun pairs, Spearman ρ by G: H³ 0.625, H² 0.621 against flat 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]. |
| L12(b, c) | supported | G beats the depth gap (H³ +0.174 [+0.062, +0.293]) and the symmetric score (H³ +0.399 [+0.309, +0.488]); H² the same. The tree carries ancestry beyond depth and direction beyond similarity. |
| L12(d) | refuted, low side | H³ − WordNet’s own graph −0.161 [−0.221, −0.112], outside the ±0.02 band: WN reaches 0.786. Flagged in the record as registered after a partial preview. |
| L13 | supported | BLESS AP H³ 0.789, H² 0.801 against 0.092–0.137 flat; WBLESS 0.970 and 0.971 against 0.516–0.569; direction 0.980 and 0.983 against 0.438–0.628. Every H − F lower end at least +0.304. |
| L14 | supported | Trained on WordNet’s 75,850 direct noun edges, d = 2 and 3, five seeds. HiT’s multi-hop test, 29,383 rows: Lorentz ahead in all four (d, setting) cells, every seed’s interval above 0; mean RR with hard negatives 0.711–0.812 against 0.318–0.366. HyperLex: ρ 0.475–0.507 against 0.112–0.265. |
| L15(a) | refuted | By Sym, curvature 0 does not do as well: SimLex nouns H³ 0.589 against flat 0.191–0.363, MEN H³ 0.395 against 0.122–0.302; every one of the eight gains has its lower end above the +0.02 bar (the smallest +0.034). |
| L15(b) | supported | GloVe beats H³ on MEN (0.761 against 0.395) and on WordSim relatedness (0.580 against −0.004); H³ beats GloVe on HyperLex (0.226 against 0.116), +0.110 [+0.024, +0.193]. |
Every control failed as required (hierarchy removed, senses scrambled, roles reversed, gold, labels and vectors shuffled, edge-shuffled training, point relabelling), L14’s closure check passed, and no claim is void. 40 of the 42 training runs converged; the two that did not are the pre-flight retrains of tuning’s rate 0.03, equal to tuning’s bit for bit.
Checked after the run. An independent check recomputed every decided value from the code files and the gold and found none different; all 1,635 code files and 1,848 receipts match the record. Node, with a new lexicon_stage2.js beside lexicon_core.js, which stays unedited, re-rendered all 106 decision files byte for byte by their text’s SHA-256, so the browser may show these verdicts as holding. The dry runs’ sealed files match their recorded SHA-256s and are committed as gzip copies (reference/results/dry/stage2-sealed/). Amendment 16, an erratum, records the Node file’s name and corrects one sentence and one figure of Amendment 14; it changes no rule and no result. Not shown. Every arm reads WordNet, and HyperLex, BLESS and HiT were built from it, so Stage 2 decides what curvature and learning do with the same information, not lexical knowledge beyond WordNet; nouns only, one sense per word without context. The full account is Explainer 15 (explainers/lexical.html); every number above is in reference/results/claims-stage2.json and claims-stage2.md.
| Spike | Found |
|---|---|
| S1 | Float64 ranking of exact H³ points first inverts an exactly strict order at depth 10 (straight paths) and 12 (random words); float32 at depth 5; exact decoding never failed. |
| S2 | The new exact H² tree at t = 11/13 decodes every random word at every depth to 28; t = 3/4 decodes only 226 of 500 at depth 12. |
| S3 | The address rule on WordNet’s verb forest: graph-edge MAP 0.6309, closure MAP 0.4206, reproduced exactly in Python; 99.96% of verb words fit 25 letters. |
| S4 | Lexicon shards equal Owl’s biochains (126/126); Owl’s verifier misses deletions and changes; a Python port agrees with the JavaScript weave only with V8’s hypot algorithm. |
| S5 | X(5, q): 2,184, 4,896 and 12,180 vertices for q = 13, 17, 29; girths 8, 8, 9; Ramanujan; SHD-CCP’s Hurwitz products, halved, equal our tree’s quaternions. |
| S6 | Node and Chromium are at Unicode 17.0, Python at 15.1; a pinned 15.1 table matches Python on all 1,112,064 code points; a 20,520-case stress set. |
| S7 | BioChain-AI’s ATTEST/1 signatures cross between browser and Python only through a padded P1363–DER conversion; verification takes about 0.2 ms. |
| Phase | Delivers | Status |
|---|---|---|
| 0 · Analysis | Pins, spikes S1–S7, the preregistration, eight explainers, proposals, the hub and this page | done |
| 1 · Python reference | The exact stages, Amendments 1 and 2, two reviews, one decisive run: L2, L3 (Python side), L5, L7 supported | done |
| 2 · Browser core | lexicon_core.js at line-for-line parity, Amendments 4 and 5, a review, one decisive run: L1, L3(f), L4(a, b) supported | done |
| 3 · Biochains | The grower in JS and Python, the records, the RFC 6962 manifest, the exact weave and the hardened, attested verifier; Amendments 7 and 8, a review, one decisive run: L8, L9, L10, L11 supported | done |
| 4 · Embeddings | The numpy float64 trainer and the exact evaluation of snapped tables, Amendments 10–12, a review, registered tuning, one decisive run: L6 and L4(c) supported, L6(c) against its prediction. The Stage-2 lexical claims planned here were registered later, in Stage 2 | done |
| 5 · 2D and 3D pages | The exact trees in the disk and the ball, a shard panel and an Engram Mind’s Eye import; Explainers 13 and 14 | done |
| Stage 2 · Lexical | L12–L15 on HyperLex, BLESS, WBLESS, HiT, SimLex, MEN, WordSim and GloVe; Amendments 13–15, a review, a sealed dry run, registered tuning, one decisive run: nine parts supported, L12(d) and L15(a) refuted, as predicted; Explainer 15 | done |
| Stage-1 gate | A review with you of L1–L15 and what Phases 1–5 and Stage 2 built, before any encoder code | next |
| 6 · CPU encoder | 1–10M parameters, BabyLM 10M, claims L16–L19 by amendment | here or your machine |
| 7 · GPU track | BERT-mini/small, BabyLM 100M, GLUE | your GPU |
| 8 · Integration | engram/2 in Engram Mind’s Eye; proposals delivered | here |
proposals/README.md); they can go to the SHD-CCP, BioChain-AI and Owl Academy maintainers when you choose.