Contents
Where this sits
Phases 1 to 4 decided all eleven registered claims, L1–L11, and every one is supported. Phase 5 builds the two pages Explainer 3 designed in Phase 0 (its pages chapter), on what those claims established. It decides nothing. After it comes the Stage-1 gate: a review with the user before any encoder code is written.
The page stands on decided ground. L1: the normaliser N_B and WordPiece over V0 give the same ids in the browser as in the Python reference. L3: the address rule gives every noun synset a distinct reduced word, ancestors are exactly its proper prefixes, and every noun decodes back exactly from its H³ and H² points; L3(f) checked the whole canonical point list in the browser. L4(a, b): exact ranking keys in the browser equal the reference’s. L7: the same word read three ways (its point, its quaternion, its X(5, q) vertex), which the 3D page shows. L8–L11: shards, records, the hardened verifier and signing, which the shard panel runs.
The code is in three layers. The page itself, lexicon-2d.html with assets/lexicon-2d.js and lexicon-2d.css, draws and asks and computes nothing the engine computes. The page engine assets/hl-pages.js (LexiconPages, version lexicon-pages-1) composes the core and adds what only a page needs: the named tree, bounded views, exact charts, lowest common ancestors, decoding and precision readings. The shared panels are assets/hl-panels.js and the stylesheet assets/hl-app.css. Under them, unchanged, are lexicon_core.js (whose parity stays 22,586 of 22,586 lines) and the cores it loads from Hyperbolic Oracles and Engram Mind’s Eye.
Every number here comes from the page’s own tests (chapter 12) or from the engine run in Node on this container: tests/pages-lexicon.cjs, tests/pages-chromium-2d.cjs and the trace reference/traces/pages_v1.txt. Times are this container’s and decide nothing. Where this page and those files differ, the files win.
The panels at a glance
Nine panels share one loaded engine, Lex. A point selected in one is selected in all of them, and the disk always draws the selection and the sentence’s tokens.
| Panel | What it shows | What it asks |
|---|---|---|
Sentence #p-input | The text, five examples, the token strip (piece and id, coloured by root), N_B’s words and refusals, the LEB128 id stream and its SHA-256 | Lex.analyse; LexiconCore.nb for the words |
The tree in H² #p-disk | The named tree around a centre in the Poincaré disk: edges, virtual letters, tokens, LCA paths; navigation, spread, turn, toggles, paging, search; the learned view | Lex.view, Lex.chart(2, centre), LexiconPages.toDisk, Lex.lca, Lex.search, Lex.parentKey |
The selected point #p-sel | Its name, word (edges grouped, virtual letters in gold), D6 id, id59, id64, certification, the exact H² point, cosh of its distance from the origin and the centre, its decoding, its named ancestors, the nearest drawn points | Lex.ids, point, cosh, decode, edges, ancestors, nearest |
Precision #p-prec | Bits per coordinate in H² and H³, point bits, the denominators, letters kept in float64; a chart of point bits per token | Lex.bits, Lex.float64Kept, LexiconPages.ratio |
Tokens #p-tokens | One row per token: piece, id, bytes, root, synset, word, id59, H² bits, whether it decodes back; 64 rows a page | the same, per token |
Paths through the LCA #p-lca | Two tokens: common prefix, named and synset LCA, letters up and down, tree path against geodesic in H² and H³ | Lex.lca, Lex.path(2 | 3) |
Shard #p-shard | Grow, sign and verify a language shard, then break it with seven tampers | LexiconPanels.mountShard → LexiconPages.shard |
Engram Mind’s Eye #p-engram | A session read from this browser, a file or pasted text: Engram’s checks, turns, packets with their engram/1 keys beside their Lexicon addresses | LexiconPanels.mountEngram → LexiconPages.engram |
Checks #p-checks | The four load checks; “Recompute LADDR/1” and “Check every noun’s points” on demand | LexiconPanels.mountChecks, Lex.addrTableAsync, Lex.verifyNouns |
On a wide screen the board has three columns: the sentence with the tokens under it, the disk, and the selected point; then the LCA panel with the checks under it, the precision panel under the disk, and the shard and Engram panels. From 900 to 1,359 px it has two columns with the disk across both; below 900 px one column, in the order of the table. The status chips at the top say 82,115 nouns, 8,192 tokens, whether the data equal their pins, whether the words equal theirs, and how long loading took.
The sentence travels in the address bar as #q=<text>, so a link opens the page on that sentence. The last sentence, the spread and the toggles are kept in this browser under hyperbolic-lexicon/pages/1, a convenience only; the hash wins when both are present.
A sentence, stage by stage
The text goes in as UTF-8 bytes and comes out as tokens with addresses. Every stage is the core’s, the one L1 and L3 were decided on.
- N_B, the normaliser. Whitespace splits the text; a word with a code point unassigned in Unicode 15.1 is refused whole and becomes
[UNK](fail closed); the rest is lowercased, decomposed, stripped of its marks, and split at punctuation. The panel lists N_B’s words and, in rose, any it refused. “Ünïcödé façade, naïve café” becomesunicode facade , naive cafe. - WordPiece over V0. The 8,192-entry vocabulary V0 “lex0” splits each word greedily, longest match first, continuation pieces marked
##. The same five words give 11 pieces:un ##ic ##ode fac ##ade , n ##ai ##ve ca ##fe. Each piece keeps its byte span in the text; specials have none. - Ids and the stream. Each piece’s V0 id; the panel shows the LEB128 id stream (the count, then each id, seven bits a byte) and its SHA-256. “The dog chased the cat up the tree.” is 10 tokens and a 20-byte stream.
- Map A, id to word. A piece that is a WordNet noun lemma takes its first noun sense’s word, under root 0; a verb lemma its first verb sense’s, under root 1, the virtual verb root. Other pieces are spelled letter by letter under four roots of their own. Map A on V0 puts 2,493 entries in root 0, 537 in root 1, 1,103 in root 2 (adjective and adverb lemmas), 1,982 in root 3 (
##pieces), 1,962 in root 4 (other whole words) and 115 in root 5 (specials, digits, punctuation); 161 addresses are shared by 338 entries, and the longest word has 49 letters.
| Root | Colour | Holds | In “The dog chased the cat up the tree.” |
|---|---|---|---|
| 0 | cyan | entity.n.01 and the noun tree | dog, cat, tree |
| 1 | violet | verbs (a virtual root over 559 verb roots) | – |
| 2 | green | adjective and adverb lemmas, spelled | up |
| 3 | amber | ## pieces, spelled | ##ased |
| 4 | pink | other whole words, spelled | the, ch |
| 5 | slate | specials, digits and punctuation | . |
Map A gives a piece one address, its first WordNet sense, whatever the sentence around it says. The page shows the surprises as they are: “sat” is Saturday.n (15164570), “whale” is giant.n (10129133), “a” is angstrom.n (13658027) and “are” is are.n (13613862), the unit of area. “chased” is not a V0 entry, so it is spelled as ch and ##ased. These are the address rule and map A working as registered, not errors of the page: choosing a sense from context is an encoder’s job, and no encoder exists yet.
Click a chip in the token strip, a row of the tokens table or a bar of the bits chart to select that token. The tokens table pages at 64 rows; its “word (len)” column shows the start of the address and its length, the whole word on hover.
The noun tree in the disk
The disk does not draw the tree; it draws a bounded neighbourhood of one node, the centre, placed exactly and then rounded for the screen. You move through the tree by changing the centre.
Why the whole tree cannot be drawn
WordNet 3.0 has 82,115 noun synsets: 16,897 with children and 65,218 leaves. Families are small (median 2 children, 90th percentile 9) but some are wide: city.n (08524735) has 659 children. The longest noun words have 36 letters: English springer.n (02102040) and three other spaniels, 18 named levels below entity. The deepest noun by levels is rock hind.n (02569631), 19 below entity and 35 letters from the origin. In the Poincaré disk a node two straight steps from the centre is already at radius 0.986 (τ = ln 12 a letter): the tree’s exponential room is what makes it hyperbolic, and it is also why nobody can see 82,115 nodes at once.
The view
Lex.view(centre) returns what is drawn: every ancestor of the centre (at most 20 named levels), a window of 24 siblings, 48 children, up to 4 grandchildren for each of the first 12 children when the centre has at most 48, the sentence’s tokens, the selection, any shard or session words, and the named nodes on the drawn paths. Over 400 nodes it drops, in order, the grandchildren, siblings beyond ±8, children beyond 24 and extras beyond 64, and says it truncated. The “named tree” has 101,050 nodes: the origin, the five roots above it, every noun and verb synset, and every spelled V0 piece; a spelled piece hangs from its longest proper prefix that is another piece (“app” under “ap”).
When a family is longer than the window, the paging row says so: “◀ children 1–48 of 659 ▶”. The 659 children of city.n are 14 pages of 48; the sibling window’s first page is centred on the centre, and the pages together visit each sibling once. The toggles turn siblings, children, grandchildren, labels, virtual letters and paths on and off.
The exact chart
Each centre gets its own chart, Lex.chart(2, centre). The centre’s exact integer frame from D3’s tree (H2_TREE.frames) gives the isometry that sends the centre to the origin, and every drawn point is moved by it in BigInt: the recentred numerators are integers over one integer denominator, the centre lands on (D, 0, 0) exactly and its parent on the negative x-axis exactly. Only then are floats taken, for drawing: the distance from the exact cosh, a direction from the scaled-down integers, and the disk radius r = tanh(d / (2·spread)). The page never draws a deep point from its own float coordinates: dog’s x₀ is about 6.6×1025, past what float64 can separate from its neighbours.
Edges are true circle arcs, orthogonal to the rim, at spread ×1; at other spreads they are the chart’s float geodesics, sampled. Spread (×1 to ×6, default ×2) divides drawn distances; it changes the picture, never the values. A sideways drag turns the disk (on a phone vertical swipes still scroll the page); turn ↺ 0° puts it back.
What is drawn
- Nodes coloured by root; the centre with a white ring; ancestors in slate; siblings and children small; the sentence’s tokens large and labelled with their pieces; the LCA of a drawn path in a gold ring; the selection in a fuchsia ring.
- Virtual letters as gold dots. When a family has more than five children the L3 rule gives each child several letters; every letter after an edge’s first is virtual, a prefix that names no synset. “The dog chased the cat up the tree.” draws 166 of them around organism.
- An edge dashed when it passes named nodes that are not drawn (a token far from the centre hangs from its nearest drawn ancestor).
- Labels for the selection, the tokens, the centre, the LCA, the six nearest ancestors and, when there are at most 24, the children; a label that would overlap another is left out. Tokens that land on the same pixels (far from the centre they crowd onto the rim) share one label, “dog / cat / tree”, with the selection’s pieces first.
- The readout (“centre organism · depth 6 · 10 letters · spread ×2 · 86 nodes”) top left and the legend bottom left; below 560 px they move under the canvas.
Moving around
| Do | What happens |
|---|---|
| Click or tap a point | Selects the nearest drawn point within 12 px (18 on touch) |
| Double-click, or long-press on touch | Selects it and centres on it |
| Up · Back · Origin · Centre on selection | The centre’s named parent; the previous centre (a history of 50); the empty word; the selected point |
| Find a lemma or piece | First lemmas (space for underscore, any case) and V0 pieces by prefix; Enter centres on the first match |
| A named ancestor in the selected panel | Selects it and centres on it |
| Keys on the focused canvas | ← → turn; + − spread; u up; b back; o origin; Enter centres on the selection |
A new sentence centres on its tokens’ named LCA when it has two or more noun or verb tokens, on the parent of its one synset token otherwise, else on the origin. For the default sentence that is organism.n (00004475), the LCA of dog, cat and tree. “Oxygen and nitrogen are gases.” centres on entity, because “are” is the unit of area; “She can run, jump and swim.” on the virtual verb root, since its four verbs hang from three different verb roots (make, travel and move) that meet only there.
- Select dog, press Centre on selection, then Up twice: carnivore, with dog and cat on either side of the gold path that joins them through it.
- Set the spread to ×1: the true disk. Everything more than a few letters away crowds onto the rim.
- Find “city”, pick the city.n with 659 children and page through them.
Click to decode
The selected panel takes the selected word’s exact H² point and decodes it back to a word, with nothing but the point and the number of letters.
D3’s decoder, H2_TREE.decode, works from the root down: at each step it finds which of the five children of the current node is nearest the point, by exact Lorentz products, and records a tie when two are equally near. The panel shows the decoded word, the ties and “decodes back ✓” when the word equals the one selected; the page’s tests read #p-sel[data-decoded]. Dog’s 27-letter point decodes back with 0 ties.
Decoding is offered on drawn points only. A click lands on a float position, and a float cannot name a deep word; the page picks the nearest drawn node and decodes its exact point.
For H² the greedy decoder’s exactness is measured, not proved: L3 checked every one of the 82,115 nouns, and the page’s engine test checks all 8,192 map A words (no ties) and 2,000 nouns against results/l3f-python.txt byte for byte. For H³ there is a proof for t > 1/√2 (Hyperbolic Oracles E2), which the 3D page uses.
The panel also gives the word’s ids. The D6 id numbers reduced words bijectively (the empty word 0, then by length); id59 and id64 are the same number for words of up to 25 and 27 letters and are left out (–) beyond. Dog has 27 letters: no id59, id64 2247098954881294088. Certified means three exact facts: its quaternion has norm 5ⁿ, right division returns the word, and the word is reduced.
The precision panel
What an exact point costs, coordinate by coordinate, and how much of it a float64 keeps.
For the selected point the table gives, in H² and H³, the bits of each coordinate’s numerator and denominator in lowest terms, the point bits (every coordinate over one common denominator: numerators plus the denominator), and the denominators themselves: 2·300ⁿ in H² (t = 11/13) and 7ⁿ in H³ (t = 3/4), n the number of letters.
| Word | letters | H² coordinates (bits) | H² point bits | H³ coordinates (bits) | H³ point bits | float64 keeps (H², H³) |
|---|---|---|---|---|---|---|
| dog.n (02084071) | 27 | 169/83, 167/81, 148/73 | 579 | 138/76, 138/76, 122/68, 95/54 | 601 | 11, 11 |
| English springer.n (02102040), a longest noun word (36 letters) | 36 | – | 770 | – | 811 | 8, 12 |
float64 keeps is a measurement made on the spot: each exact coordinate is rounded to the nearest double (correctly rounded, ties to even, as Python’s float(Fraction)), the doubles are read back as exact rationals over one power of two, and that point is decoded exactly. The number is how many leading letters survive. Dog keeps 11 of its 27 letters in either geometry: stored as floats, dog is only “somewhere under organism” (10 letters), short of animal (13). This is the exact point stored in float64, decoded exactly; it is not L3’s float control.
Below the table, a chart gives every token’s point bits, H² in blue against H³ in orange, with the selected token shaded; hover a bar for its values, or open “the values as a table”. On the default sentence the H² bar is the shorter for some tokens and the taller for others: dog costs 579 bits in H² and 601 in H³. The last line gives the selected point’s own x₀ and repeats why the chart recentres before any float is taken.
Paths through the lowest common ancestor
Two tokens, A and B, and the way between them through the tree, against the straight way through the plane.
The panel defaults to the sentence’s first two noun or verb tokens. It shows:
- the common prefix of the two words, in letters;
- the named LCA, the longest common prefix that is a named node, and the synset LCA, the longest that is a noun or verb synset. They differ from the common prefix when the prefix ends inside a multi-letter edge: dog and cat share 24 letters, but carnivore.n (02075296), their LCA, has 23. The 24th letter is virtual and names nothing.
- letters: 4 up from dog to carnivore, 3 down to cat, 7 in all (|a| + |b| − 2|LCA|), the page’s
#p-lca[data-letters]; - the named nodes on the way (dog → canine → carnivore → feline → cat);
- the tree path, letters × τ with τ = ln 12 in H² and ln 7 in H³, against the geodesic from the exact cosh of the distance, and the detour between them;
- the exact cosh in both geometries.
| Pair | LCA | letters | H² tree / geodesic | H³ tree / geodesic |
|---|---|---|---|---|
| dog – cat | carnivore.n (02075296) | 7 | 17.394 / 11.762 | 13.621 / 9.057 |
| cat – tree | organism.n (00004475) | 26 | – | – |
| oxygen – nitrogen | chemical element.n (14622893) | 6 | – | – |
Words under different roots meet only at the origin, and the panel says so: “act” (a verb) and “ta” (tantalum, a noun) are 19 letters apart through the empty word. On the disk the A–B path is drawn thick in gold, letter by letter through every prefix; the paths between consecutive noun and verb tokens of the sentence are drawn thinner. “Centre on the LCA” moves the disk there.
Nearest in view, and the learned mammals
Two ways to look at nearness: exact, among the drawn points; and learned, in L6’s measured table.
Nearest in view ranks every drawn point by its distance to the selection, with the exact keys of LC.h2Arm (Lorentz products, integers): Lex.nearest(2, key, drawn, 8). Equal keys are marked as ties. With dog selected around organism the list starts canine (4.750), feline (9.281), carnivore (9.493) and cat (11.762): the named nodes of the drawn dog–cat path come first. It ranks the drawn points only, and the tree’s distances only: nearness here is position in WordNet’s spanning hierarchy, not meaning.
The learned view (the “view” select above the disk) draws L6’s measured table learned-lorentz-d2-lr1-s0: the 1,182 synsets of the mammal closure, trained by Phase 4’s trainer, snapped to n/2³² in the Poincaré disk, with straight spanning edges. It is the same data file as Explainer 12’s lab, data/l6_view_v1.js, and the panel checks its JSON text’s SHA-256 against the pin (38fc6aac…). The sentence’s nouns that are mammals are drawn large: for the default sentence, dog and cat. Click a mammal to select it and centre the exact view on it.
The learned view decides nothing here. L6 was decided in Phase 4 (Explainer 12); this is one table of one seed, drawn for comparison with the exact tree.
The shard panel
Grow a language shard into a biochain, commit it, sign it, put it in a corpus tree and verify it, all in the page; then break it seven ways. It follows Explainer 11’s lab, with one change.
- The text. The sentence (“use the sentence”), a built-in sample of 1,501 bytes, or your own: up to 60,000 bytes, or 6,000 with the engram layer, whose check recomputes every engram.
- Grow.
growSynccuts the bytes into 720-byte frames, crystallizes each into a packet and a residual, hashes the leaves and weaves the frames into one exact quaternion. - The session. LVOCAB/1 is built here from the pinned V0 and Unicode table, and its hash is the decisive run’s (55962675…). LADDR/1 is recomputed here from this page’s own data: the address table of all 8,192 V0 entries, from map A on wn-lite. Its root is the decisive run’s (30b17bc3…) and its hash is the recorded laddrHash (83f09be9…). Explainer 11’s lab had to take that hash on trust; this page computes it.
- Commit, sign, verify. LPREP/1, a corpus tree of one, LCORPUS/1 and LGROW/1; two P-256 keys made in the page (WebCrypto where the context offers it, else the core’s deterministic ECDSA with the attestation check skipped), one active and one revoked; the hardened verifier’s ten checks; Owl Academy’s own rule,
verifyBiochain, beside it.
In Chromium on this container the sample paragraph grew into 3 frames in about 4 ms and was accepted, verified in about 6 ms. Recomputing LADDR/1 is about 0.5 s of work; the panel does it once the page is idle after loading, in steps of a few tens of milliseconds so that the page stays responsive, and every run reuses it (a run started before then waits for it). Then the tampers, each a copy of the package with one thing changed:
| Tamper | What changes | First failing check | Owl’s rule |
|---|---|---|---|
| T1 | leafHashes and merkleRoot removed | leaves | accepts (it recreates them) |
| T2 | one crystal bit of frame 0’s packet flipped, parity re-fixed | crystal | accepts |
| T3 | the last digit of LPREP/1’s lvocabHash | commitment | accepts: the record is unchanged |
| T4 | the same LPREP/1 signed by the revoked key | attestation | accepts: the record is unchanged |
| T7 | frames 0 and 1 swapped (needs more than 720 bytes) | leaves | rejects |
| T8 | the last digit of chainId | weaves | accepts |
| T9 | a residual bit that changes no decode (spike S4’s first silent flip) | canonical | accepts |
“Show its tokens in the tree” draws the shard’s distinct words on the disk and centres on their LCA; the sample paragraph has 195. A chip under the disk (“the shard’s 195 words ✕”) removes them.
L8–L11 were decided in Phase 3 (Explainer 11). The panel demonstrates the code on your text and your keys; the panel’s own text says so.
Engram Mind’s Eye sessions
A dialogue held on Engram Mind’s Eye’s pages can be read in here, and every word it holds is put beside its Lexicon address.
Three ways in: “Read this browser’s Engram session” reads Engram’s own session store (engram-minds-eye/session/1) when both pages share an origin: over http on the same host, or from files in Chromium; a file; or pasted text: an Engram v2 export, an Owl Academy session, a v1 chain, a v1 text crystal, a biochain or an engram stream, through Engram’s own importAny and its checks. Nothing is ever written to Engram’s storage. A lattice seed or an ENVIRONMENT/1 object is not a dialogue, and the panel points to Engram’s 3D page for it.
The panel lists Engram’s checks, the turns (“use” makes a turn the sentence) and the packets: speaker, Engram’s token, its engram/1 key, the Lexicon pieces and their addresses. “Show the whole session in the tree” draws every distinct word of the session on the disk, coloured by its main speaker (you in white, slate in light mode; STRIX in fuchsia; biochains in teal; streams in amber) and sized by how often it was said.
engram/1 is a 64-bit checksum of a token’s letters, so anagrams share a key: CAT, ACT and TAC are all f7b164a270b6804d. Their Lexicon addresses differ: cat.n (02121620), act.v (02367363) and tantalum.n (14656666), and the packet table marks them “same key as #k, different address”. That is L2’s finding made visible: engram/1 is a checksum, and the address is the identity.
Packets known only by their grids, as in an engram stream, have no text and so no address: “grid only: no text, no address”. engram/1 cannot be inverted, and the page does not guess.
The data and how it is checked
The page reads WordNet without the 10.8 MB archive: two script files carry what map A and the trees need, and the page checks them against the decisive runs’ records each time it loads.
| File | Holds | Wrapper | Text | Text SHA-256 |
|---|---|---|---|---|
| data/wordnet_nouns_v1.js | Every noun synset in offset order: offset, first lemma, the index of its L3 spanning parent | 2,549,905 B (836,759 gzipped) | 2,138,095 B | 46196fea… |
| data/wordnet_map_a_v1.js | The verb forest (13,767 synsets, 559 roots) and the WordNet index rows of V0’s entries (6,296) | 567,400 B (185,162 gzipped) | 465,846 B | 10f78a4c… |
Both are written by reference/golden/make_wordnet_view_v1.cjs from the pinned archive. It parses its own output with the engine’s parsers and refuses to write unless the noun words give L3’s canonical point list (eb22bf00…), the verb words give the trace’s hash, map A on the shipped data equals map A on the full archive for all 8,192 entries, and the address table’s root is the decisive run’s. --check rebuilds both in memory and compares bytes (6.4 s). Each text begins with the WordNet licence, verbatim: they are derived from WordNet 3.0, Copyright 2006 by Princeton University, used and redistributed under its licence (LICENSE-WORDNET.txt).
At load the page runs four checks, shown in the checks panel (Chromium, this container, 1440 px):
- The texts equal their pins, SHA-256 and size (144 ms).
- Parse and build wn-lite, the shape of the archive the core’s functions read, with one parent pointer per synset (86 ms).
- The words: the core’s own
nounWordsandverbWordson wn-lite, hashed and compared with the pins (308 ms). - Map A: the core’s
mapAon V0, its per-root counts, shared addresses and longest word compared with the record (30 ms).
Then the named tree is built; in all, 778 ms. If a check fails, the page stays up, shows the failed check in red, and marks itself data-ready="error". Two more checks run when asked: Recompute LADDR/1 builds the address table of all 8,192 V0 entries and gives root 30b17bc3… and hash 83f09be9…, the decisive run’s (530 ms); Check every noun’s points writes L3(f)’s canonical point list of all 82,115 nouns, 29,442,565 bytes, and gives eb22bf00…, L3’s record (2.6 s, about 100 MB of memory). That is L3(f) again, in the page.
How the page is tested
Three layers: the engine in Node against the Python reference’s trace, the engine against the decisive records, and the page in Chromium against the engine.
reference/traces_pages.pywritesreference/traces/pages_v1.txt, 1,326 lines, from the Python reference’s modules: ten sentences’ tokens, ids, H³ and H² points, decodings, bits, float64 depths, pairs, charts and X(5, q) vertices; three BERT-style pairs through the coupler; seven Engram words.--checkrebuilds it.tests/pages-lexicon.cjs(62 of 62 checks pass, 39.6 s): the data and their pins;load()from the wrappers alone (775 ms); map A on wn-lite equal to the full archive’s, the address table and the canonical point list recomputed; all 1,326 trace lines regenerated by the engine; every map A word decoded back in H² and H³; 2,000 random LCA pairs; 500 exact charts (centre at (D, 0, 0), every point on the sheet, products kept, the parent on the negative axis); the view’s budgets, paging and truncation order; the shard and its tampers; the Engram import; and parity oflexicon_core.js, still 22,586 of 22,586.tests/pages-chromium-2d.cjs(134 of 134 checks pass) serves the repository over http on a free port and also opens the page byfile://, at 1440×900, 1024×768 and 390×844, dark and light. For the page and this manual: no page error, no console error, no horizontal scroll; the page ready within 20 s; in light, body text at 16.9:1 contrast. Then, against the engine run in Node: all ten trace sentences through#q=give Node’s token counts (10, 6, 8, 15, 13, 8, 1, 12, 0, 18); 31 tokens of three sentences select, decode back, and show Node’s address, exact H² point and H² and H³ point bits; Centre, Up and Back move as Node’sparentKeysays; a click at the canvas centre selects the centre; dog–cat is 7 letters; spread, a drag and the learned view change the canvas; the search centres; the shard panel accepts and T8 is rejected; an Engram v2 export made in Node is read, drawn and its turn becomes the sentence; and a session put in the page’s storage is found after a reload and left as it was.
Screenshots at 1440 and 390 px, dark and light, were looked at before the page was called done; they are scratch files and are not committed.
What it is not
A window on decided machinery. Four things it does not do.
- Not semantic similarity. The tree is WordNet’s spanning hierarchy, as the L3 rule reads it. Nearness on the disk is nearness in that hierarchy, and a piece has one sense with no context: “sat” is Saturday.
- One parent only. Each synset hangs from its first hypernym or instance-hypernym pointer, the one its address uses. Other hypernyms, the closure, closure-based ranking and glosses are not shipped.
- The float positions are display only. Every value in the panels is exact; every position on the canvas is a float taken after an exact isometry, then spread and turned for the eye. A float click names no deep word.
- Not a claim. The page decides nothing. It demonstrates L1, L3, L4, L7 and L8–L11 as decided, and the learned view shows one of L6’s measured tables. Next comes the Stage-1 gate: the review with the user before any encoder code.
It also runs on V0 only (V1 lives in the cache, not the repository), and it draws a neighbourhood, never the whole tree.