Contents
Where this sits
Stage F of the front end is a learned table: one point per synset, trained so that a synset’s relatives sit near it. Explainer 5 set it up as baseline B1, learned static hyperbolic embeddings, against which the training-free exact tree is measured; Explainer 6 put its trainer on the CPU track. Phase 4 built it and decided the two claims about it. This page’s focus node is the static embeddings.
The code is in reference/: the trainer lexicon/embed.py (549 lines), its stream stream.py (201, a numba copy of the shared Rng) and pystream.py (91, the same calls on hpstep.prng.Rng), the snapping and exact evaluation learned.py (633), the controls, intervals and decisions l6.py (746), and the runner run_claims_phase4.py (2,230). The browser core’s exact ranking of snapped tables is the Phase 4 section of lexicon_core.js (lines 1,573–1,837 of its 3,205: SnapArm, evaluateSnapped and the L6 trace), and run_l6_node.cjs (416) re-ranked the measured tables in Node. Every number on this page comes from results/claims-phase4.json (summarised in claims-phase4.md), tuning.json, l6-node.json (.md), fractional-ties.json (.md), the dry run in results/dry/, PREREGISTRATION.md (L4, L6, Amendments 10, 11 and 12), the commit messages and the source files; the lab’s values come from your own browser. Where this page and those files differ, the files win.
supported means what the registered decision rule says, and nothing more. L6 is statistical: per seed, the paired per-node differences in average precision between two tables, their mean and a 95% bootstrap interval, in each of five seeds, read by the rule of each part. L4(c) is exact: a largest difference of MAPs, computed as rationals, against 1/1000. A prediction was written with each claim; it is not part of the rule, and one of this phase’s was wrong.
Decimals are rounded from the exact values in the record. Times belong to this container and decide nothing; they are marked “~” where they stand alone.
- Closure set S
- mammal.n.01 (01861778) and every noun with it among its hypernym and instance-hypernym ancestors: 1,182 synsets, in offset order, with 6,542 (node, ancestor) pairs inside S. SHA-256 of its offsets c4748ce2….
- Closure MAP
- Every node is a query against the other 1,181. Its neighbours are its closure ancestors and descendants inside S (13,084 query–neighbour pairs). The MAP is the mean of the 1,182 average precisions.
- Graph-edge MAP
- The neighbours are the spanning parent (the first hypernym or instance-hypernym pointer) and the spanning children, inside S: 2,350 pairs over 1,176 queries. Six nodes have their spanning parent outside S and no children in S; they have no AP and stay candidates.
- Pessimistic ties
- A neighbour tied exactly with a non-neighbour ranks after it (the Common rules). Fractional ties average the AP over every order inside each tie class; they are reported, never used to decide.
- Learned table
- 1,182 rows of float64 after epoch 999 of a run: a Lorentz row (x0, x1, …, xd) on the hyperboloid, a Euclidean row (x1, …, xd).
- Snapped table
- The table on the 2−32 grid, as integers n: for Lorentz, of the Poincaré point p = x/(1 + x0), n = ⌊232p + 1/2⌋ by
fence.dyadic, stepped in at the rim; for Euclidean, n = ⌊232x + 1/2⌋ of the float read exactly. Its text, a lineoffset n_1 … n_dper node, is committed and named by its SHA-256. - κ key
- For a query u and candidate v of a snapped Lorentz table, κu(v) = |nu − nv|²/(432 − |nv|²): an exact rational that orders and ties the candidates exactly as the Lorentz product of the lifted points does (A10.6). A Euclidean table’s key is |nu − nv|².
- Cell, seed
- A cell is a geometry and a dimension: Lorentz or Euclidean at d = 2, 3, 5, 10 or 50, ten in all. A run is a cell, a learning rate and a seed; its draws come from one
Rng(seed). - Interval
- Per seed, the 95% percentile bootstrap of the mean per-node paired AP difference, 10,000 resamples with numpy’s
default_rng(7), started afresh for each interval (A10.7). - Seed present
- A seed counts for a part when the tables it compares exist (no run diverged) and control 2 is established for their cells at that seed, that is, both runs of its pair exist (A10.7; Amendment 11 item 4). A failing control 2 does not drop a seed; it voids all of L6. A part is supported only with all five seeds present.
- Exact arm
- L3’s H³ words of S, placed exactly by the reference’s
h3tree.py(hpstep.decode3d’s octahedral tree;decoder3d.js’s pointExact is its JavaScript twin, against which the Node re-evaluation checked the arm’s lines) and ranked by exact Lorentz products: the training-free tree, with no seed. - Dry run
- The whole pipeline on the closure set of solid.n.01 (1,232 nouns, 5,696 closure edges), every seed +3000 (A10.13). It decides nothing.
- Decisive run
- The one run that decides:
run_claims_phase4.py --measure --workers 4, on the code committed at 515a4a1.
The five decisions at a glance
| Claim | What it says | Decision | Result, per seed (0–4) | Controls that must show their weakness |
|---|---|---|---|---|
| L6(a) | Learned Lorentz beats learned Euclidean on closure MAP at d = 2 and d = 3 | supported | Lorentz − Euclidean closure AP: means +0.7159 to +0.7524 at d = 2 and +0.7284 to +0.7523 at d = 3; every lower end above 0 (at least +0.6990). The predicted gap of at least 0.2 holds: 0.7256 and 0.7424 | 1. Label shuffle: the largest relabelled closure MAP over 316 trained tables is 0.018803 (must be ≤ 0.05). 2. Edge-shuffled training scores below true training in all 50 cell–seed pairs, closure and graph-edge (every interval above 0). 3. Random floors, reported. L6 is not void (chapter 8) |
| L6(b) | At d = 50 the advantage vanishes | supported Euclidean ahead | Means −0.0313 to −0.0328, every interval entirely below 0, which the rule counts as support: Euclidean’s closure MAP is 0.99997, Lorentz’s about 0.968 | |
| L6(c) | The training-free exact H³ tree has graph-edge MAP at least that of learned Lorentz at d = 3 | supported predicted refuted | Exact − learned graph-edge AP: means +0.2138 to +0.2324, lower ends at least +0.1916 (the rule needs ≥ −0.01). Exact 0.690653 against learned 0.458–0.477 | |
| L6(d) | Learned Lorentz at d = 3 has higher closure MAP than the exact H³ tree | supported | Learned − exact closure AP: means +0.6445 to +0.6655, lower ends at least +0.6301. Learned 0.950–0.971 against exact 0.305408 | |
| L4(c) | Learned tables snapped to 2−32 and ranked exactly have MAP within 0.001 of float64 evaluation | supported | 40 tables (measured and edge-shuffled, d = 2 and 3), closure and graph-edge: the largest |ΔMAP| is 9.37×10−6; none above 1/1000 | L4’s own, read by A10.10 to cover (c): control 2 showed its weakness in Phase 2 on the same evaluator |
With these, all eleven registered claims are supported: L1–L11, L3 and L4 in full (Phase 1 in Explainer 9, Phase 2 in Explainer 10, Phase 3 in Explainer 11). Three predictions were wrong, and all three are on record: L2’s share (2–10% predicted, 52.6% measured), L11’s time (about 50–150 ms predicted, 155.4 ms measured) and L6(c)’s outcome (refuted predicted, supported measured; chapter 6). The Node re-evaluation found every exact value of the 50 measured tables equal to the record, which the Common rules (“Authority”) ask for before a page shows L6 or L4(c) as holding.
How Phase 4 was ordered
Definitions first, then code, a review, a full dry run with an independent check, then registered tuning and the amendment that froze its rates, then one decisive run on the code as committed. Ten commits on 2026-11-06 (times in UTC, from git) record the order.
- 43265cf · 10:51 · Amendment 10, before any code for L6 and L4(c). Written before any trainer, evaluator or runner existed, with nothing trained, ranked or evaluated on the mammal sets: the protocol (positives, non-neighbours, draw order, initialisation, schedule, loss and both steps), the numerics (binary64 throughout, no BLAS, the snap and the exact keys) and the statistics (the intervals and the decision mechanics). It read the registered tuning as rate k on seed block k, 240 runs; chose the solid.n.01 closure set as dry data by criteria fixed before choosing; listed every design probe; and recorded an omission: Phases 1 and 2 never reported the fractional-tie values the Common rules ask for (item 17). Nothing registered was changed.
- 272a50d · 12:50 · The code, built on synthetic graphs and unregistered seeds (80000 + i) only: the stream, the trainer with a second slow implementation and a 60-digit oracle in its tests, the evaluators, the runner,
lexicon_core.js’s exact ranking of snapped tables with its trace (traces/l6_v1.txt), and the A10.17 supplement. “fast pytest 295 passed, … parity 22,585/22,585, links 47/47, all.cjs 26/26”, in its message. - e0477fb · 15:16 · Review fixes, before the dry run. Four reviewers, with independent reimplementations of the trainer and the evaluator, mutants of the runner and two skeptics per finding, found no defect in the stream, the trainer or the decisions. Seven minor findings were confirmed and fixed: among them the Euclidean snap, now exactly ⌊232x + 1/2⌋ (a float shortcut was one unit off at one double per K), the environment recorded per run and per start, and a wider clean-tree check.
- 78c661d · 16:54 · Dry tuning on solid.n.01: 240 runs, 5,867 s (~) on 4 workers; its replay with
hpstep.prng.Rngended in the run’s state. - a780bb5 · 17:42 · The dry measure, 2,833 s (~): dry verdicts L6(a)–(d) and L4(c) all supported, on dry data, deciding nothing. Then an independent check of the dry record, two verifiers with their own ranking, intervals and A10.7 rules, about 29,700 comparisons: every exact MAP, interval, verdict, control, tuning choice, receipt and table hash equal; two dry runs retrained from scratch matched bit for bit. The only differences were 77 reported diagnostic values off by at most 2 ulps, which their binary64 reading accounts for (Amendment 11 item 3).
- 7c1806c · 19:57 · Registered tuning at a780bb5 on a clean tree: 240 runs on the mammal closure set, 6,089 s (~) on 4 workers. The replay of
tuning-lorentz-d3-lr0.03-s9000withhpstep.prng.Rngover 1,000 epochs ended in the run’s state (EQUAL). Only closure MAP was computed. - 515a4a1 · 19:58 · Amendment 11, the rates frozen in
reference/settings.json(SHA-256 058e1900…): Lorentz 1 at every d; Euclidean 0.1 at d = 2, 3 and 5, 1 at d = 10 and 3 at d = 50. It lists every tuning run and discloses what ran between Amendment 10 and tuning, among it the A10.17 supplement (below). “The measured runs use seeds 0–4 and have not run.” - The decisive run · started 19:58:57 at 515a4a1, the only paths changed since tuning’s commit being the four A10.14 allows (
PREREGISTRATION.md,settings.json,tuning.jsonand tuning’s console). In one pool of 153 jobs it trained the measured and edge-shuffled tables and the floors, retrained two tuning jobs (their float tables equalled tuning’s bit for bit) and replayed measured (Lorentz, 3, seed 0) withhpstep.prng.Rng(equal); then it computed P =Rng(7)for the first time, and it checked the tree was clean three times. 3,051 s (~). - b6f3b9d · 20:50 · The results, as they came out:
claims-phase4.jsonand.md, the console log, 367 LBENCH/1 receipts and 141 files of snapped and float tables inresults/l6-tables/. - 5c846c5 · 21:26 · Amendment 12, an erratum to Amendment 11. An independent check of the decisive record found one wrong sentence (below) and no other difference among its decisions, intervals, controls, tuning choices, receipts and table hashes.
- 09a8afa · 21:26 · The Node re-evaluation (run at 21:23:09, 117 s ~):
lexicon_core.js, unchanged, regenerated the L6 trace (2,585/2,585 lines), rebuilt S from the WordNet archive and re-ranked the 50 measured snapped tables and the exact arm: 50/50 tables and the exact arm equal in every field; 0 of 118,200 per-query APs differ.
What Amendment 10 fixed
| Item | What it fixes |
|---|---|
| 1 · code | embed.py trains; stream.py computes Rng’s stream in numba and nothing else, tested output for output against hpstep.prng; learned.py snaps and ranks; l6.py decides. MAPs are decided by the Python reference’s rank functions, unchanged. No BLAS; every run single-threaded |
| 2 · instance | The 6,542 positives (u, v), v an ancestor of u, one direction; NN(u), the non-neighbours, the complement of u’s closure; the neighbour sets; the exact arm |
| 3–5 · training | The order of the draws; the initialisation; 1,000 epochs of 131 batches; the loss and both steps in binary64 without fused multiply-add; divergence and the diagnostics (chapter 3) |
| 6 · snapping | The float and snapped tables’ bytes and hashes, the snaps, the κ key, the metrics through rank._ap_and_ranks |
| 7 · intervals | Paired differences, ci_mean, the comparisons in float64, seeds present, each part’s rule, precedence, prediction (a)’s gap |
| 8 · tuning | Rate k on seed block k, 240 runs; scores by exact closure MAP alone; the choice; the lr-freeze amendment; 50 measured runs |
| 9 · controls | One permutation P = Rng(7), computed once, in the decisive run; the edge-shuffled pairs from Rng(2000 + s); the floors; the disclosed 1–2% risk that P voids L6 by chance |
| 10 · L4(c) | The 40 tables; MAP(float64) without acosh; the reported 2−8 snap and displacement |
| 11–12 · reported, LBENCH/1 | Mean rank, fractional-tie MAP, distortion, bits, times, further intervals, the geoopt cross-check, the Node re-evaluation; the receipt’s 22 fields |
| 13–14 · dry runs, order | solid.n.01 with seeds +3000; build, review, dry run, tuning, freeze, one decisive run; a defect found after tuning only by an amendment that says so |
| 15 · sources | Where each constant comes from: Nickel & Kiela’s papers, their released script, or this project (chapter 3) |
| 16–17 · disclosures | Every source read and every probe run before the amendment, none on the mammal sets; the known Phase 1 values; the fractional-tie omission of Phases 1–2 |
Six labels to note
“Amendments 1–11”. The decisive record and the Node re-evaluation’s both say they ran “with PREREGISTRATION.md with Amendments 1-11”. That was true: Amendment 12 was committed at 21:26:23, after both had run. The Node runner was uncommitted when it ran, which its record lists (?? reference/run_l6_node.cjs); it was committed with its output in 09a8afa, and the lexicon_core.js it ran was the one committed at b6f3b9d.
The A10.17 supplement ran before tuning. A10.17 asked for the fractional-tie values of Phases 1 and 2, on those runs’ own code and data; A10.14 says nothing may be ranked on the mammal sets before registered tuning. The supplement ran during the build (at 43265cf, again at 272a50d after a fix to learned.py, every value unchanged), so it ranked Phase 1’s arms on the mammal spanning subtree first. It trained nothing, evaluated no L6 table, did not rank S and did not compute P, and its values were published in Phases 1 and 2 except the fractional ones, which decide nothing. Amendment 11 item 3 discloses the conflict.
Tuning previews the outcome. As A10.14 says, tuning on the mammals shows Lorentz against Euclidean closure MAP before any measured run: at its seeds 9000–9023 the chosen Lorentz rates scored 0.885–0.968 and the Euclidean ones 0.167–0.99997. That is why every line of code and the whole dry run came before it.
The dry run saw (c) come out supported. On solid.n.01, about half an hour before registered tuning began (the dry measure ended at about 17:42, tuning started at 18:15:39) and about two hours before the decisive run, the dry run’s exact tree scored graph-edge MAP 0.619361 against learned Lorentz d = 3 at 0.497–0.520, and its verdict on (c) was supported. Dry data decide nothing; (c)’s prediction is registered text, which no amendment edits, and it was left as it stood.
Amendment 11’s closest choice. Amendment 11 item 1 named Lorentz d = 2 the closest tuning choice (rates 1 and 3: 0.884987 and 0.884130, 0.000857 apart). By that same measure Euclidean d = 50 is closer (rates 3 and 1: 0.999973 and 0.999840, 0.000133). Amendment 12 corrects the sentence; it decides nothing, since A10.8 picks each cell’s rate by the larger exact mean alone.
The geoopt cross-check was not run. D9 names geoopt as a cross-check of the Lorentz step. torch could not be installed through the proxy (download.pytorch.org refused; PyPI’s Linux wheel pulls more than 1 GB of CUDA wheels), as A10.11 foresaw; the tests carry a 60-digit decimal recomputation of one step and finite-difference gradients in its place. It would have been a tolerance, never a decision.
The protocol
L6 registered the training as Nickel and Kiela’s. Amendment 6 found that its constants mix Nickel and Kiela’s Poincaré paper (P17) with their released script and add one of this project’s own (1,000 epochs), and A10.15 says where every constant comes from, P18 included. Each run is a function of the geometry, d, the rate, the seed and the instance alone.
The training rule
| Element | The rule (A10.2–5) | Where it comes from (A10.15) |
|---|---|---|
| Positives | The 6,542 pairs (u, v) with v a closure ancestor of u, in one direction: u is the anchor | The script’s (child, ancestor) orientation |
| Negatives | 50 per row, drawn uniformly with replacement from NN(u), every node but u, its ancestors and its descendants (49–1,180 per anchor; placental.n.01 has 49), in every epoch, burn-in included | 50: the script’s train-nouns.sh. The undirected closure: P18 §4.1. Uniform, with replacement: this project. The script draws descendants as negatives; not followed, since the metric scores them as neighbours |
| Initialisation | xik = (2·random() − 1)·10−3, node by node; Lorentz then x0 = √(1 + Σxk²). Both geometries start from the same spatial numbers | P17 §3.2 (and P18 p. 4): U(−0.001, 0.001) |
| Schedule | 1,000 epochs; a fresh permutation of the positives each epoch; batches of 50, the last of 42 kept: 131 batches, 131,000 steps | Batch 50: train-nouns.sh. The permutation and the short batch: the script’s graph_dataset.pyx. 1,000 epochs: this project (the script runs 1,500; neither paper gives a count) |
| Burn-in | Epochs 0–19 at lr/10, then lr; no momentum, decay, clip or max-norm | The rate lr/10: P17 §3.2. 20 epochs: train-nouns.sh. The script’s own burn-in (lr × 0.01 with 5 negatives drawn by degree) is not followed |
| Loss | A softmax over −d of the 51 candidates, the positive inside: ℓ = d0 + log Σj e−dj, averaged over the batch | The script’s code: the positive inside (energy_function.py line 48) and the batch mean (F.cross_entropy’s default) |
| Lorentz distance | arcosh of the Lorentz product, computed as log1p(t + √(t(t + 2))); a product ≤ 1 is a guard hit with no gradient; no derivative floor | P18. The script’s floor of 10−5 under the derivative is not followed |
| Lorentz step | The Minkowski gradient, its tangent projection, the exact exp map; x0 then recomputed from the spatial coordinates; no clip | P18 eqs. 6, 9 and 10, Algorithm 1. x0 recomputed: geoopt and the script. The script clips the step at 1; not followed |
| Euclidean distance and step | The squared distance |u − v|²; plain SGD, x ← x − ηA | P17 p. 5 and the script’s euclidean.py; “SGD” as registered |
| Gradients | To the anchor, the positive and every negative, repeats summed; every node met in a batch takes one step, from the table as it stood at the batch’s start | The script’s rsgd.py lines 53–57 |
| Arithmetic | IEEE-754 binary64, round to nearest, no fused multiply-add; every sum left to right; no BLAS. Bit identity is promised on the build machine only | This project (A10.4); a second, slow trainer in plain Python floats equals it byte for byte |
| Generator | One Rng(seed) per run, read in a fixed order: initialisation, each epoch’s permutation, then the negatives batch by batch | This project: the shared xoshiro128** of hpstep.prng, copied into numba line for line |
| The table kept | The table after epoch 999; a non-finite table after any epoch ends the run as diverged, with no table and no MAP | This project. The script keeps its lowest-loss checkpoint; not followed |
P17 is Nickel and Kiela’s Poincaré paper (arXiv:1705.08039v2), P18 their Lorentz paper (arXiv:1806.03417v2), and the script facebookresearch/poincare-embeddings at dff101b. Also not followed from the script: negatives drawn without replacement and padded, the always-on max-norm of 106, initial ranges of ±10−5 (Lorentz) and ±10−4 (Euclidean), and five Hogwild threads. The only mammal number found in the literature, P17’s Figure 2 (Poincaré, d = 5: MAP 0.927), is not comparable: its instance is unknown, its ranking directed and its ties not pessimistic. No claim compares against it.
The evaluation
- Snap, then rank exactly. Each table is snapped to 2−32 (the glossary’s snapped table) and every node ranked against the other 1,181 by the κ key (Lorentz) or the exact squared distance (Euclidean), with
rank._ap_and_ranksunchanged: pessimistic APs, MAP and pooled mean rank as exact rationals. - Per seed, per part. The per-node AP differences of the two tables, in offset order (1,182 for closure, 1,176 for graph-edge); their mean and 95% interval. The exact arm has no seed, so its APs enter every seed’s comparison.
- The rules, as registered. (a) at each of d = 2, 3: supported if the interval lies above 0 in all five seeds; refuted if the mean is ≤ 0 in three or more. (b) at d = 50: supported if every interval lies within [−0.02, +0.02] or entirely below 0; refuted if above +0.02 in three or more. (c) supported if every lower end is ≥ −0.01; refuted if the mean is below −0.05 in three or more. (d) supported if every interval lies above 0; refuted if the mean is ≤ 0 in three or more. Otherwise inconclusive; a failed control voids all four. No multiplicity correction is registered, and none is applied.
- Tuning (A10.8): in each of the ten cells, rate k of {0.03, 0.1, 0.3, 1, 3, 10} trained on seeds 9000 + 4k to 9003 + 4k; the rate with the largest exact mean closure MAP over its four runs is frozen, the smaller on a tie; a rate with a diverged run is not eligible. Measured runs use seeds 0–4.
| Tuning, mean closure MAP of four runs | 0.03 | 0.1 | 0.3 | 1 | 3 | 10 |
|---|---|---|---|---|---|---|
| Lorentz d = 2 | 0.227940 | 0.296830 | 0.573959 | 0.884987 | 0.884130 | diverged ×4 |
| Lorentz d = 3 | 0.252473 | 0.422143 | 0.916422 | 0.961827 | 0.927831 | 0.848202 |
| Lorentz d = 5 | 0.275444 | 0.649637 | 0.941990 | 0.967564 | 0.931211 | 0.856591 |
| Lorentz d = 10 | 0.314710 | 0.726946 | 0.948738 | 0.967804 | 0.933893 | 0.861726 |
| Lorentz d = 50 | 0.374534 | 0.760018 | 0.947487 | 0.967860 | 0.937506 | 0.868199 |
| Euclidean d = 2 | 0.108615 | 0.166889 | 0.156837 | 0.156116 | 0.139754 | diverged ×4 |
| Euclidean d = 3 | 0.168306 | 0.218726 | 0.206724 | 0.206521 | 0.193973 | diverged ×4 |
| Euclidean d = 5 | 0.256342 | 0.294311 | 0.288973 | 0.289414 | 0.277995 | diverged ×4 |
| Euclidean d = 10 | 0.374314 | 0.463161 | 0.492301 | 0.496754 | 0.417665 | diverged ×4 |
| Euclidean d = 50 | 0.780164 | 0.999290 | 0.999694 | 0.999840 | 0.999973 | diverged ×4 |
Bold: the frozen rate. Every run at rate 10 diverged in the Euclidean cells (all at epoch 23) and in Lorentz d = 2 (at epochs 375, 295, 327 and 505); no cell chose an end of the grid. Each run’s exact MAP, float and snapped SHA-256 and generator state are in tuning.json, and Amendment 11 prints every run to four decimals.
Planned and measured cost
| Phase 0’s estimate (Explainer 6) | Measured (~, 4 workers) | |
|---|---|---|
| One run | about 1 minute | Lorentz 45–46 s at d = 2 to 345–350 s at d = 50; Euclidean 30–31 s to 268–270 s (measured tables) |
| All runs | about 290, tuning included; about 1–5 h | 340 trained: 240 in tuning, 6,089 s; 100 in the decisive run (50 measured, 50 edge-shuffled) with two pre-flight retrains, 3,051 s in all with the evaluations and control 1. The dry run: 5,867 s and 2,833 s more |
The mammals in the disk
Two of the 50 measured tables, as the decisive run snapped and committed them: learned Lorentz and learned Euclidean at d = 2, seed 0. The Lorentz table is drawn in the Poincaré disk (p = n/232), the Euclidean one in the plane. Pick a mammal, by clicking or tapping it or by name, and lexicon_core.js ranks every other mammal against it exactly, in both tables, here.
Learned Lorentz · d = 2 · Poincaré disk
Learned Euclidean · d = 2 · the plane
| Ranked against the other 1,181, exactly | Learned Lorentz, d = 2 | Learned Euclidean, d = 2 |
|---|---|---|
| no mammal picked | ||
Recompute each table’s MAP
All 1,182 queries, each ranked against the other 1,181 by the same exact keys, closure and graph-edge, in short slices so that the page stays responsive. The result is compared, as a fraction in lowest terms, with the record’s.
How it is computed. The tables are the committed snapped texts results/l6-tables/learned-lorentz-d2-s0.snap.txt.gz and learned-euclid-d2-s0.snap.txt.gz, carried to the page by data/l6_view_v1.js with each synset’s first lemma and parents. A Lorentz table is SnapArm(N, 'lorentz'): candidates ordered by κu(v), compared by BigInt cross-multiplication; a Euclidean one, SnapArm(N, 'euclid'), by |nu − nv|². Each query goes through rankQuery and the MAP through mapExact, the functions evaluateSnapped and the Node re-evaluation use. Closure neighbours are rebuilt from the closure parents, graph-edge neighbours from the spanning parents. A rank is 1 plus the non-neighbours nearer than that neighbour, ties pessimistic (these two tables have none). Drawing alone uses floats: the disk’s points are n/232, moved, when asked, by the hyperbolic isometry that brings the mammal picked to the centre, then spread as Explainer 3’s lab does (at ×s each distance from the centre is drawn divided by s, directions kept; at ×1 the picture is the true disk, where almost every point lies on the rim). Edges are drawn straight.
A page here uses no fetch, so it works from file:// as well as over HTTP: reference/golden/make_l6_view_v1.py writes data/l6_view_v1.js from the two committed snapped texts, claims-phase4.json and the WordNet archive, after checking that S, its closure and graph-edge neighbour sets and both tables are the decisive run’s; its --check rebuilds the file and compares the bytes. On load the page checks the file’s JSON text against its SHA-256; rebuilds S’s offsets and checks their SHA-256 (c4748ce2…), the 6,542 closure edges and the neighbour counts against the record; rebuilds each snapped text from the integers and checks its SHA-256 against the run’s snap_sha; and checks each recorded MAP text against its LBENCH/1 hash. The MAPs it computes are compared with those texts. The first lemmas and parents are WordNet 3.0’s, under the WordNet licence (its notice).
- mammal sits at the centre of the disk, 0.21 from the origin in hyperbolic distance. Every other node is its closure neighbour, so its closure AP is 1 in both tables, whatever the geometry.
- Samoyed, a leaf six steps down: closure AP 0.948 in the Lorentz table, 0.112 in the Euclidean one. In the disk its nearest candidates are spitz, its parent, then carnivore, mammal and placental, ancestors at every level; in the plane they are other breeds of dog, none of them its closure neighbour but spitz, second.
- dog, with 189 descendants: 0.621 in the Lorentz table and 0.987 in the Euclidean one. The plane serves hubs and fails leaves; 889 of the 1,182 nodes are leaves. Recompute both MAPs and the lab counts the queries each table ranks better.
- lion: its spanning parent, big cat, ranks 7th in the disk, behind three of its ancestors (mammal, placental, carnivore), one of its descendants (lion cub, whose spanning parent lies outside S) and two nodes outside its closure. Training made every ancestor a positive with the same weight, so the parent has no special place: this is L6(c) on one query (chapter 6).
- tusker, a child of mammal with no children of its own: 0.5 in the disk (mammal ranks 2nd), 0.0038 in the plane (261st).
- Centre the disk on Samoyed. Every other mammal then crowds into one narrow direction: seen from a leaf near the rim, the rest of the tree lies far off, toward the origin. The hyperbolic plane gives each branch room by putting it far from every other.
- Spread ×1 shows the true disk: the farthest point of this table lies 16.7 from the origin (the record’s max_radius), within 2×10−7 of the rim in the Poincaré coordinates that were snapped.
It runs the functions the Node re-evaluation ran, on two of the tables it checked, and recomputes their MAPs; your browser’s numbers decide nothing. L6 was decided by the Python reference on all 50 measured tables, five seeds a cell; these are two tables of one seed, at the dimension where the geometries differ most. Its drawings are pictures in floats; only the ranking is exact. A Euclidean table in two dimensions is a plane with no centre; it is drawn around the origin, at one scale.
L6(a, b) · Lorentz against Euclidean
At d = 2 and 3, learned Lorentz embeddings rank the mammal closure far better than learned Euclidean ones: about 0.72 to 0.75 more closure AP per query, in every seed. At d = 50 the order reverses and Euclidean is ahead by about 0.032. (a) supported (b) supported
| Registered | As run |
|---|---|
| Instances | S, 1,182 queries for closure; learned Lorentz and Euclidean tables at d = 2, 3, 5, 10 and 50, seeds 0–4, each cell at its frozen rate: 50 tables, none diverged |
| Metric | Closure AP, exact on the snapped tables; per seed the paired differences Lorentz − Euclidean and their 95% interval |
| Decision | (a) at d = 2 and 3, (b) at d = 50, by the rules of chapter 3; d = 5 and 10 reported |
| Seeds present | 5 of 5 for every part: no run diverged, so control 2 is established in every cell and seed (and it holds in all 50) |
| Deciding comparison | seed 0 | seed 1 | seed 2 | seed 3 | seed 4 |
|---|---|---|---|---|---|
| (a) closure, Lorentz − Euclidean, d = 2 | +0.7181 [+0.7013, +0.7347] | +0.7524 [+0.7363, +0.7682] | +0.7172 [+0.7010, +0.7335] | +0.7159 [+0.6990, +0.7325] | +0.7242 [+0.7080, +0.7401] |
| (a) closure, Lorentz − Euclidean, d = 3 | +0.7439 [+0.7270, +0.7601] | +0.7284 [+0.7112, +0.7448] | +0.7452 [+0.7284, +0.7617] | +0.7424 [+0.7259, +0.7587] | +0.7523 [+0.7354, +0.7684] |
| (b) closure, Lorentz − Euclidean, d = 50 | −0.0317 [−0.0365, −0.0270] | −0.0326 [−0.0375, −0.0280] | −0.0328 [−0.0377, −0.0281] | −0.0313 [−0.0361, −0.0268] | −0.0320 [−0.0369, −0.0273] |
| (c) graph-edge, exact − Lorentz d = 3 | +0.2138 [+0.1916, +0.2359] | +0.2324 [+0.2110, +0.2541] | +0.2194 [+0.1972, +0.2415] | +0.2233 [+0.2022, +0.2450] | +0.2322 [+0.2110, +0.2529] |
| (d) closure, Lorentz d = 3 − exact | +0.6592 [+0.6451, +0.6727] | +0.6445 [+0.6301, +0.6584] | +0.6606 [+0.6462, +0.6743] | +0.6630 [+0.6490, +0.6763] | +0.6655 [+0.6515, +0.6790] |
Each cell: the mean, and below it the interval. In every one of the 25 intervals the mean lies inside it. The (c) and (d) rows belong to chapter 6.
The MAPs behind them
| Learned table, closure MAP graph-edge MAP below | rate | seed 0 | seed 1 | seed 2 | seed 3 | seed 4 |
|---|---|---|---|---|---|---|
| Lorentz d = 2 | 1 | 0.889203 0.435848 | 0.909782 0.450571 | 0.876359 0.432120 | 0.883042 0.434068 | 0.897142 0.448395 |
| Lorentz d = 3 | 1 | 0.964599 0.476903 | 0.949911 0.458278 | 0.965984 0.471298 | 0.968414 0.467310 | 0.970952 0.458420 |
| Lorentz d = 5 reported | 1 | 0.967929 0.462000 | 0.969022 0.451724 | 0.970575 0.450984 | 0.966848 0.457642 | 0.969538 0.452347 |
| Lorentz d = 10 reported | 1 | 0.969244 0.444941 | 0.968758 0.447645 | 0.969979 0.456548 | 0.967838 0.454509 | 0.969053 0.454316 |
| Lorentz d = 50 | 1 | 0.968313 0.449858 | 0.967344 0.447834 | 0.967176 0.459265 | 0.968667 0.452467 | 0.967982 0.445952 |
| Euclidean d = 2 | 0.1 | 0.171146 0.223374 | 0.157408 0.196009 | 0.159110 0.201609 | 0.167149 0.220003 | 0.172927 0.253720 |
| Euclidean d = 3 | 0.1 | 0.220680 0.349004 | 0.221554 0.347448 | 0.220769 0.352691 | 0.225976 0.368912 | 0.218669 0.335260 |
| Euclidean d = 5 reported | 0.1 | 0.291163 0.543375 | 0.291355 0.550406 | 0.290672 0.540049 | 0.292539 0.545717 | 0.292858 0.543713 |
| Euclidean d = 10 reported | 1 | 0.497401 0.670047 | 0.494134 0.666836 | 0.497055 0.667948 | 0.499476 0.680384 | 0.494946 0.654565 |
| Euclidean d = 50 | 3 | 0.999977 0.850050 | 0.999975 0.851543 | 0.999971 0.850407 | 0.999974 0.853607 | 0.999975 0.851156 |
| Exact H³ tree (no seed) | – | 0.305408 / 0.690653 | ||||
- Lorentz levels off; Euclidean climbs. Learned Lorentz reaches a closure MAP of 0.950–0.971 at d = 3 and stays at 0.967–0.971 up to d = 50. Learned Euclidean climbs with the dimension: about 0.17 at d = 2, 0.22 at d = 3, 0.29 at d = 5, 0.50 at d = 10 and 0.99997 at d = 50, where its pooled closure mean rank is 1.25–1.29 (Lorentz d = 50: 17.8–18.4).
- (b)’s word “vanishes”. The registered rule supports (b) when the d = 50 interval lies within ±0.02 or entirely below 0. Every interval lies below 0: means −0.0313 to −0.0328, upper ends at most −0.0268. So the support here is not a tie: at d = 50 Euclidean is ahead.
- Reported, d = 5 and 10. Lorentz − Euclidean closure AP: +0.6743 to +0.6799 at d = 5 and +0.4684 to +0.4746 at d = 10, every interval above 0. On graph-edge AP, reported at every d, Lorentz is ahead at d = 2 (+0.19 to +0.25) and 3 (+0.10 to +0.13) and behind from d = 5 (−0.08 to −0.10) to d = 50 (−0.39 to −0.41).
- Where the tables sit. The farthest point of a Lorentz table lies 16.4–17.3 from the origin in hyperbolic distance at d = 2, 13.1–14.1 at d = 3 and about 12 from d = 5 on; of a Euclidean table, 2.8–3.1 at d = 2 and 4.7 at d = 50 (max_radius in the record). No run had a guard hit.
The predictions were (a) “supported, with a closure-MAP gap of at least 0.2 at d = 2 and d = 3 (the direction of Nickel & Kiela)” and (b) “supported”. Both held. The gap, the mean over the seeds of the MAP difference (A10.7), is 0.725557 at d = 2 and 0.742442 at d = 3. Nickel and Kiela’s own figures (P17 Table 1: Poincaré 0.823 against Euclidean 0.024 at 5 dimensions, on all nouns) are another instance and protocol, and are not compared.
L6(c, d) · The exact tree against learned
The training-free exact H³ tree and learned Lorentz at d = 3 are each better at a different job. The tree keeps direct parents and children closer (graph-edge MAP 0.691 against about 0.46); the learned table keeps the whole closure closer (about 0.96 against 0.305). (c) supported (d) supported (c) against its registered prediction
| Registered | As run |
|---|---|
| Arms | The exact arm: L3’s H³ words of S, placed exactly, no training and no seed. Learned Lorentz at d = 3, seeds 0–4, rate 1 |
| Metric | (c) graph-edge AP, exact − learned, 1,176 queries; (d) closure AP, learned − exact, 1,182 queries; per seed, paired, with the interval |
| Decision | (c) supported if every lower end is ≥ −0.01; (d) supported if every interval lies above 0 |
| Exact H³ tree | Learned Lorentz d = 3, seeds 0–4 | |
|---|---|---|
| Graph-edge MAP (decides (c)) | 0.690653 | 0.458278–0.476903 |
| Closure MAP (decides (d)) | 0.305408 | 0.949911–0.970952 |
| Pooled mean rank, graph-edge; closure | 2.909 (6,837/2,350); 68.127 | 15.06–19.04; 15.07–22.35 |
| Exact ties (candidates minus distinct keys, summed over queries) | 47,375, in 1,179 queries | 0 |
| Bits per node, mean and max | 643.3; 811 | 303.6–304.3; 321 |
| Distortion, mean |d/(τ·dT) − 1| | 0.1826 (τ = ln 7) | 0.2752–0.2896 (τ the median) |
The deciding intervals are the (c) and (d) rows of chapter 5’s table: exact − learned graph-edge AP +0.2138 to +0.2324, lower ends +0.1916 to +0.2110; learned − exact closure AP +0.6445 to +0.6655, lower ends +0.6301 to +0.6515. The exact arm’s graph-edge MAP is Phase 1’s value on the same 1,176 queries, as A10.16 had shown it could be at most: the six extra candidates are non-neighbours of every query, and since the MAP is equal as a rational, no AP fell; in every query they ranked behind every graph-edge neighbour.
Reported, beyond d = 3. The exact tree’s graph-edge AP is above learned Lorentz’s at every d (exact − learned means +0.21 to +0.26) and above learned Euclidean’s at d = 2, 3 and 5; at d = 10 the means are +0.010 to +0.036 and one seed’s lower end is −0.0085; at d = 50 learned Euclidean is ahead, with a graph-edge MAP of 0.850–0.854 (exact − learned −0.159 to −0.163). On the closure the exact tree is below learned Lorentz at every d and learned Euclidean at d = 10 and 50, and above learned Euclidean at d = 2, 3 and 5 (learned − exact −0.013 to −0.148).
The wrong prediction, and why
The prediction was fixed in Phase 0 by a rule set with the design and applied to spike S3 on the disjoint verb forest: “supported if S3’s exact-tree graph-edge MAP on verbs is ≥ 0.90, otherwise refuted”. S3 measured 0.6309, so the registered prediction read refuted (Explainer 8). The rule judged the exact tree against a fixed bar, and so took for granted that learned Lorentz embeddings keep graph edges well, near that bar, and that a tree held back by its virtual letters (siblings that share a virtual prefix sit as close as the parent, or closer) would fall below them.
They do not keep graph edges. The training signal is the closure: each of a node’s ancestors is a positive with the same weight, so mammal.n.01 and placental.n.01 are pulled toward a node as hard as its direct parent is, and its siblings are negatives no more than any other non-neighbour. Trained on the closure, the learned tables rank ancestors and descendants alike; the direct parent and children are a few among them. Their graph-edge MAP is 0.458–0.477 at d = 3 and 0.432–0.462 at every other d, and their pooled graph-edge mean rank 15.06–19.04 against the exact tree’s 2.909. The exact tree, low for the reason S3 found, is still well above: 0.690653.
The decision follows the rule, not the prediction: (c) is supported. The prediction stays on record as wrong, beside L2’s and L11’s. The lab shows it on one query: lion’s parent ranks 7th in the disk, behind three of its ancestors and three other nodes.
(d)’s prediction, “supported: learning pulls ancestors toward the origin, which closure ranking rewards”, held. The record decides the outcome and measures no mechanism. The lab shows where one table puts its nodes: pick a mammal and it gives the distance from the origin. In the lab’s Lorentz table (d = 2, seed 0), mammal.n.01 and placental.n.01, the two most general, sit 0.21 and 0.30 from it, and every other node at 2.7 or more; in the d = 3 table of seed 0, which (d) compares, 0.13, 0.17 and 2.85 or more.
L4(c) · Snapping costs nothing at 2−32
Every learned table at d = 2 and 3, snapped to the 2−32 grid and ranked exactly, has the MAP its unsnapped float64 table has, to within 9.37×10−6: about a hundred times under the bar. A coarse 2−8 grid, reported, moves the Lorentz tables’ closure MAP by up to 0.60. supported
| Registered | As run |
|---|---|
| Instances | 40 tables (A10.10): the 20 measured and 20 edge-shuffled tables at d = 2 and 3, seeds 0–4, both geometries. Floors and tuning tables are not included |
| Metric | Per table, |MAP(snapped, exact) − MAP(float64)|, closure and graph-edge, the larger; exact rationals compared exactly with 1/1000 and 1/100. MAP(float64) ranks the unsnapped table by keys in binary64 without fused multiply-add (Lorentz x0y0 − x1y1 − …, Euclidean Σ(xk − yk)²), equal keys pessimistic, no acosh |
| Decision | Supported if the largest is ≤ 1/1000; refuted if any exceeds 1/100; otherwise inconclusive |
| Tables (5 seeds each) | Largest |ΔMAP| at 2−32 | Largest snap displacement | |ΔMAP| at 2−8, closure | |ΔMAP| at 2−8, graph-edge | Exact ties at 2−8 |
|---|---|---|---|---|---|
| Learned Lorentz d = 2 | 9.37×10−6 | 1.565×10−3 | 0.5802–0.6004 | 0.0739–0.0846 | 371,186–385,929 |
| Learned Lorentz d = 3 | 1.73×10−7 | 8.87×10−5 | 0.3978–0.4168 | 0.0258–0.0390 | 89,849–106,335 |
| Learned Euclidean d = 2 | 0 | 1.64×10−10 | 0.0013–0.0026 | 0.0041–0.0068 | 49,850–93,743 |
| Learned Euclidean d = 3 | 0 | 1.96×10−10 | 0.0000–0.0012 | 0.0003–0.0040 | 2,460–3,598 |
| Edge-shuffled, all four cells | 0 | ≤ 1.86×10−7 | ≤ 0.0004 | ≤ 0.0005 | 4,047–74,390 |
Only eight of the 40 tables move at all, all learned Lorentz: the five at d = 2 and three at d = 3 (by 7.6×10−10 to 1.7×10−7). The Euclidean and edge-shuffled tables keep their float MAP exactly. No snapped table has an exact tie and no float table a float tie. The displacement of a Lorentz table is a hyperbolic distance, of a Euclidean one a Euclidean distance (A10.10); they are reported side by side, not compared.
- Why Lorentz at d = 2 moves most. Its points lie far out: 16.4–17.3 from the origin, which in the Poincaré coordinates that are snapped is within about 2×10−7 of the rim. There one step of 2−32 is a larger hyperbolic distance (up to 1.565×10−3 here) than near the centre, and some candidates that were nearly equally far change places. At d = 3 the points lie less far out (13.1–14.1), and the largest displacement is about eighteen times smaller.
- Why 2−8 breaks the same tables. On a grid of 2−8 the Lorentz points near the rim fall onto a few grid points: 371,186–385,929 exact ties at d = 2 (tie counts are candidates minus distinct keys, summed over the 1,182 queries), and pessimistic ties cost 0.58–0.60 of closure MAP. The Euclidean tables, spread over a few units, keep most of their order even on that grid.
- Bits. A snapped point costs 236.9–237.5 bits on average (at most 257) for learned Lorentz at d = 2 and 95.2–95.5 (at most 100) for Euclidean, as the lifted rational point and as n over 232 respectively; the exact tree’s points cost 643.3 (at most 811).
- Every other table, reported. At d = 5, 10 and 50 the measured and edge-shuffled tables move by at most 2.4×10−8, and the floors by at most 1.9×10−8.
- In Node. The re-evaluation ranked the 50 measured snapped tables again with
SnapArmandevaluateSnapped: every exact MAP equal as p/q, every LBENCH/1 hash equal, 0 of 118,200 per-query APs different. It checks the snapped side; MAP(float64) was computed by the Python reference alone.
All 40 tables
| Table | |ΔMAP| closure | |ΔMAP| graph-edge | Displacement | 2−8 closure | 2−8 graph-edge | Ties exact / float | Ties at 2−8 |
|---|---|---|---|---|---|---|---|
| learned-lorentz-d2-s0 | 4.01×10-6 | 3.73×10-6 | 1.23×10-3 | 0.5936 | 0.0743 | 0 / 0 | 376,317 |
| learned-lorentz-d2-s1 | 9.37×10-6 | 5.55×10-6 | 1.56×10-3 | 0.6004 | 0.0776 | 0 / 0 | 385,929 |
| learned-lorentz-d2-s2 | 6.27×10-8 | 3.26×10-8 | 8.56×10-4 | 0.5802 | 0.0846 | 0 / 0 | 371,186 |
| learned-lorentz-d2-s3 | 7.21×10-9 | 6.16×10-9 | 5.57×10-4 | 0.5830 | 0.0739 | 0 / 0 | 377,262 |
| learned-lorentz-d2-s4 | 8.60×10-8 | 1.57×10-8 | 6.10×10-4 | 0.5892 | 0.0815 | 0 / 0 | 382,191 |
| learned-lorentz-d3-s0 | 0 | 0 | 3.39×10-5 | 0.3978 | 0.0390 | 0 / 0 | 89,849 |
| learned-lorentz-d3-s1 | 7.64×10-10 | 0 | 3.30×10-5 | 0.4026 | 0.0273 | 0 / 0 | 100,449 |
| learned-lorentz-d3-s2 | 0 | 0 | 8.87×10-5 | 0.4076 | 0.0303 | 0 / 0 | 106,335 |
| learned-lorentz-d3-s3 | 0 | 1.73×10-7 | 3.91×10-5 | 0.4026 | 0.0258 | 0 / 0 | 99,264 |
| learned-lorentz-d3-s4 | 1.98×10-9 | 0 | 3.37×10-5 | 0.4168 | 0.0382 | 0 / 0 | 102,788 |
| learned-euclid-d2-s0 | 0 | 0 | 1.62×10-10 | 0.0013 | 0.0041 | 0 / 0 | 70,932 |
| learned-euclid-d2-s1 | 0 | 0 | 1.60×10-10 | 0.0026 | 0.0068 | 0 / 0 | 93,743 |
| learned-euclid-d2-s2 | 0 | 0 | 1.61×10-10 | 0.0024 | 0.0064 | 0 / 0 | 68,772 |
| learned-euclid-d2-s3 | 0 | 0 | 1.62×10-10 | 0.0015 | 0.0045 | 0 / 0 | 65,737 |
| learned-euclid-d2-s4 | 0 | 0 | 1.64×10-10 | 0.0018 | 0.0059 | 0 / 0 | 49,850 |
| learned-euclid-d3-s0 | 0 | 0 | 1.91×10-10 | 0.0002 | 0.0013 | 0 / 0 | 3,598 |
| learned-euclid-d3-s1 | 0 | 0 | 1.96×10-10 | 0.0000 | 0.0003 | 0 / 0 | 2,591 |
| learned-euclid-d3-s2 | 0 | 0 | 1.93×10-10 | 0.0004 | 0.0022 | 0 / 0 | 2,460 |
| learned-euclid-d3-s3 | 0 | 0 | 1.96×10-10 | 0.0012 | 0.0040 | 0 / 0 | 2,562 |
| learned-euclid-d3-s4 | 0 | 0 | 1.96×10-10 | 0.0003 | 0.0014 | 0 / 0 | 2,541 |
| edge-shuffled-lorentz-d2-s0 | 0 | 0 | 5.85×10-8 | 0.0001 | 0.0000 | 0 / 0 | 61,385 |
| edge-shuffled-lorentz-d2-s1 | 0 | 0 | 7.39×10-8 | 0.0001 | 0.0001 | 0 / 0 | 67,323 |
| edge-shuffled-lorentz-d2-s2 | 0 | 0 | 4.85×10-8 | 0.0003 | 0.0001 | 0 / 0 | 74,390 |
| edge-shuffled-lorentz-d2-s3 | 0 | 0 | 5.12×10-8 | 0.0001 | 0.0000 | 0 / 0 | 64,938 |
| edge-shuffled-lorentz-d2-s4 | 0 | 0 | 7.49×10-8 | 0.0000 | 0.0004 | 0 / 0 | 44,888 |
| edge-shuffled-lorentz-d3-s0 | 0 | 0 | 1.63×10-7 | 0.0001 | 0.0000 | 0 / 0 | 9,445 |
| edge-shuffled-lorentz-d3-s1 | 0 | 0 | 1.71×10-7 | 0.0000 | 0.0000 | 0 / 0 | 12,985 |
| edge-shuffled-lorentz-d3-s2 | 0 | 0 | 1.03×10-7 | 0.0000 | 0.0000 | 0 / 0 | 12,987 |
| edge-shuffled-lorentz-d3-s3 | 0 | 0 | 1.86×10-7 | 0.0001 | 0.0001 | 0 / 0 | 16,524 |
| edge-shuffled-lorentz-d3-s4 | 0 | 0 | 1.78×10-7 | 0.0001 | 0.0000 | 0 / 0 | 4,725 |
| edge-shuffled-euclid-d2-s0 | 0 | 0 | 1.61×10-10 | 0.0000 | 0.0001 | 0 / 0 | 21,135 |
| edge-shuffled-euclid-d2-s1 | 0 | 0 | 1.62×10-10 | 0.0001 | 0.0005 | 0 / 0 | 20,826 |
| edge-shuffled-euclid-d2-s2 | 0 | 0 | 1.63×10-10 | 0.0000 | 0.0001 | 0 / 0 | 21,307 |
| edge-shuffled-euclid-d2-s3 | 0 | 0 | 1.62×10-10 | 0.0001 | 0.0000 | 0 / 0 | 21,811 |
| edge-shuffled-euclid-d2-s4 | 0 | 0 | 1.60×10-10 | 0.0001 | 0.0000 | 0 / 0 | 19,661 |
| edge-shuffled-euclid-d3-s0 | 0 | 0 | 1.93×10-10 | 0.0000 | 0.0000 | 0 / 0 | 4,047 |
| edge-shuffled-euclid-d3-s1 | 0 | 0 | 1.91×10-10 | 0.0000 | 0.0000 | 0 / 0 | 4,113 |
| edge-shuffled-euclid-d3-s2 | 0 | 0 | 1.96×10-10 | 0.0000 | 0.0000 | 0 / 0 | 4,068 |
| edge-shuffled-euclid-d3-s3 | 0 | 0 | 1.99×10-10 | 0.0001 | 0.0000 | 0 / 0 | 4,139 |
| edge-shuffled-euclid-d3-s4 | 0 | 0 | 1.91×10-10 | 0.0001 | 0.0000 | 0 / 0 | 4,175 |
The prediction was “supported”, and it held. Amendment 10’s design probes had found that snapping moved toy tables’ MAP by at most 1.3×10−6 (A10.16); the largest change on the mammals, 9.37×10−6, is about seven times that and about a hundred times under the bar.
The controls, and what they rule out
Controls 1 and 2 are broken variants that must show their weakness, or L6 is void; both did. Control 3, the untrained floor, is reported and decides nothing. The first is the one A10.9 named a risk before any run: one fixed permutation could void L6 by chance.
| Control | Must | Measured | What it rules out |
|---|---|---|---|
1 · Label shuffle: one permutation P = Rng(7), computed for the first time in the decisive run; the node with index P[i] takes the point of row i | Every trained table, relabelled, scored against the true closure: closure MAP ≤ 1/20 | Holds. 316 tables (216 finite tuning tables, 50 measured, 50 edge-shuffled); the largest 0.018803 (edge-shuffled Lorentz d = 50, seed 3); measured tables at most 0.016447 | An evaluator that scores well whatever the labels: a leak from the labels or the offsets into the ranking |
2 · Edge-shuffled training: 6,542 random pairs from Rng(2000 + s), trained by the same rule at the cell’s rate | True − shuffled AP, closure and graph-edge, interval above 0, in every cell and seed | Holds in all 50 pairs. Lowest lower ends: closure +0.1318, graph-edge +0.1745 (both Euclidean d = 2, seed 1). Shuffled tables score closure MAP 0.0129–0.0161, graph-edge 0.0049–0.0098 | A score that training on 6,542 random pairs would earn: from the number of positives and steps, or the geometry alone. The random pairs do not keep node degrees, so a degree effect is not ruled out |
3 · Floors: each cell’s initial table from Rng(2000 + i), untrained | Reported | Closure MAP 0.0132–0.0165, graph-edge 0.0053–0.0094; a random ranking’s expected MAP, from the neighbour counts alone: 0.014957 and 0.007320 | Nothing by rule; it shows where “learned nothing” lies |
- The disclosed risk did not happen. mammal.n.01 and placental.n.01 neighbour 1,181 and 1,132 nodes; had P handed either label to the point of a general node in a well-trained table, nearly every query would have gained a neighbour near the top (A10.9). P gave mammal.n.01’s label to row 321 (Samoyed, 02111889, 6 closure neighbours) and placental.n.01’s to row 116 (dugong, 02074367, 4).
- P is not in the tail. Reported: under 200 further permutations
Rng(2100 + j), the highest relabelled closure MAP of any measured table is 0.0443, none above 0.05, and P sits among them (for learned Lorentz d = 2, seed 0: 184th from the top). - L4(c)’s controls are L4’s. Control 2 (a float evaluator with acosh distances and index tie-breaking must change an AP on a query with an exact tie) names no part; A10.10 reads it, as Amendment 5 did, to cover (c). It showed its weakness in Phase 2 on
rank._ap_and_ranks, the evaluator (c) uses unchanged (487 of 488 tied queries). No control was added.
The controls test the evaluator and the training signal, not the tuning: every cell’s rate was chosen on the same instance, at other seeds (chapter 10).
Fractional ties: what the pessimistic rule costs the exact tree
Pessimistic ties decide; fractional ties are reported. The learned tables have no tie, so the two values are equal for them. The exact tree has 47,375, and the rule costs it 0.079 of graph-edge MAP. No decision of this phase depends on which rule is read.
| L6’s exact arm (S, 1,182 nodes) | Pessimistic (decides) | Fractional (reported) | Difference |
|---|---|---|---|
| Graph-edge MAP, 1,176 queries | 0.690653 | 0.770081 | 0.079428 |
| Closure MAP, 1,182 queries | 0.305408 | 0.330472 | 0.025064 |
A fractional-tie AP averages the AP over every order inside each exact tie class, computed exactly (A10.11; its formula was checked against brute force over every order on 400 synthetic key lists). Read fractionally, (c)’s gap would widen, from about 0.22 to about 0.30, and (d)’s would narrow, from about 0.66 to about 0.63; neither comes near its rule’s threshold. Where the exact tree’s ties come from, spike S1 found in Phase 0: exact neighbour and non-neighbour ties wherever virtual letters occur (L4’s prediction quotes it).
The supplement for Phases 1 and 2 (A10.17)
Amendment 10 item 17 recorded that Phases 1 and 2 ranked with exact ties and reported only the pessimistic values, though the Common rules ask for both. The supplement (fractional-ties.md) rebuilt Phase 1’s L5 arms and Phase 2’s L4(a) rank lists with those runs’ own code and draws, checked that every pessimistic value equals the published one, and added the fractional ones. It decides nothing, and L5 and L4(a) stay decided as recorded. Selected rows:
| Set, arm | Graph-edge MAP, pessimistic | Graph-edge MAP, fractional | Queries that differ | Closure MAP, pessimistic | Closure MAP, fractional |
|---|---|---|---|---|---|
| Mammal spanning subtree (1,176), H³ | 0.6907 | 0.7701 | 488 | 0.3059 | 0.3311 |
| Mammals, H² | 0.7187 | 0.7189 | 28 | 0.3063 | 0.3063 |
| Mammals, F3 (flat, same construction) | 0.1099 | 0.1820 | 1,152 | 0.0600 | 0.0838 |
| Mammals, F3* (flat fractal) | 0.6420 | 0.6420 | 0 | 0.2583 | 0.2583 |
| Mammals, K3 (content-hash words) | 0.0068 | 0.0068 | 40 | 0.0142 | 0.0142 |
| Nouns (1,000 queries), H³ | 0.5679 | 0.6377 | 400 | 0.1577 | 0.1712 |
| Nouns, H² | 0.5901 | 0.5903 | 16 | 0.1567 | 0.1567 |
L5’s decision, hyperbolic against flat, compared H³ with F3 and F3*: read fractionally, H³’s graph-edge MAP on the mammals rises by 0.079 and F3’s by 0.072, F3*’s not at all, so the MAPs keep their order. The mammal H³ row’s graph-edge values are those of L6’s exact arm: the same 1,176 queries. The supplement ran before registered tuning, as chapter 2 records.
What this does not show
Five supported parts about one hierarchy, one protocol and one machine. They say a good deal about how geometry and training shape a learned table, and nothing about language.
- WordNet mammals only. One instance: 1,182 synsets, nine levels deep, nearly a tree (one node has two parents inside S). Other hierarchies, deeper or wider, all nouns, verbs, are new tests.
- Reconstruction, not link prediction. Every closure edge that is scored was trained on. (a), (b) and (d) measure how well each geometry fits the relation it was given, not whether it predicts an edge it never saw. No edge was held out.
- No lexical meaning. The tables place synset ids. Lemmas, glosses and the way words are used play no part, and no word’s meaning is tested.
- The Stage-2 lexical claims were not registered. The roadmap listed them for Phase 4 by amendment: HyperLex, a hypernymy suite, SimLex-999 and the other similarity and relatedness controls (Explainer 7). No such amendment was written, and no code for them exists. They remain to be registered by amendment before any code for them.
- One protocol, one tuning. The protocol is this project’s own, after Nickel and Kiela’s papers and script (A10.15); another protocol may order the geometries differently, and these numbers are not comparable with theirs. Each cell’s rate was tuned on the same instance at other seeds, on closure MAP alone, from a six-point grid. Under A10.8’s reading of “in blocks of four”, each rate ran on its own block of four seeds (240 runs, not every rate on all 24 seeds, 1,440 runs). So rates were compared across different seeds, and the two closest choices (Euclidean d = 50, 0.000133; Lorentz d = 2, 0.000857) could fall the other way on other seeds.
- (c) is one comparison. It sets the exact tree against learned Lorentz at d = 3, as registered. Learned Euclidean at d = 50 has a graph-edge MAP of 0.850–0.854, above the exact tree’s 0.691 (reported). A learned table trained on graph edges rather than the closure was not part of L6.
- One machine. Python 3.13.18, numpy 2.5.3, numba 0.68.1, glibc 2.39, 4 CPUs; bit identity is promised on this build machine only, and the record names its environment. The geoopt cross-check was not run.
- Snapping at 2−32 only. L4(c) says that this grid keeps the ranking of these tables; it says nothing about whether a table is good, and a coarse grid does not keep it.
- The lab draws two tables of one seed and recomputes their MAPs with the functions the Node re-evaluation used. It demonstrates the code and decides nothing.
Next: Phase 5
With L6 and L4(c) decided, every Stage-1 claim is supported. Phase 5 builds the two pages Explainer 3 designed in Phase 0 (its pages chapter), and ends at the Stage-1 gate.
- The 2D page.
lexicon-2d.html: the exact H² tree (t = 11/13) in the Poincaré disk, every noun at its exact address. - The 3D page.
lexicon-3d.html: the exact H³ tree in the ball. - A shard panel and an Engram session import.
- The Stage-1 gate. All eleven claims, L1–L11, decided and reviewed before any encoder code is written (the roadmap).
The Stage-2 lexical claims are not part of Phase 5. They are to be registered by amendment, with instances, controls, rules and predictions, before any code for them.