Contents
Where this sits
The pins and the spikes feed the preregistration, and the preregistration feeds the Python reference and the browser core that will decide every claim. This page’s focus node is the preregistration.
Phase 0 is analysis, seven measurement spikes and a preregistration; there is no model code. The spikes have finished. Each script and its captured output sit in spikes/, and every spike number on this page comes from those outputs and is called a spike result (“spike S3 measured …”); in the claims table, spike numbers appear as the preregistration rounds them. The claims are summarised from PREREGISTRATION.md, the authority on what each claim says; where this page and that file differ, the file wins.
The grey blocks copy output lines exactly, chosen and shortened by leaving lines out, never by editing one. Lines that begin with “~” carry timings and runtime versions, which change from machine to machine. They are never quoted in a block, and where the prose uses one, it says so.
A spike result is a measurement on data no claim uses. It decides nothing. A claim is registered with its instances, controls, decision rule and prediction. Phase 1 decided four (L2, L3’s Python side, L5, L7), Phase 2 three more (L1, L3(f), L4(a, b)), Phase 3 four (L8–L11) and Phase 4 two more (L6, L4(c)); all are supported. Stage 2 decided L12–L15 part by part: nine parts supported and two refuted, L12(d) and L15(a), both predicted refuted. A prediction is not a decision: “predicted refuted” means the registered prediction, fixed in advance, expects the test to come out that way. L6(c) was predicted refuted and came out supported (Explainer 12).
exact: integers, rationals or bytes, identical in every engine. float: floating point, rounded at every step.
- Spike
- A short measurement script run before the claims were written, to fix a fact the design depends on. Each has a header (what it measures, how to run it, what it settles, its data and seeds) and a captured output ending in a SETTLES block.
- Preregistration
- Writing down, before any code that tests a claim exists, what will be tested, on which data, how it will be decided and what is expected.
- Instance
- The registered data a claim is decided on, such as all 82,115 WordNet noun synsets.
- Control that must fail
- A deliberately broken variant of a test. It must show its weakness on at least one case. If it passes, the test cannot tell good from bad: it is void, and is repaired by amendment.
- Decision rule
- The rule, fixed in advance, that turns a result into supported, refuted or inconclusive. Exact claims are all-or-nothing: one failure refutes, and is recorded as a counterexample.
- Dry run, decisive run
- A dry run exercises a runner on unregistered seeds and data. The decisive run is the one that decides, on the registered instances.
- MAP
- Mean average precision. For each query node, rank every other node by distance and measure how high its true neighbours come; average over queries; 1 is perfect. Graph-edge MAP counts the parent and the children as neighbours; closure MAP counts every ancestor and descendant.
- Pessimistic ties
- When a neighbour and a non-neighbour are exactly equally far, the neighbour ranks after. This is the registered rule; optimistic values are shown only for contrast.
- Virtual letters
- Under the address rule a node with c children gives each child m = max(1, ⌈log₅ c⌉) letters. With more than 5 children, each child gets two or more letters (up to 4 in the verb forest; under the noun with 659 children, 5), and the letters beyond the first stand for no WordNet node (Explainer 3).
The order of Phase 0
Phase 0 ran in a fixed order, so that no case a claim is decided on could have shaped the claim.
- Pin the data. WordNet 3.0 and UD English EWT are fixed by hash and count, fetched once into a cache outside git (chapter 3). The nouns, which most claims are decided on, were touched only to count and hash them: the metadata needed to define the instances.
- Run the spikes. Seven scripts, each with its captured output, on data disjoint from every registered instance: WordNet verbs and adjectives, Owl Academy’s canon tree, synthetic words, repository Markdown and full Unicode sweeps. Their seeds are 90000 + i, which no later run may reuse. They decide no claim.
- Register the claims. PREREGISTRATION.md, registered 2026-11-05, was committed alone, before any code that tests the claims exists. It holds L1–L11, the design inputs D1–D12, the common rules and the shared instances. Amendment 13, committed alone on 2026-11-07 before any Stage-2 code, added L12–L15.
- Then everything else: the hub, the eight explainers (this page among them), the README, the proposals, the tests and the summary.
Why spikes come first
A design rests on facts nobody has measured yet: how deep float64 stays correct, which boost makes an H² tree decodable, how long WordNet’s addresses get. Measured on the registered instances, they would be circular: the claim would be fitted to the cases that decide it. So each spike measured its fact on disjoint data, and the claims were written afterwards, against instances no spike had touched except to count or hash them.
The preregistration puts it this way: the spikes “fixed facts the design depends on, and three of their values are written into this file where marked (S3 in L6(c), S4 in L8 and L10, S6 in L1). They decide no claim.” Other spike results appear in the predictions, as expectations, never as findings.
The design fixed a rule before spike S3 ran: L6(c)’s prediction would read “supported if S3’s exact-tree graph-edge MAP on verbs is ≥ 0.90, otherwise refuted” (the rule is quoted in S3’s own header). S3 measured 0.6309, so the registered prediction reads refuted. The claim was decided in Phase 4, on the mammal closure, against learned embeddings (chapter 7), and came out supported: the prediction was wrong (Explainer 12).
After Phase 0: dry runs, then the runner, then the decisive run
From Phase 1 on, every runner follows Engram Mind’s Eye’s discipline. It is first dry-run on unregistered seeds and on the dry-run data each claim names (the verb forest, repository Markdown, synthetic shards). Then the runner is committed. Only then comes the decisive run on the registered instances. Engram ran its first nine claims this way on 2026-11-04, with the runner committed beforehand (its evidence page).
| Draws | Seeds (common rules) |
|---|---|
| Instances | 1000 + i |
| Secondary draws | 2000 + i |
| Dry runs | 4000 + i (and +3000 on every other seed) |
| Tuning | 9000–9023 |
| Training | 0–4 |
| Spikes (never reused) | 90000 + i |
| Bootstrap intervals | seed 7, 10,000 resamples |
Both languages draw from one generator, hyperbolic_core.js Rng and reference/hpstep/prng.py (xoshiro128** seeded by splitmix32), so Python and JavaScript draw the same instances. Spike S5 checked this on its own words: Node regenerated all 1,000 of them bit for bit.
Changes. A later change to the preregistration is recorded as a dated amendment at its end, with its reason, and results computed before an amendment are reported under the rules in force when they ran. Sixteen have been made. In Phase 1, before its decisive run, Amendment 1 fixed the definitions the registration left open, among them the algorithm that trains the V0 “lex0” vocabulary (L1), and Amendment 2 records a disclosure, an erratum and the readings fixed in the code; Amendment 3, after the run, corrects Amendment 2. In Phase 2, Amendments 4 and 5, before its decisive run, fixed how the engines are run and compared and recorded the disclosures; Amendment 6, after it, is an erratum to L6’s protocol attribution (chapter 13). In Phase 3, Amendment 7, before any code, fixed the definitions L8–L11 left open, and Amendment 8, after the dry runs and before the decisive run, fixed which packages are timed, replaced L11’s control and recorded the disclosures (chapter 12); Amendment 9, an erratum written with the write-up, records three stale texts in the decisive record and changes no result. In Phase 4, Amendment 10, before any code, fixed the definitions L6 and L4(c) left open (the training protocol, the numerics, the statistics) and recorded an omission: Phases 1 and 2 never reported fractional-tie values; Amendment 11, after registered tuning and before any measured run, froze L6’s learning rates in reference/settings.json and gave every tuning run; Amendment 12, an erratum written with the write-up, corrects one sentence of Amendment 11 and changes no result (Explainer 12). In Stage 2, Amendment 13 registered L12–L15 before any code; Amendment 14, after the dry run, recorded the readings fixed in the code and changed no definition; Amendment 15 froze L14’s learning rates before any measured run; and Amendment 16, an erratum written with the write-up, records the Node re-evaluation’s file name and corrects one sentence and one figure of Amendment 14; it changes no rule and no result (Explainer 15).
The pins
Two outside datasets are pinned by hash. A third shared instance, the Unicode stress set, was written by spike S6 and is pinned by its hash in the same way. Phase 1 added four pins: the Unicode 15.1 table, the V0 and V1 vocabularies and L1’s instance lists (Explainer 9).
reference/golden/make_wordnet_v1.cjs and make_ewt_v1.cjs fetch the data once into ~/.cache/hyperbolic-lexicon, outside git, and record every file’s hash and the counts the claims use. Run with --check, they recompute everything; without the cache they report “skipped” and exit 2, never “passed” (reference README).
WordNet 3.0
| Pinned | Value (wordnet_v1.meta.json) |
|---|---|
| Archive | nltk_data wordnet.zip, 10,775,600 bytes, SHA-256 cbda5ea6…2646ab59; data.noun 489f145e…58b614cc |
| Synsets | 82,115 nouns · 13,767 verbs · 18,156 adjectives (10,693 satellites) · 3,621 adverbs |
| Noun spanning tree | Spanning parent: the first @ or @i pointer; children by synset offset. One root, 00001740 entity.n.01; depth 19; 16,897 internal nodes; up to 659 children; 6,162 nodes with one child, 3,291 with more than 5, 396 with more than 25 |
| Noun closure | 743,241 hypernym-closure edges (hypernym and instance hypernym); 2,213 nodes with several parents |
| The mammal sets | mammal.n.01 = 01861778. Closure set 1,182 synsets, 6,542 edges (c4748ce2…); spanning subtree 1,176 synsets (31c43a5b…) |
| Lemma types | 147,306 (L2’s types before normalisation) |
| C0, the gloss corpus | The noun synsets in offset order, one line each (offset, lemmas, gloss), cut at line boundaries into 148 shards of at most 60,000 UTF-8 bytes: 147 full ones (≥ 59,000 bytes; the largest 59,999) and one of 20,962. Every shard’s SHA-256 is listed |
| Verb forest (spike data) | 559 spanning roots, 3,309 internal nodes |
| Licence | The WordNet licence, copied as LICENSE-WORDNET.txt |
UD English EWT
Commit 4a4d77f599ea53cc405f85d0cec4b2f14f81d42b, CC BY-SA 4.0. Only hashes and counts are committed, never the text (ewt_v1.meta.json). Its 16,622 # text = sentences are L1’s instance (b).
| File | Bytes | Sentences |
|---|---|---|
| en_ewt-ud-train.conllu | 15,034,493 | 12,544 |
| en_ewt-ud-dev.conllu | 1,898,574 | 2,001 |
| en_ewt-ud-test.conllu | 1,900,101 | 2,077 |
The Unicode stress set
spikes/s6_stress_set_v1.json: 360,160 bytes, 20,520 cases, SHA-256 bd1179ea…f6e94a. It holds the 9,990 code points on which Node, Python and Chromium disagree, each alone and in ASCII context, plus 540 explicit cases. It is L1’s instance (c) (chapter 10).
node "Pages/Hyperbolic Lexicon/reference/golden/make_ewt_v1.cjs" --check
Seven spikes at a glance
Each spike asked one question the design could not answer on paper. The table gives the question, the method, the data, what it settled and which claim it informs; the next seven chapters take them in turn.
- The code as it is. The shared cores load unchanged. Owl Academy’s and BioChain-AI’s JavaScript runs from their checkouts by name-grab (taking a function by its name from the file), and their Python only as
python3 -B -Iwith an explicitsys.path. Nothing is written into the other repositories. - Deterministic. Every output line that does not start with “~” must come out identical on a rerun, and
tests/spikes.cjschecks it. - Checked two ways. Each spike recomputes its key values by a second route, and a difference fails a check: S3 has an independent Python script, S2 computes every point twice, S5 checks its eigenvalues by power sums and by Lanczos, S7 runs both languages on the same tampered strings.
| Spike | Question | Method | Data | What it settled | Informs |
|---|---|---|---|---|---|
| S1 Node | How deep can floats rank and decode the exact H³ tree, and what do exact points cost? | Exact and float distances; rank inversions by depth 1–40; bits to depth 60; MAP on small trees with virtual letters | Synthetic words | Ranking must be exact: float64 first inverts at depth 10 (straight) and 12 (random). At depth 28, ≤ 139/79 bits (random words; 157/79 on the straight word). Virtual letters create exact ties | L3, L4, L6(c) |
| S2 Node | Which rational boost gives an exact H² tree that decodes? | The tree on rational directions for six values of m; 500 words per depth to 28; bits; a float sweep | Synthetic words | t = 11/13 decodes 500/500 at every depth; t = 3/4 fails; 1.28×–2.38× the bits of H³ | D3, L3, L4 |
| S3 Node + Python | What do WordNet-shaped trees look like under the address rule, and how well does the exact tree rank them? | The L3 rule; every exact point; exact graph-edge and closure MAP over every query; an independent Python recomputation | WordNet verbs; Owl’s canon tree; noun counts only | Verb graph-edge MAP 0.6309; 99.96% of verb words fit 25 letters; no query sampling needed for verbs | L3, L5, L6(c) |
| S4 Node + Python | Can a gloss shard be an Owl Academy biochain, and what does that cost and miss? | A spike-only grower against Owl’s own, field for field; Python ports; tampers; RFC 6962 trees; the exact weave | WordNet verb and adjective glosses; 1,000 synthetic shards | 126/126 records identical; a faithful Python weave port agrees on 1,000/1,000; verifyIntegrity’s gaps; proofs of ≤ 14 hashes at 10,000 leaves | D8, L8–L11 |
| S5 Python | Is SHD-CCP’s planned X(5, q) overlay a quotient of our tree, and what are its facts? | The LPS map for q = 13, 17, 29; exact girth three ways; dense eigenvalues; SHD-CCP’s Hurwitz product | 1,000 synthetic words | 2,184, 4,896 and 12,180 vertices; girths 8, 8, 9; Ramanujan; the Hurwitz identity | L7; RFC 03 proposal |
| S6 Node + Python + Chromium | Do the three runtimes agree on Unicode, and can a pinned table make them agree? | Every code point in each runtime; the disagreements as a stress set; a 15.1 table; a toy WordPiece in all three | Full Unicode sweeps; synthetic strings; repository Markdown | Pinned tables (D5): 0 mismatches on 1,112,064 code points; the stress set and its hash; L1’s control 1 fails as required | D5, L1 |
| S7 Node + Python | Can BioChain-AI’s ATTEST/1 signatures be checked identically in Node and Python? | BioChain’s code as written; sign in WebCrypto, verify in both; tamper every position; the reverse direction; a golden vector | Synthetic shards; random keys and RFC 6979’s test key | A padded P1363 ↔ DER conversion is required; the high-S twin verifies; the whole attestation step took 0.23 ms here (a timing) | L10, L11 |
S2 settled the H² boost t = 11/13 that D3 fixes. S6 confirmed D5’s pinned tables, showed that the export must include the two Final_Sigma sets (Python’s unicodedata does not expose them), and fixed L1’s control 1 as the platform normaliser “exactly as spike S6 implemented it”. S4 settled D8 and found residual aliasing, the source of L10’s tamper class T9 and its re-encode check; it also showed that the controls planned for L8 (the 0x80 packing) and L9 (the duplicated last leaf) can fail as they must. S7 found that a signature’s high-S twin also verifies, which is why L10’s importer “keys nothing by signature bytes”. S3 fixed L6(c)’s prediction.
proposals/check_kernel.py is a test. It lints the proposed SHD-CCP kernel 0xA, the Hyperbolic Address Tile, with SHD-CCP’s own Kernel Ontology tooling, read-only (the proposal). The kernel holds a reduced word of up to 25 letters in a 59-bit field, the limit spike S3 measured against. Its output, run on this container with an SHD-CCP checkout beside this one:
kernel Hyperbolic Address Tile (norm-5, LPS p=5) · Form 0xA · Domain Codex_Semantics · Status [OPEN] lint_kernel: pass layout_integrity: pass (3 fields tile bits 0..63 exactly once) glass_box_round_trip: pass (1000 random round trips and 3 isolation checks) pending suites (block [PROVEN]): 01_tqf_parity_checks, 02_toda_kogame_stress, 03_merkle_collision Form IDs already used in the registry: 0x0, 0x1, 0x3, 0x4, 0x6, 0x8, 0xc; 0xA is FREE allocation hash: 1aefabb16b7b12c3559b19700efa999120537a5cfe2cc9769473dafed8654126 kernel check: pass
“0xA is FREE” holds in the Ontology’s registry only: inside Owl Academy’s and BioChain-AI’s streams Form 10 is the ROT gate (Explainer 2).
Rerunning them
node "Pages/Hyperbolic Lexicon/tests/spikes.cjs" --all
python3 -B -I "Pages/Hyperbolic Lexicon/proposals/check_kernel.py"
The first line reruns the quick set (S1, S6, S7, about a minute), the second all seven (about ten minutes). A spike whose data or checkout is missing (the WordNet cache, Owl-Academy, BioChain-AI or SHD-CCP beside this repository, numpy, Playwright’s Chromium) is reported as skipped, never as passed (tests/spikes.cjs).
S1 · The H³ tree, exact against float
s1_h3_tree_metrics.cjs · output. The H³ tree gives every word an exact point. How deep can float64 go before it ranks or decodes those points wrongly, and what do exact points cost?
The method. All on TreeEmbedding3D as it is, with the boost t = 3/4: cosh τ = 25/7, sinh τ = 24/7, τ = ln 7. A word of length n is a point whose coordinates are integers over 7ⁿ. The spike measured exact distances between relatives; how often hyperbolic distance reverses tree-distance order on the 937 words within 4 letters of the root; graph-edge MAP on small subtrees, some with virtual letters; and, at each depth 1–40, the ranking of 21–26 nearby candidates (parent, grandparent, siblings, uncles, children and some grandchildren) exactly and in three float modes. It also measured the bit cost of exact points up to depth 60. Words come from Rng(90000 + n); the straight word always takes child 0, a geodesic, and float64 ranking inverts on it first.
parent-child [0] [0,0]: cosh d = 25/7, d = 1.9459 siblings at 90 deg (straight vs bent) [0,0] [0,2]: cosh d = 625/49, d = 3.2375 (law of cosines with cos theta = 0: equal) siblings at 180 deg (bent +y vs bent -y) [0,2] [0,3]: cosh d = 1201/49, d = 3.8918 (law of cosines with cos theta = -1: equal) total: 2264600 comparisons, 47352 reversed (2.09%), 0 tied (0.00%); first source recounted with direct Q comparisons: equal
Children 1–4 leave at 90°, so a bend shortens a two-edge path by 0.6543, a loss that tends to ln 2 for long edges. Hyperbolic distance is therefore not tree distance. It reversed tree-distance order in 2.09% of comparisons, never across a gap of more than two hops.
Float against exact. Each row reads: among 20 random words of length n, how many rankings invert an exactly strict order / fail (invert, tie or a non-finite float32 product) in three modes: point(), the float placement; f64 exact, the exact point rounded once; and f32. Then the straight word’s status, and how many of 50 words float decoding returns.
n=10 random 0/ 0 | 0/ 0 | 20/20 straight inv | inv | tie decode random 50/50 | 50/50, straight ok | ok
n=12 random 3/ 4 | 1/ 2 | 20/20 straight inv | tie | tie decode random 50/50 | 50/50, straight ok | ok
n=13 random 14/15 | 13/14 | 20/20 straight tie | tie | tie decode random 49/50 | 49/50, straight ok | ok
n=15 random 20/20 | 20/20 | 20/20 straight tie | tie | tie decode random 24/50 | 29/50, straight ok | ok
first depth with an inversion, random words: f64 point() 12, f64 exact 12, f32 5
first depth with an inversion, straight word: f64 point() 10, f64 exact 10, f32 5
first depth at which float decode fails, random words: point() 13, rounded exact 13
decodeExact(pointExact(w), n) returned the word on 840/840 ranked words; the adjacent-level and all-pairs inversion tests agreed on every ranking
- Bit budget: at depth 28, <= 139-bit numerators (random), 157 (straight) and 79-bit denominators (7^28); at depth 60, 297 / 336 / 169. Every coordinate at depth n is an integer over 7^n and every Lorentz product an integer over 7^(n_a + n_b), so ranking by an integer key is exact. - Graph-edge MAP with pessimistic ties: perfect 5-ary subtree of depth 3 = 1/1 (0 neighbour/non-neighbour ties); root with 25 children (m = 2) = 0.995703; root with 125 children (m = 3) = 0.995276; 25-ary at every level (m = 2) = 0.260362 (optimistic 0.845473). Neighbour/non-neighbour exact ties appear only with virtual letters (25, 120 and 525 queries): the virtual-letter tie effect behind the doubt in L6(c).
What it settled. Ranking must be exact. Float64 first inverts an exactly strict order at depth 10 on the straight word and 12 on random words, and fails on all 20 random words from depth 15. Float32 inverts from depth 5 and overflows from 23. Float decoding first fails at depth 13 on random words; exact decoding never failed. At depth 28 exact points need at most 139-bit numerators on random words (157 on the straight word) over 79-bit denominators, and every Lorentz product is an integer over a power of 7, so ranking by an integer key is exact. Exact ties between a neighbour and a non-neighbour appear only where virtual letters occur. On this container an exact point at depth 28 took about 1.6 ms against 3 µs in floats (a “~” line).
What it informs. L3’s control 3 (float decoding must fail beyond 12 letters); L4(b) and both L4 controls (float32 inverts; a float evaluator with index tie-breaking differs where exact ties exist); the bit budget in L3’s report; and the tie effect behind L6(c) (exact ranking in Explainer 3).
This runs S1’s item 4 at one depth on Hyperbolic Oracles’ cores, unchanged: the same 50 words from Rng(90000 + n), the same candidates, the same three float modes, the same row format. Floats in JavaScript follow IEEE 754 in every browser, and Q.toNumber rounds exactly, so the row must match the captured one character for character. Deeper rows take longer; depth 24 takes well under a second in a current browser.
- 5: float32 already inverts on 6 of 20 random words, while float64 is still clean.
- 10 and 12: the straight word inverts first, then random words begin to.
- 13 to 16: rankings collapse, and float decoding starts to return wrong words.
- 23: the straight word’s float32 products overflow (“nf”, not finite). Exact decoding still returns all 21 ranked words.
S2 · An exact H² tree
s2_h2_exact_tree.cjs · output. No exact tree existed in the hyperbolic plane: the old one is built from cos and sin. Which rational boost lets greedy decoding recover every word exactly, and what does it cost against H³?
The method. The tree uses only rational directions: (1, 0), (3/5, ±4/5), (−7/25, ±24/25) and (−1, 0), at 0°, ±53.13°, ±106.26° and 180°. Each step rotates, then boosts with cosh + sinh = m, so τ = ln m and t = (m − 1)/(m + 1). For m ∈ {3, 5, 7, 12, 19, 20} (and 8–11 as a supplement) it decoded 500 random words per depth exactly, checked the sheet identity x₀² − x₁² − x₂² = 1 exactly on every point, computed every point a second way in BigInt, counted bits, and swept float64 decoding.
depth 2 4 6 8 10 12 16 20 24 28 m=3 t=1/2 303 105 23 7 4 1 0 0 0 0 m=7 t=3/4 500 443 376 311 274 226 148 124 84 55 m=12 t=11/13 500 500 500 500 500 500 500 500 500 500 m=20 t=19/21 500 500 500 500 500 500 500 500 500 500 H^3 t=3/4 500 500 500 500 500 500 500 500 500 500 (decoder3d decodeExact, octahedral tree) exact ties among the best-scoring children: 0 in 390000 greedy decisions (none happened) planning replay, Rng(90001): 100 words at depth 12 then 40 at depth 28 from the same stream: t = 11/13 100/100 and 40/40; t = 3/4 48/100 and 1/40
Why some m fail: greedy decoding picks the child direction nearest the point, so each child’s whole subtree must stay within the bisector between neighbouring directions (26.57°). The spike measured each subtree’s exact half-width seven levels down.
margin to the bisector at 7 levels (a lower bound on the half-width, so an upper bound on the margin): m=10 2.01 · m=11 6.00 · m=12 8.72 · m=19 16.96 · m=20 17.54 degrees range of the per-coordinate ratios at t = 11/13 over the four classes: 1.28x .. 2.38x worst over all classes at depth 28: H^2 t = 11/13 251/188 bits, H^3 157/79 bits (1.60x, 2.38x) - float64 (same construction) at t = 11/13 keeps 500/500 up to depth 8 and reaches 0/500 at depth 20; exact rationals are required beyond that.
What it settled. D3’s boost, t = 11/13 (cosh 145/24, sinh 143/24, τ = ln 12): 500/500 at every depth from 2 to 28, with no exact ties. The threshold lies between m = 9 and 10. m = 10 and 11 decode as well, but m = 12 keeps the widest margin of the three (8.72° against 2.01° and 6.00°) and the fewest bits at depth 28 (225/152 against 247/185 and 235/167). The H³ boost t = 3/4 in the plane decodes only 226 of 500 words at depth 12. The H² tree costs 1.28×–2.38× the bits of H³ per coordinate at depth 28. The S2 replay also reproduced the design’s earlier planning check (100/100 and 40/40 at t = 11/13; 48/100 at t = 3/4).
What it informs. D3; L3(e) in H² and L3’s control 4 (the H² tree at t = 3/4 must fail); the bit cost of L4’s H² ranking (placement in Explainer 3).
S3 · WordNet’s shape, on verbs
s3_wordnet_shape.cjs and .py · output. Under the address rule, how long do WordNet-shaped words get, and how well does the exact H³ tree rank a real hierarchy?
The method. The nouns are the registered instances, so the spike used the verb forest: 13,767 synsets with 559 roots. The roots were read as children of a virtual root at the word [1], 4 letters each. It also used Owl Academy’s canon tree (169 nodes: canon, 10 departments, 13 artifacts, 145 tomes). On each it applied the L3 rule, computed every exact point, and ranked every query against every other node by the exact Lorentz product, as integers. Then it computed graph-edge and closure MAP with pessimistic ties, over all 13,542 verb queries. An independent Python script recomputed the words, points, rankings and both MAPs with integers and Fractions. Nouns were only counted.
VERB GRAPH-EDGE MAP (exact H^3, L3 rule) = 0.6309 over 13542 queries
graph-edge MAP exactly: 205-digit / 205-digit rational, sha256("n/d") 2e428dd7f198b81b0ee0e824404aefaf40ed3542a292c761eb7664968ad0efb2; truncated 0.6308581090844327
queries with AP < 1: 7893/13542; with a neighbour tied exactly with a non-neighbour: 5396/13542; optimistic-tie MAP (contrast only) 0.8149
m_in=1 5357 queries, MAP 0.9974
m_in=2 5195 queries, MAP 0.4087
m_in=3 1928 queries, MAP 0.3217
m_in=4 1062 queries, MAP 0.4301
The last four lines split the queries by m_in, the number of letters on the query’s own edge from its parent. They show where the score is lost. A query whose own edge needs one letter scores 0.9974. Where the edge needs two to four letters, its siblings under the same virtual prefix sit as close as the parent or closer, and the score falls to 0.32–0.43. Owl Academy’s canon tree, where departments and tomes take two letters each, scores 0.3544.
maximum word length 26; words with <= 25 letters: 13762/13767 (99.96%); <= 27 letters: 13767/13767 (100.00%)
20 replicate 1,000-query samples Rng(90010..90029): graph-edge 0.6114..0.6427 (sd 0.0085), closure 0.4028..0.4347 (sd 0.0084)
verb graph-edge MAP: node 0.6308581090844327, python 0.6308581090844327 (truncated to 16 decimals); the exact rationals are equal (same reduced n/d, by SHA-256), so |difference| = 0
What it settled. The value behind L6(c)’s prediction rule: 0.6309, an exact 205-digit rational, reproduced exactly by the Python recomputation. Against the rule’s threshold of 0.90, L6(c)’s registered prediction reads refuted: a prediction fixed by the rule, not a decision. Phase 4’s decision went the other way: (c) is supported (Explainer 12). The closure MAP on the same queries is 0.4206. Verb words reach 26 letters; 13,762 of 13,767 (99.96%) fit the kernel’s 25-letter tile and all fit 27 (id64), so 5 would need a continuation tile. Points need at most 133-bit numerators and 73-bit denominators. All queries were ranked, so nothing was sampled; a 1,000-query sample would have moved the verb MAP by up to 0.0195. Ranking all 13,542 queries took 35.5 s in Node on this container (a “~” line).
The verb forest needed a virtual root; the noun tree has one real root, entity.n.01, so the nouns need no such reading. Nouns are deeper (spanning depth 19) and wider (up to 659 children), so a larger minority of their words may pass 25 or 27 letters, and L3 reports that share: in Phase 1, 7,485 of the 82,115 noun words (9.1%) passed 25 letters and 3,565 (4.3%) passed 27. The noun MAP was measured in Phase 1 too (L5: graph-edge MAP 0.5679 for the exact H³ tree on the 1,000 noun queries; Explainer 9), and on the mammals Phase 4 compared the exact tree with learned embeddings (L6): learned Lorentz d = 3 ranks the closure far better (closure MAP 0.950–0.971 against 0.305408) and the graph edges worse (0.458–0.477 against 0.690653; Explainer 12).
What it informs. L6(c)’s prediction; L5’s prediction that the exact tree’s MAP falls below 1 where virtual letters occur; L3’s word-length report; the 25-letter limit of kernel 0xA (proposal).
S4 · A lexicon shard
s4_lexicon_shard.cjs · output · s4_python_pack.py · output. Can a WordNet gloss shard be an Owl Academy biochain, unchanged, and what do Owl’s own checks miss?
A biochain is Owl Academy’s record of grown text: the shdccp/2 stream of 64-bit packets, one per 720-byte chunk, with leaf hashes, a Merkle root, two float “weaves” and a chainId. A lineage is capped at 60,000 bytes, so a corpus becomes many shards (Explainer 4).
The method. 22 verb and 33 adjective gloss shards (disjoint from C0, which is nouns) and 8 synthetic shards were grown, with engrams on and off, by a spike-only synchronous grower: biochain_v1.js’s verbatim codec with orbital_core’s SHA-256. Each was compared field for field with Owl’s own growBiochain, run unchanged. The spike then ported the weave to Python on 1,000 synthetic shards and packed chunks with BioChain-AI’s Python kernel. It tampered with records, built RFC 6962 trees of 1,000 and 10,000 leaves, tested the shdccp/2 Merkle rule, computed one shard’s exact norm-5 weave, and imported every verb shard into Engram Mind’s Eye.
Selected lines on equality and the Python ports:
verb shards, engrams off: 22/22 records identical; mismatching fields: none adjective shards, engrams on: 33/33 records identical; mismatching fields: none synthetic shards, engrams on: 8/8 records identical; mismatching fields: none Owl's verifyIntegrity accepts 63/63 engrams-off records; the decoded stream equals the shard's bytes on 63/63 faithful Python port (V8's Math.hypot algorithm, exact toFixed(12)): weaveChiral differs on 0, weaveMirror on 0; shards with any difference 0 of 1000 naive Python port (math.hypot, format(x, '.12f')): weaveChiral differs on 2, weaveMirror on 1; shards with any difference 2 of 1000
A naive Python port fails because Python’s math.hypot differs from V8’s Math.hypot on 30.9928% of calls, enough to change a 12-decimal weave string now and then (Explainer 2).
What Owl’s checks miss. verifyIntegrity checks self-consistency, and some alterations stay self-consistent:
T1 leafHashes and merkleRoot deleted: Owl ACCEPTS; EngramCore accepts; stream unchanged
T2 packet 0 crystal32 bit 0 flipped, parity re-fixed: Owl ACCEPTS; EngramCore accepts; stream sha256 changed
T8 chainId altered (last hex digit): Owl ACCEPTS; EngramCore accepts; stream unchanged
one bit of a raw-byte rank code flipped (frame 0, residual bit 30; decodes the same): Owl ACCEPTS; EngramCore accepts; stream sha256 changed
T7 frames 0 and 1 swapped (control: must be rejected): Owl rejects (leaf 0 mismatch); EngramCore rejects; stream sha256 changed
every single-bit flip of frame 0's residual, verb 00-03: 689 of 19400 (3.5515%) decode to the same 720 bytes: 8 in the final byte's padding, 681 inside a rank code that reads a raw byte, 0 elsewhere
re-encode check on those flipped copies: rejects 689 of 689
The rank coder reads a raw byte for any rank above its candidate count, so an escape code has aliases: 3.5515% of single-bit residual flips decode to the same bytes. Leaves and root commit to decoded bytes only, so such a stream verifies. Re-encoding each chunk and comparing it with the stored residual rejects all 689.
Manifests and the exact weave.
the certificate-transparency reference vector (8 entries, roots of every prefix n = 0..8): 9/9 roots equal
inclusion proofs: 10000/10000 verify; rejected for the next leaf's hash 10000/10000, at the next position 10000/10000; length 8-14 hashes (mean 13.6320), at most 448 B
K = 1..200, L and L + [last]: equal roots at K = 3, 5, 7, ..., 199 (99 values, step 2); exactly the odd K >= 3: true; K = 1: false
RFC 6962 roots of the same lists, L against L + [last]: equal at 0 of 200
K = 84 leaves, 2352 letters; norm (sum of squares) = 5^(28K) = 5^2352 exactly: true (log2 = 5461.2; sqrt bound 2730.6 bits)
The shdccp/2 rule duplicates an odd last node, so a list and the same list with its last leaf repeated share a root at every odd length from 3: the CVE-2012-2459 class (Lemma 15 note). The RFC 6962 roots of the same lists were never equal (0 of 200).
Costs and the 0x80 byte.
stream hex 5,437,860 chars = 1.7120 per byte; residual 2,665,518 B = 6.7134 bits per byte (rank coder alone)
value: engrams off median 1.1016 (range 1.0334-1.3070), engrams on median 0.4860 (0.4426-0.5194)
all gloss shards: 64 of 4529 chunks = 1.4131% (z = -0.76 against the analytic share); shards with at least one: 39 of 55
the normalised stream differs from Owl's on 43 of 63 shards (exactly those with a 0x80 chunk: true)
recomputed from the normalised stream (decode, leaves, root, weaves, chainId): merkleRoot unchanged 63/63, both weaves unchanged 63/63, chainId unchanged 63/63 (from Owl's own stream: 63/63)
Owl writes a crystal byte 0x80 as it is; BioChain-AI’s kernel writes 0x81. Leaves, root and weaves are computed from chunk bytes, never from packet words, so they do not see the difference: a verifier must re-crystallize to check packets (Explainer 2).
What it settled. D8: shards of at most 60,000 bytes in unmodified shdccp/2, tied by RFC 6962 manifests. The spike grower equals Owl’s on 126/126 records, and a faithful Python port of the weave equals Owl’s JS on 1,000/1,000 shards. It also settled what verifyIntegrity accepts that it should not, the proof sizes, and that the exact weave at K = 84 has norm exactly 52352 with components of 2,729–2,730 bits. On this container (“~” lines) the codec part of L11’s hardened verification took a median 41.0 ms per verb shard, and the re-encode check 23.5 ms more; Owl’s verbatim engram layer took 6,933.7 ms on one shard, against 131.5 ms for engram_core’s.
What it informs. The predictions of L8, L9 and L10; L10’s control 1 (Owl’s check must accept T1, T2, T8 and T9 records), its tamper class T9 and the re-encode check; L11’s expected range; the BioChain-AI proposal. In Phase 3, L8, L9 and L10 held as predicted; L11 was supported, but its median, 155.4 ms on packages grown with engrams off (a reading Amendment 8 fixed after the dry runs), is above that range (Explainer 11).
S5 · The LPS overlay X(5, q)
s5_lps_overlay.py · output. SHD-CCP’s RFC 03 plans Ramanujan graphs X(5, q) as an overlay. Our tree’s six generators, 1±2i, 1±2j, 1±2k, are exactly the Lubotzky–Phillips–Sarnak (LPS) set for p = 5. Is X(5, q) then a quotient of the tree our addresses live on, and what are its facts?
Terms. For a prime q with 4 | q − 1, pick ι with ι² ≡ −1 (mod q). The LPS map φq sends a quaternion to a 2×2 matrix mod q. Matrices equal up to a nonzero scalar are one vertex, and each vertex is joined to its products with the six generator matrices: a Cayley graph. Its girth g is its shortest cycle, so words of length up to r = ⌊(g − 1)/2⌋ cannot collide. It is Ramanujan when every eigenvalue other than ±6 has |λ| ≤ 2√5 = 4.4721.
The method. In Python with numpy, for q = 13, 17, 29: build each graph by breadth-first search from the identity and check its size, 6-regularity, inverse closure and bipartiteness. Compute the girth exactly three ways and test every reduced word up to length r. Reduce 1,000 synthetic words’ quaternions mod q and compare each with walking the word. Take the dense eigenvalues, checked by power sums and Lanczos, and multiply the generators with SHD-CCP’s own HurwitzQuaternion. Three controls must fail.
- q = 13: iota = 5, (5|13) = -1; 2,184 vertices = |PGL(2,F_q)| = q(q^2-1), bipartite, 6-regular, connected, inverse-closed, diameter 7; exact girth g = 8, so r = 3; largest nontrivial |lambda| = 4.249721, Ramanujan margin 0.222415 to 2 sqrt 5 = 4.4721. - q = 17: iota = 4, (5|17) = -1; 4,896 vertices = |PGL(2,F_q)| = q(q^2-1), bipartite, 6-regular, connected, inverse-closed, diameter 9; exact girth g = 8, so r = 3; largest nontrivial |lambda| = 4.308919, Ramanujan margin 0.163217 to 2 sqrt 5 = 4.4721. - q = 29: iota = 12, (5|29) = +1; 12,180 vertices = |PSL(2,F_q)| = q(q^2-1)/2, not bipartite, 6-regular, connected, inverse-closed, diameter 8; exact girth g = 9, so r = 4; largest nontrivial |lambda| = 4.442016, Ramanujan margin 0.030120 to 2 sqrt 5 = 4.4721. - L7(e): P.wordQuaternion = HurwitzQuaternion product of (2, +-4, 0, 0), (2, 0, +-4, 0), (2, 0, 0, +-4), halved (1,000/1,000 words); without halving it never matches. - L7 controls fail as required: iota = 2 breaks the walk identity at every q; the 4-generator subset is 4-regular; the unhalved Hurwitz product disagrees.
| q | ι | Group | Vertices | Bipartite | Girth g | r | Largest nontrivial |λ| | Margin to 2√5 |
|---|---|---|---|---|---|---|---|---|
| 13 | 5 | PGL(2, F13) | 2,184 | yes | 8 | 3 | 4.249721 | 0.222415 |
| 17 | 4 | PGL(2, F17) | 4,896 | yes | 8 | 3 | 4.308919 | 0.163217 |
| 29 | 12 | PSL(2, F29) | 12,180 | no | 9 | 4 | 4.442016 | 0.030120 |
What it settled. The facts the RFC 03 proposal cites, and L7’s feasibility. A word’s quaternion reduced mod q equals the vertex reached by walking the word, on 1,000 of 1,000 words at each q. Distinct words of length ≤ r reach distinct vertices, and collisions start at r + 1. SHD-CCP’s Hurwitz product, halved, equals our tree’s quaternion. The dense float64 matrix at 12,180 vertices is 1131.8 MiB; its eigvalsh took 161.2 s with a 2,308 MiB peak on this container (“~” lines). A mod-q reduction is a shard key, never integrity: LPS Cayley hashes have known collision attacks.
What it informs. L7 (a)–(e) and its three controls; the RFC 03 proposal; Explainer 2.
| Quantity | S5 captured (Python) | Here (JavaScript) |
|---|
A second implementation, in JavaScript on HPCore.P and Rng: the same ι, the same map, a breadth-first search from the identity, the girth as the shortest cycle through a non-tree edge, every reduced word up to length r + 2, and the 1,000 words of Rng(90000 + i) with their quaternions reduced mod q against the walk. Control (1) swaps in ι = 2, which is not a square root of −1, and must break the walk identity. Eigenvalues are not computed here.
S6 · Unicode in three runtimes
s6_unicode_wordpiece.cjs and .py · output · stress set. The front end must give the same bytes in Python, Node and Chromium. Do their own Unicode functions agree, and can a pinned table make them agree?
The method. For every code point except the surrogates (1,112,064), each runtime reported, with its own functions, the general category, the lowercase mapping, the canonical decomposition (NFD) and whether the code point is a nonspacing mark (Mn), the class a BERT normaliser deletes after NFD. Every disagreement became a case of the stress set, alone and between two ASCII letters, with explicit groups for Final_Sigma, U+0130, Hangul and canonical ordering. The spike then ran L1’s control 1, built a prototype Unicode 15.1 table from Python’s unicodedata, and ran a toy WordPiece in all three runtimes on the repository’s Markdown at commit 7b10514.
The runtimes (“~” lines, since they depend on versions). Node 22.23.4 reports Unicode 17.0 (ICU 78.3). Chrome for Testing 153 behaves as 17.0: it has 159,801 assigned graphic and format code points, the published 17.0 total. Python 3.13.18 reports 15.1.0. Node and Chromium agree on every value. Node and Python differ on 9,990 code points, nearly all assigned after 15.1; only U+0295 and U+1171E differ on code points assigned in both. The platform normaliser (toLowerCase, then NFD, then removing \p{Mn}) differs from Python’s reference on 725 of the 20,520 cases, in Node and in Chromium alike, 392 of them Final_Sigma cases.
python: 149,813 -> Unicode 15.1 (reports 15.1.0) committed file: 360,160 B, sha256 bd1179ea80eb3dd44e05a4efa0484f034a637a66d8f09ffe10e428f040f6e94a 20,520 cases: divergentAlone 9990, divergentInContext 9990, finalSigma 444, u0130 10, hangul 15, canonicalOrdering 71 9,990 divergent code points (= 9,990 in 159 ranges) by property: gc 9990, lower 55, nfd 20, mn 76
Final_Sigma is the context rule that makes capital Σ lowercase to final ς at the end of a word and to σ elsewhere, looking past case-ignorable marks. U+0130 (İ) lowercases to two code points, i and a combining dot. Python’s reference (hex code points):
[0041 03A3] -> [0061 03C2]
[0041 03A3 0042] -> [0061 03C3 0062]
[0041 03A3 0301] -> [0061 03C2 0301]
[0130] -> [0069 0307]
compact JSON: 142,041 B, sha256 7b3b2bf293f0484bbfb8b7226a9b329b2246172920d5ec1681501bfdba2bd237 (a prototype, not a pin)
exactness, table-driven lower + Final_Sigma + NFD + drop Mn against Python's own functions: every code point alone: lower 0, nfd 0, full 0 mismatches of 1,112,064;
python: words 29659, tokens 48007, unk 434, longWords 0, multiPieceWords 6506, streamBytes 63002, vocabSize 500
chromium: words 29659, tokens 48007, unk 434, longWords 0, multiPieceWords 6506, streamBytes 63002, vocabSize 500
vocab sha256 equal, id stream sha256 equal, text sha256 equal: identical to python
What it settled. D5’s pinned tables. A table-driven lowercase, Final_Sigma, NFD and Mn removal built from Python’s 15.1 data reproduces Python on every code point and on 2,000 synthetic strings. It takes 142,041 bytes as compact JSON (a prototype; the Phase 1 pin, reference/golden/unicode_15_1_v1.json, is 142,624 bytes). Final_Sigma needs the Cased and Case_Ignorable sets, which unicodedata does not expose, so the export must include them. It also settled the stress set and its hash, and that L1’s control 1 fails as it must. The toy WordPiece (ASCII pre-tokenizer, 500 entries) gives the same 48,007-token id stream in all three runtimes.
What it informs. L1: instance (c), the pool of instance (d) (the code points assigned after 15.1), control 1 and the prediction’s risk points (the normaliser in Explainer 3; Stage 0 in Explainer 7).
S7 · Attestation in two languages
s7_attestation.cjs and .py · output. Shard records will be signed in BioChain-AI’s ATTEST/1 format. WebCrypto writes an ECDSA P-256 signature as raw r‖s (IEEE P1363, 64 bytes); Python’s cryptography reads DER. Do signatures cross, and what may a verifier rely on?
The method. BioChain-AI’s attestation code ran as written, by name-grab, with Firestore replaced by an in-memory map. The spike built an LPREP/1-style commitment of 15 fields for a synthetic shard (Rng(97000)), with labelled placeholders for the hashes Phase 1 will compute. It signed the ATTEST/1 payload with a fresh P-256 key, verified in Node and in Python, and changed every character of payload, commitment and signature once. It also tried the signature’s high-S twin (r, n − s), went the reverse way (Python signs, Node verifies) and made a deterministic golden attestation under RFC 6979’s public test key.
payload = attestationPayload({ keyId, keyVector, contentHash, epochToken }): 137 characters = 8 + 1 + 26 + 1 + 16 + 1 + 64 + 1 + 19: true; equal to the plain join: true
the 200 signatures of Node's timed loop: verify after conversion 200/200
[L10 control] the same 200 given raw, as if DER: accepted 0/200; raised: InvalidSignature
[reverse control] the same 200 as DER, unconverted: WebCrypto accepts 0/200, verifyPayload 0/200; node:crypto, which reads DER by default, accepts 200/200
Python's signature with r < 2^248: left-padded P1363 (64 B) verifies: true; unpadded (under 64 B) verifies: false
identityId (not in the payload): valid true, reason 'verified', reported identityId is the registry's: true
registry status 'revoked' (L10 T4): valid false, reason 'key revoked — validity has been revoked'
commitment, all 582 positions in 15 fields and 14 separators: contentHash differs 582/582, signature over the rebuilt payload rejected 582/582
high-S twin (r, n - s): WebCrypto accepts: true; node:crypto accepts: true (ECDSA is malleable; neither enforces low-S, so signature bytes are not unique)
What it settled. L10’s encoding control: Python verifies WebCrypto signatures only after the P1363-to-DER conversion (0 of 200 raw), and the reverse conversion must left-pad r and s to 32 bytes; a short r or s occurs in about 1 signature in 128. ECDSA is malleable: the high-S twin verifies everywhere, so nothing may be keyed by signature bytes. Fields outside the signed payload (identityId, ownerUid, signedAt, format) do not affect the verdict, so the signer’s identity must come from the registry. On this container (“~” lines) BioChain’s whole attestation step took a median 0.2341 ms in Node and WebCrypto’s verify 0.1186 ms with the key imported once: 0.23 s for 1,000 shards.
What it informs. L10 (control 2, tamper class T4, the identity rule) and L11’s attestation term; the golden attestation is a known-answer vector for tests. The BioChain-AI proposal carries these cross-language notes. An attestation proves who signed a commitment, not that the text is licensed or correct. In Phase 3, Python without the conversion accepted 0 of 126 valid signatures (L10’s control 2), and the attestation step took a median 0.714 ms inside L11’s verification (Explainer 11).
The claims, L1–L15
Registered on 2026-11-05 in PREREGISTRATION.md, before any code that tests them. Each names its instances, the broken variants that must fail, how it is decided and what is expected. Phase 1 decided three of them, and L3’s Python side; Phase 2 decided L1, L3(f), which completes L3, and L4(a, b); Phase 3 decided L8, L9, L10 and L11; Phase 4 decided L6 and L4(c), which completes L4. L12–L15 were registered on 2026-11-07 by Amendment 13, after Phase 5, and decided in Stage 2 on 2026-11-08.
L2, L3 (its Python side, parts (a)–(e) and (g)), L5 and L7 were decided in one decisive run on 2026-11-05, on the code committed at 88e63f7, after Amendments 1 and 2, two adversarial reviews and a dry run. All four are supported under their registered decision rules, and every control failed as it had to. One registered prediction was wrong: L2 expected 2–10% of the lemma types to share their key, and the share is 52.6% (77,520 of 147,305). The results, the controls and how the run was prepared are in Explainer 9. The table below still summarises the registration; only the status tags have changed.
L1, L3(f) and L4(a, b) were decided in one decisive run on 2026-11-05, on the code committed at a1fe9a8, after Amendments 4 and 5, an adversarial review and a dry run, and once the browser core, lexicon_core.js, had passed all 18,667 lines of its parity test in Node. All are supported under their registered decision rules, and every control failed as it had to. L1: in all four cells (V0 and V1, each in Node and in Chromium) 0 of 156,801 instances differ from the reference, and every id-stream SHA-256 is equal; control 1, the platform’s own normaliser, differs on 725 of the 20,520 stress cases in both runtimes, as spike S6 found. L3(f): Node’s canonical point list of the 82,115 nouns has Python’s SHA-256, and all 2,000 sampled lines are equal. L4(a): every rank list, and every exact MAP and mean rank, is equal in Python and Node. L4(b): float64 inverts an exactly ordered adjacent pair in 997 of the 1,000 noun queries. The results, the controls and how the run was prepared are in Explainer 10.
L8–L11 were decided in one decisive run on 2026-11-06, 50 min 44 s long, on the code committed at 6da04be, after Amendments 7 and 8, an adversarial review and dry runs; the run first reran the parity test, now with the chain trace: 19,991 of 19,991 lines. All four are supported under their registered decision rules, and every control showed its weakness. L8: 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, for the JS grower and for the Python port. L9: every root and proof of the C0 manifest and of eight synthetic lists is equal in JS and Python, every alteration is detected, and all 148 exact weaves are exact. L10: of 50 clean and 450 tampered attested packages, 0 false accepts and 0 false rejects in JS and in Python, with identical verdicts; Owl’s verifyIntegrity accepts 50 of 50 in each of T1, T2, T8 and T9. L11: a median 155.4 ms per full C0 shard, 95% interval [154.2, 156.0], against the 250 ms bar. Amendment 8 discloses that L11’s packages were fixed as grown with engrams off after dry runs had put the engrams-on median at 243.5–265.5 ms (in the decisive run, engrams-on packages took 243.6 ms, reported), and it replaced L11’s control, a comparison of medians that could not resolve a 0.7–0.8 ms step, with the verifier’s own record of its checks, which held in all 441 full and all 441 skipped verifications. L11’s prediction held in its decision but not in its range: the median is above the predicted 50–150 ms. The results, the controls and how the run was prepared are in Explainer 11.
L6 and L4(c) were decided in one decisive run on 2026-11-06, 3,051 s on 4 workers, at 515a4a1, after Amendment 10, an adversarial review, a dry run on the solid.n.01 closure set, registered tuning (240 runs) and Amendment 11, which froze the rates tuning chose. Every table was snapped to 2−32 and ranked exactly. All parts are supported under their registered decision rules, and every control showed its weakness. L6(a): the learned Lorentz minus learned Euclidean closure AP lies above 0 in every seed, means +0.716 to +0.752 at d = 2 and +0.728 to +0.752 at d = 3 (closure MAP 0.88–0.91 against 0.16–0.17 at d = 2, 0.95–0.97 against 0.22–0.23 at d = 3). L6(b): at d = 50 Euclidean is ahead, 0.99997 against 0.968, every interval entirely below 0, which the rule counts as support. L6(c): the exact H³ tree’s graph-edge MAP, 0.690653, is above learned Lorentz d = 3’s 0.458–0.477, every lower end at least 0.19. L6(d): learned Lorentz d = 3’s closure MAP, 0.950–0.971, is above the exact tree’s 0.305408. L4(c): over 40 tables the largest change in MAP from snapping is 9.37×10−6, against the bar of 0.001. Control 1, the label shuffle by Rng(7), gives at most 0.018803 over 316 tables. L6(c)’s prediction, refuted, was wrong: the rule on spike S3 assumed that learned embeddings keep graph edges, but trained on the closure they rank ancestors and descendants alike. Amendment 12, an erratum, corrects one sentence of Amendment 11. Node, with lexicon_core.js unchanged, re-ranked the 50 measured tables and found every exact value equal (reported). The results, the controls and how the run was prepared are in Explainer 12.
L12–L15 were decided in one decisive run on 2026-11-08, 16,673 s on 4 workers, at 6b6ec09, after Amendment 13, an adversarial review, a dry run on WordNet’s verbs with its values on human-rated sets sealed, Amendment 14, registered tuning and Amendment 15, which froze the rates. Pass 1 scored every instance blind; pass 2 opened the gold and decided. L12(a)–(c) are supported: on HyperLex’s 2,163 noun pairs, ρ is 0.625 for H³ against 0.055–0.217 for the flat arms, and the is-a score beats both the depth gap and the symmetric score. L12(d) is refuted on the low side: WordNet’s own graph scores 0.786, and H³ − WN is −0.161 [−0.221, −0.112]. L13(a)–(c) are supported: BLESS AP 0.789 against at most 0.137 flat, WBLESS 0.970 against at most 0.570, direction 0.980 against at most 0.629. L14(a) and (b) are supported: on HiT’s multi-hop test learned Lorentz beats learned Euclidean in every (d, setting) cell and every seed, and on HyperLex at both d. L15(a) is refuted: by the symmetric score the hyperbolic gain on SimLex and MEN exceeds the 0.02 bar in every cell. L15(b) is supported: GloVe leads on relatedness, H³ on HyperLex. Every control failed as required. Every part came out as predicted; four graded details did not, and are in Explainer 15. An independent check recomputed every decided value and found none different, and Node, with lexicon_stage2.js beside the unedited lexicon_core.js, re-rendered all 106 decision files byte for byte.
The common rules
- Authority. The Python reference decides exact claims. The browser core must reproduce its traces line for line before a claim is shown as holding in the browser. Owl Academy’s and BioChain-AI’s own JavaScript is the authority for compatibility (L8), the numpy float64 trainer for static embeddings (D9).
- Exact claims are all-or-nothing: supported if every case passes, refuted by any single failure, recorded as a counterexample.
- Controls. Every test has at least one. If a control passes, the test is void, the claim stays open, and the test is repaired by amendment.
- Statistics. 95% percentile bootstrap intervals, 10,000 resamples, seed 7. Ties are pessimistic, and fractional-tie values are reported, never used to decide.
- Literature numbers are graded verified, likely or secondary, and no claim compares against a likely or secondary number. Reporting: every case and cell is reported; nothing is dropped after a run.
| # | Claim, in one line | Instances | Controls that must fail | Decision rule, in short | Prediction | Track · phase |
|---|---|---|---|---|---|---|
| L1 exact supported | The front end (normaliser NB on pinned Unicode 15.1 tables, WordPiece, ids, offsets) gives identical normalised bytes, tokens, ids, offsets and id-stream SHA-256 in Python, Node and Chromium | (a) 117,659 WordNet glosses, all four parts of speech; (b) 16,622 EWT sentences; (c) the stress set, 20,520 cases; (d) 2,000 synthetic strings, Rng(1000 + i). V0 “lex0” (8,192) decides; V1 (pinned in Phase 1) is a second cell | (1) the platform normaliser must differ on a case of (c) (S6: 725); (2) shortest-match-first WordPiece must differ on (a); (3) NB without accent stripping must differ on (a) or (b) | All-or-nothing per vocabulary cell and runtime; void if a control passes | Supported in both runtimes; all three controls fail. Risk points: Final_Sigma, U+0130, canonical ordering | browser + CPU · Phase 2 |
| L2 exact supported | engram/1 cannot serve as a token id: at least 1% of WordNet’s distinct lemma types share their key with another type; Python and Node tables equal | Every distinct lemma of the four index files, “_” as a space, NB applied, deduplicated (147,306 types before NB). No randomness | A 64-bit SHA-256-prefix key must give 0 collisions; a Node/Python table mismatch voids the test | Supported if the share ≥ 0.01 and the control gives 0; refuted if < 0.01; void otherwise | Supported, with a share of 2–10% | CPU + Node · Phase 1 |
| L3 exact supported | Every noun synset has an exact, invertible, certified address: (a) distinct, (b) decodes back, (c) certifyWord, (d) ancestor exactly when a proper prefix, (e) exact points on the sheet that decode back in H³ (t = 3/4) and H² (t = 11/13), (f) Python = JS, (g) id59/id64 round-trip | All 82,115 noun synsets; (f) on all nodes by SHA-256, and line by line on 2,000 nodes, Rng(1000 + i) | (1) zero-letter and (2) truncation variants must break injectivity; (3) float placement and decoding must fail beyond 12 letters; (4) H² at t = 3/4 must fail exact decoding | All-or-nothing on (a)–(g) across both trees | Supported; the share of words over 25 and 27 letters is reported (S3: 99.96% of verb words fit 25) | CPU + Node · Phase 1; (f) Phase 2 |
| L4 exact and measured supported | (a) Exact ranking gives identical rank lists, MAP and mean rank in Python and JS, in H³ and H²; (b) float64 ranking is not certifiable at WordNet depth; (c) snapped learned tables rank within 0.001 MAP | The mammal spanning subtree; the noun query sample, 1,000 queries against 82,115 candidates ((a) uses queries 0–199); (c) every L6 table at d = 2, 3 | (1) float32 ranking of the mammals must invert, else (b) is void; (2) an acosh evaluator with index tie-breaking must change an AP on a mammal query with an exact tie (N/A if none) | (a) all-or-nothing; (b) supported if ≥ 1 inversion, refuted if none; (c) supported if every |ΔMAP| ≤ 0.001, refuted if any > 0.01 | All supported; control 2 applies (S1: float64 inverts from depth 10 and 12, float32 from 5) | CPU + Node · Phase 2; (c) Phase 4 |
| L5 statistical supported | At d = 2 and 3 the exact hyperbolic tree reconstructs the noun hierarchy better than the same construction at curvature 0, and its score depends on the hierarchy | The mammal spanning subtree and the noun query sample. Arms H3, H2; flat F3, F2 and fractal F3*, F2*; S3 (permuted words; an arm, not spike S3); K3 (content-hash words). Graph-edge MAP | S3 and K3 must score below H3, with the intervals of (H3 − S3) and (H3 − K3) above 0 on both sets | Supported if (H3 − F3), (H3 − F3*), (H2 − F2), (H2 − F2*) all lie above 0 on both sets; refuted if any lies entirely at or below 0; inconclusive otherwise | Supported; the exact tree falls below 1 where virtual letters occur (S3: 0.6309 on verbs) and short of Sala et al.’s combinatorial 0.989 (verified; reported, not part of the decision) | browser + CPU · Phase 1 |
| L6 statistical supported (c) against its prediction | On the mammals: (a) learned Lorentz beats learned Euclidean on closure MAP at d = 2, 3; (b) not at d = 50; (c) the exact H³ tree’s graph-edge MAP is at least learned Lorentz d = 3’s; (d) learned Lorentz d = 3 beats the exact tree on closure MAP | The mammal closure set (1,182 synsets, 6,542 edges); Nickel & Kiela training in numpy float64; learning rate tuned on seeds 9000–9023, frozen by amendment; measured seeds 0–4 | (1) label shuffle must give MAP ≤ 0.05; (2) edge-shuffled training must score below true training; (3) a random floor is reported | Per part, on paired intervals over 5 seeds: (a), (d) above 0 in all seeds; (b) within ±0.02 or below 0; (c) lower end ≥ −0.01. Each has its own refutation rule | (a) supported, gap ≥ 0.2; (b) supported; (c) refuted, by the rule applied to S3’s 0.6309; (d) supported | CPU · Phase 4 |
| L7 exact and numerical supported | One tree, three readings for q = 13, 17, 29: (a) the LPS Cayley graph’s size, regularity, connectivity, inverse closure, bipartiteness; (b) reduction mod q = walk; (c) no collisions up to length r; (d) Ramanujan; (e) = SHD-CCP’s Hurwitz product, halved | (b) 10,000 random words of length 1–60, Rng(1000 + i), and the mammal addresses; (c) every word up to length r; (e) 1,000 words, Rng(2000 + i), and the mammal addresses | ι = 2 must break (b); a 4-generator subset must fail 6-regularity; the Hurwitz product not divided by 2L must fail (e) | (a), (b), (c), (e) all-or-nothing; (d) supported if every nontrivial |λ| ≤ 2√5 − 10−9 | Supported (the LPS theorem); S5: girths 8, 8, 9; |λ| 4.2497, 4.3089, 4.4420 | CPU + Node · Phase 1 |
| L8 exact supported | Language shards are Owl-valid biochains: (a) our JS grower and Python port give Owl’s record field for field; (b) Owl’s and BioChain-AI’s verifyIntegrity accept; (c) Engram imports and recreates the text; (d) derived layers equal in Python and JS | C0 (148 shards) and 20 synthetic shards, Rng(1000 + i), engrams on and off | (1) a Python grower with BioChain-AI’s 0x80 normalisation must differ from Owl’s; (2) leaf hashing over binary bytes must differ and be rejected; (3) one altered byte must change leaf and root | All-or-nothing, separately for the JS grower and the Python port; Owl’s JS is the authority for (a), (b) | Supported for both (S4: 126/126; faithful weave 1,000/1,000) | Node + CPU · Phase 3 |
| L9 exact supported | (a) The LCORPUS/1 manifest is an RFC 6962 tree: proofs verify only for their own leaf, LGROW/1 is append-only, every alteration is detected, JS and Python agree; (b) each shard’s exact weave has norm 528K, unfolds in order and equals its 7 segments’ product | The C0 manifest (K = 148) and synthetic K ∈ {1, 2, 3, 7, 84, 200, 1000, 1001}; six tamper classes; (b) every C0 shard | (1) the shdccp/2 rule must give L and L + [last] one root at every odd K ≥ 3; (2) an XOR summary must miss an adjacent swap | All-or-nothing; void if a control fails to show its weakness | Supported (S4: proofs ≤ 10 hashes at 1,000 leaves, ≤ 14 at 10,000; weave norm 52352 at K = 84) | Node + CPU · Phase 3 |
| L10 exact supported | The hardened importer, in JS and Python, accepts every clean attested record and rejects every registered tamper, naming the check; verdicts (self-consistent, authentic) identical in both languages; Owl’s own check accepts the classes only these checks catch | 50 C0 shards, Rng(1000 + i), attested in ATTEST/1 with a per-run P-256 test key; tamper classes T1–T9, 50 records each: 450 tampered, 50 clean | (1) Owl’s verifyIntegrity must accept a T1, T2, T8 and T9 record, or that class is void; (2) Python without the P1363-to-DER conversion must reject every valid signature | Supported with 0 false accepts, 0 false rejects and identical verdicts; refuted by any one | Supported (S4: Owl accepts T1, T2, T8 and same-decode residual flips; S7: 0 of 200 raw, pad r and s, high-S twin) | Node + CPU · Phase 3 |
| L11 measured supported | A full C0 shard verifies, every hardened check included, in a median of at most 250 ms in Node, single-threaded, on this container | The 147 C0 shards of at least 59,000 bytes, 3 timed repetitions each, the first discarded | A run without the attestation step must be faster, else void (replaced by Amendment 8 item 2 with the verifier’s own step record; the comparison is reported) | Supported if the interval’s upper end ≤ 250 ms; refuted if its lower end > 500 ms; inconclusive otherwise | Supported, median about 50–150 ms (S4: codec 41 ms, re-encode about 25 ms; S7: ECDSA 0.12–0.23 ms) | Node · Phase 3 |
| L12 statistical (a)–(c) supported (d) refuted | On HyperLex’s nouns, read by the is-a score G with the maximum over senses: (a) H³ and H² track the human ratings better than the same construction at curvature 0 (F3, F3*, F2, F2*); in H³ and H², G beats (b) the depth gap Dep° and (c) the symmetric score Sym; (d) H³ tracks them as well as WordNet’s own graph, within ±0.02 (registered after a partial preview, and flagged) | HyperLex’s 2,163 noun rows, x the candidate hyponym, the gold AVG_SCORE; Spearman ρ, paired differences with word-level intervals (Amendment 13) | (1) H³ − K3 and H³ − S-full* (the strongest of 20 permutations) above 0; (2) H³ − W* above 0; (3) H³ read with the roles reversed must score lower; (4) over 20 gold shuffles |mean ρ| ≤ 0.0240 for seven arms | (a)–(c) as L5; (d) supported if the interval lies within [−0.02, +0.02], refuted if entirely outside, the failing side reported | (a)–(c) supported, ρ(H³) 0.45–0.70 with every flat arm at least 0.10 below; (d) refuted on the low side | CPU · Stage 2 |
| L13 statistical supported | On the hypernymy suite’s test folds, read by G: H³ and H² beat the same construction at curvature 0 in (a) BLESS detection AP, (b) WBLESS detection AP and (c) BLESS direction accuracy | BLESS test, 12,365 covered rows (1,194 positive, 200 concept clusters); WBLESS test, 1,493 rows (764 positive, 192 clusters); BLESS’s 1,194 positives for direction | (1) H³ − K3, − S-full* and − W* above 0 on each part; (2) over 20 label shuffles the mean AP ≤ the share of positives + 1/50; (3) Sym on H³ and GloVe must give a direction accuracy of exactly 0 | Each part: supported if its four H − F cluster intervals lie above 0; refuted if any lies at or below 0 | Supported; F* the likeliest inconclusive cell of (c) | CPU · Stage 2 |
| L14 statistical supported | Trained by Amendment 10’s protocol on WordNet’s 75,850 direct noun edges alone, learned Lorentz beats learned Euclidean at d = 2 and 3, read by G at the origin: (a) on HiT’s multi-hop test, with random and with hard negatives; (b) on HyperLex’s nouns | HiT’s WordNet multi-hop test, 29,383 rows, each with 10 random and 10 hard negatives; HyperLex’s nouns among the 74,401 trained (2,153); seeds 0–4 at the frozen rates | (1) within-row label shuffle and (2) point relabelling (macro mean): mean RR ≤ H11/11 + 1/50 for every trained table; (3) edge-shuffled training below true in at least one cell per d, seed and metric; (4) gold shuffled for (b); and a check that must pass: the training edges’ closure scores RR = 1 on every row | Per (d, setting): supported if all five seeds are present with lower ends above 0, refuted if the mean is ≤ 0 in three or more; (b) the same on ρ per d | Supported, with a larger gap in (a) than in (b), held with low confidence | CPU · Stage 2 |
| L15 statistical (a) refuted (b) supported | (a) Read by Sym with the same information, curvature 0 does as well as the exact trees on similarity (SimLex-999 nouns) and relatedness (MEN noun pairs): the hyperbolic gain in ρ is at most 0.02. (b) GloVe 6B 300-d beats H³ on relatedness (MEN, WordSim-353 relatedness), and H³ beats GloVe on HyperLex | SimLex nouns, 666; MEN noun pairs, 2,005; WordSim relatedness, 245 covered; HyperLex; in (b), each within GloVe’s vocabulary | (1) for (a), H³ − K3, − S-full* and − W* above 0 on SimLex and MEN; (2) gold shuffled, per set; (3) for (b), GloVe’s vectors shuffled among its words | (a) supported if all eight intervals have their upper end ≤ +0.02, refuted if any has its lower end > +0.02; (b) supported if its three intervals lie above 0 | (a) refuted, at least on SimLex; (b) supported | CPU · Stage 2 |
The phases come from the README’s roadmap. Phase 1 decided L2, L3 (Python side), L5 and L7, all supported (Explainer 9); Phase 2 decided L1, L3(f) and L4(a, b), all supported (Explainer 10); Phase 3 decided L8–L11, all supported (Explainer 11); Phase 4 decided L6 and L4(c), all supported, L6(c) against its registered prediction (Explainer 12); Stage 2 decided L12–L15, L12(d) and L15(a) refuted and the other parts supported, every part as predicted (Explainer 15). The full instances, metrics and refutation rules are in the file; the cells above are summaries. The design inputs D1–D12 are fixed with the claims and are part of what is tested (the hub’s decisions).
The prediction was fixed by a rule set with the design: “supported if S3’s exact-tree graph-edge MAP on verbs is ≥ 0.90, otherwise refuted”. S3 measured 0.6309, an exact 205-digit rational reproduced by an independent Python recomputation, so the prediction reads refuted. The cause is the virtual letters: siblings that share a virtual prefix sit as close as the parent or closer. The decision was made in Phase 4, on learned Lorentz embeddings at d = 3 on the mammal closure, five seeds, by the rule in the table, and it went the other way: the exact tree’s graph-edge MAP is 0.690653 against 0.458–0.477, and every (exact − learned) interval’s lower end is at least 0.19, so (c) is supported. The rule assumed that learned embeddings keep graph edges; trained on the closure, they rank ancestors and descendants alike, and direct parents and children reach only about 0.46. The prediction was wrong, and it stays on record (Explainer 12).
Not every prediction is flattering. L6(c) expected the training-free tree to lose to learned embeddings on graph-edge MAP (in Phase 4 it won instead, so that prediction was wrong), and L5 expects it to fall short of Sala et al.’s combinatorial 0.989 in 2 dimensions at about 500 bits (verified; reported, not part of L5’s decision). Hyperbolic Oracles’ C1, “hyperbolic beats flat” for optimisation, was refuted (Explainer 1), and every hyperbolic claim here has a matched Euclidean or flat control.
What none of this decides
The preregistration ends its claims with what they leave open. The spikes leave open more still, because they ran on other data.
What the preregistration does not decide
- Whether hyperbolic geometry helps a language model. Stage-2 claims (lexical semantics) were registered by Amendment 13 and decided (L12–L15, Explainer 15); they read WordNet in every arm and decide nothing about a language model. Stage-3 claims (small MLM pretraining on BabyLM) and Stage-4 claims (GLUE, MTEB) are registered by amendment before any code for them, and most need a wider network or a GPU (Explainer 7).
- Whether the norm-5 address carries meaning beyond WordNet’s spanning tree. One address per synset is one sense, without context;
##pieces get orthographic addresses. - Whether SHD-CCP’s maintainers adopt any proposal in
proposals/(Explainer 2).
What the spikes cannot decide
- Any claim. They ran on disjoint data: the verb forest, not the nouns; synthetic words, not WordNet addresses; verb and adjective glosses, not C0; repository Markdown, not glosses or EWT. A spike value is a fact about that data, and none is a finding of a registered test.
- The noun MAP. S3’s 0.6309 is on verbs, read under a virtual root. The nouns have one real root, depth 19 and up to 659 children. L6(c)’s prediction follows from the rule; its decision was made on the mammal closure, in Phase 4, where (c) is supported, against the prediction (Explainer 12).
- L4(b) on WordNet. S1’s float depths come from random and straight synthetic words with 21–26 nearby candidates each. L4(b) was decided on 1,000 noun queries against all 82,115 candidates, in Phase 2: float64 inverts an exactly ordered pair in 997 of them (Explainer 10).
- The real grower and importer. S4’s grower was spike-only, and S7’s commitment carried placeholder hashes. L8–L10 tested the Phase 3 code on C0, and all three are supported (Explainer 11).
- Exact spectra. S5’s eigenvalues are float64, checked by power sums against exact walk counts. L7(d) asks for a margin of at least 10−9; the smallest S5 found, at q = 29, is 0.030120.
- Tomorrow’s runtimes. S6’s divergences and its 725 depend on the runtimes’ Unicode versions (“~” lines); an update to Node or Chrome moves them. The stress set is fixed by its hash, and the pinned tables are meant to keep the platform’s Unicode out of L1.
- Timings. “~” lines belong to this container (4 CPU cores). L11 was decided on its own timed runs, in Phase 3: a median 155.4 ms per full C0 shard, on packages grown with engrams off, a reading Amendment 8 fixed after the dry runs (engrams-on packages: 243.6 ms, reported; Explainer 11).
Sixteen. Two were written in Phase 1 before any decisive run. Amendment 1 fixed what the registration left open: NB step by step, the V0 trainer, the token map A, ties and rank lists, the readings of L2, L3, L5 and L7, and the dry-run and trace seeds. Amendment 2 records a disclosure (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), an erratum (google-research/bert drops only categories Cc and Cf, Hugging Face’s copy every C category; the rule in force, Cc, Cf and Co dropped and Cn failing closed, is unchanged), the readings fixed in the code, and the two reviews. Amendment 3, after Phase 1’s run, corrects Amendment 2: the text track’s checks also compared Python with Python oracles on L1’s instances, which decided nothing. In Phase 2, Amendment 4, before any code, fixed how the three engines are run and compared, and Amendment 5, before the decisive run, recorded the disclosures, the readings fixed in the code, the environment and the review. Amendment 6, after that run, is an erratum: 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, and L6 ran under it in Phase 4. In Phase 3, Amendment 7, before any code, fixed what L8–L11 left open: the code and its authorities, L8’s synthetic shards, the exact LVOCAB/1, LADDR/1, LPREP/1, LCORPUS/1 and LGROW/1 strings, the exact weave, the RFC 6962 conventions, L10’s packages, keys and draws, L11’s timing and the dry runs. Amendment 8, after the dry runs and before the decisive run, fixed the packages of L9(a), L10 and L11 as grown with engrams off, the Lexicon’s default for corpora, and disclosed that this reading was fixed after dry runs had put L11’s engrams-on median at 243.5–265.5 ms, near the bar; replaced L11’s control, since a comparison of medians could not resolve a 0.7–0.8 ms step against 10–28 ms of noise, with the verifier’s own record of its checks; made the two verdicts follow Explainer 4 (self-consistent is steps 1–6 and 8, authentic step 7); and recorded the readings fixed in the code, the container restart that cut the first build off, the review and the environment. Amendment 9, an erratum written with Phase 3’s write-up, records three stale texts in the decisive record and changes no result. In Phase 4, Amendment 10, before any code, fixed what L6 and L4(c) left open: the code and its authorities, the training protocol step by step, binary64 numerics, the snap to 2−32 and exact ranking, the intervals and decision mechanics, tuning (rate k on seed block k, 240 runs), the controls, LBENCH/1, the dry runs on the solid.n.01 closure set and the order of work; it also recorded an omission, that Phases 1 and 2 never reported fractional-tie values, now in fractional-ties.md. Amendment 11, after registered tuning and before any measured run, froze the rates in reference/settings.json, gave every tuning run, and disclosed that the supplement computing them had ranked Phase 1’s mammal spanning subtree before tuning, which Amendment 10 item 17 required and item 14’s order forbade. 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) and changes no result. In Stage 2, Amendment 13, committed alone before any Stage-2 code, registered L12–L15 with their definitions, pins and order of work, and disclosed a partial preview of L12(d) from counts. Amendment 14, after the dry run, recorded the readings fixed in the code, the instance manifest and the dry run’s diagnostics (among them L15’s control 1, which failed on a 29-row stand-in), and changed no definition. Amendment 15, after registered tuning and before any measured run, froze L14’s rates at 10 in every cell, the grid’s top, and gave every tuning run. Amendment 16, an erratum written with Stage 2’s write-up, records that the Node re-evaluation Amendment 13 item 1 assigns to lexicon_core.js lives in lexicon_stage2.js beside it, that L14’s per-row intervals report rank.ci_mean’s float64 mean, not the exact difference Amendment 14’s wording gives, and that the dry run’s sealed half-widths on MEN’s stand-in were 0.59–0.85, not 0.8–0.9; it changes no rule and no result. Every later change is dated and given a reason at the end of PREREGISTRATION.md, and the claims ledger shows each claim’s state as runs come in.