Hyperbolic Lexicon · Explainer 1 · Phase 0

What We Have Made, Measured

Before we build a hyperbolic BERT, we take stock. This repository already gives a language system exact geometry, exact addresses and strong integrity checks. When the survey ran, none of the four repositories gave it a subword tokenizer or a vocabulary (Phase 1 has since built both, in Python), and none gave it learned embeddings, an encoder or gradients (Phase 4 has since trained static embeddings by gradient descent, in Python: Explainer 12). This page sorts what exists from what is missing, with the measurements, and ends with a lab you can type words into.

Try words, live What exists What is missing The short answer Claims ledger
engram/1 key: 26 useful bits of 64 C1, hyperbolic beats flat: refuted 0/12/1 exact H³ to depth 28 · float to 12 chain: ~130 bits per 64-bit packet
Contents
  1. Where this sits
  2. What exists
  3. engram/1: a checksum, not an id
  4. What is missing everywhere
  5. Learning without gradients
  6. Exact against float
  7. Words, live
  8. The short answer
01

Where this sits

This is the analysis the rest of Hyperbolic Lexicon stands on. Its focus node is Engram Mind’s Eye: the system whose words, codec and bridges this one starts from, and the one it bridges back into.

Phase 0 is analysis, measurement spikes and a preregistration; there is no model code yet. This page rests on a read-only survey of four repositories (Ebayednoob, this site; Owl Academy; BioChain-AI; SHD-CCP) and of the literature, re-checked by an adversarial cross-check whose corrections win. Other numbers come from the design spec (its planning measurements are called “a planning check”), from Phase 0’s two pins (WordNet 3.0 and UD English EWT), or from the existing systems’ own pages. Spikes S1–S7 were still running when it was written; nothing here quotes them (Explainer 8).

How to read the marks

exact: integers, rationals or bytes, identical in every engine. float: floating point, rounded at every step. Decisions use the ledger’s tags: SUPPORTED REFUTED INCONCLUSIVE.

Literature numbers carry the survey’s grade. Verified: matched against the paper’s own page or repository. Likely: from a search summary of a primary source that could not be opened (many paper hosts were blocked here then). Secondary: only from someone else’s summary.

H², H³
The hyperbolic plane and 3-space. Room grows exponentially with distance, as a tree’s nodes multiply with depth.
Hyperboloid
The points with x₀² − x₁² − … − xₙ² = 1, x₀ > 0: the “sheet” of the Lorentz model. The Poincaré disk and ball draw the same space inside a unit circle or sphere.
The norm-5 tree
Words in the integer quaternions 1±2i, 1±2j, 1±2k that never undo the previous letter. An n-letter word multiplies out to one quaternion of norm 5ⁿ; right division reads it back.
GF(2)
Arithmetic on bits, where 1 + 1 = 0: adding is XOR.
02

What exists

Three systems here already run, tested, in Node and in the browser. None was built for language. The last column says what each piece is worth to a language system, often less than its name suggests.

Engram Mind’s Eye

A standalone rebuild of Owl Academy’s engram memory and its STRIX familiar: words enter as keys and become exact addresses, memory words and registers (README).

PieceWhat it is, and the evidenceFor a language system
engram/1 keys exactThe TTMPT key, verbatim from Owl Academy: the XOR of one fixed 64-bit grid per letter A–Z. E1 bit-identical to Owl on the golden corpus.A checksum Owl Academy reads. Not an id (chapter 3).
128-bit packetsA 32-bit codex parity, the 64-bit grid, and a footer with the Hamming distances (bits that differ) to the three-packet window and the nearest of 15 concepts.A per-token record in Owl’s shape. The parity is linear and unkeyed, so forgeable; integrity needs SHA-256.
28-letter addresses exactAny 64-bit value as a reduced 28-letter word of the norm-5 tree: one integer quaternion of norm 5²⁸. A chain of packets is one quaternion that right division unfolds in order. E2 up to 720 packets.Exact, invertible addressing of any 64-bit id; an exact chain that keeps order. Storage, not compression (chapter 6).
Triple-quad memory exactCells α, β, γ and Y = α ⊕ β ⊕ γ over GF(2), each sent as two Form 5 Einstein tiles (the orbital 64-bit wire word), with SHA-256 links. E3 1,444,184 cases, no failures.Locate and repair one altered cell, and detect two: a way to certify an id stream segment by segment.
Clock and registers exactA three-packet window; a 720-frame register of 90 packets whose ordered product telescopes 720 → 72 → 10. E4Deterministic 90-token segments with exact products. Bookkeeping, not a learned context.
Coupler, twin system exactq₁ ← w q₁, q₂ ← q₂ w̄ (w̄ the conjugate) keeps B = q₂q₁ fixed across the human and STRIX streams. E5An integrity binding of two streams, like BERT’s segments A and B, with no cross-attention and no meaning.
H² and H³ memory treesRegister → section → zero point → cell, drawn on the 2D (float) and 3D (exact) pages.Views. Positions are structural; placing by content was rejected, since engram bits scatter like a hash.
Fence and guardThe 0.7 fence flags memories sitting too far out and an exact address check settles each flag; the ln 2 guard names a corrupted stored distance. E7 E8 E10Descriptors for stored tables. The fence over-flags Gaussian-like clouds, which learned embeddings probably are.
Bridges to OwlSession export and import, and biochain_v1.js: Owl’s biomesh.js codec copied verbatim and pinned by SHA-256, the working SHD-CCP word and shdccp/2 stream (Explainer 2). E11 50/50.Language shards in Owl’s format that Engram verifies and imports (but does not grow). The check proves self-consistency, not authorship.
Reference and browser corereference/engram/ (41 tests) and engram_core.js: 849/849 parity lines, also live in the page.The method: Python and JavaScript agree bit for bit.
11 claimsE1–E11, each registered before its code. 9 supported 2 inconclusive, none refuted.The template for L1–L11 (PREREGISTRATION.md).

Hyperbolic Oracles

Hyperbolic PolyStep, a gradient-free optimizer in hyperbolic space, and the 0.7 Claude fence. Its browser cores give the Lexicon its geometry (README).

PieceWhat it is, and the evidenceFor a language system
PolyStepH floatA gradient-free optimizer on products of hyperbolic and flat factors. 169/169 parity; over 7,740 runs C1 C2 C3.Heads of a few hundred parameters at most; never an encoder (chapter 5).
Q exactRationals on BigInt, rounded to doubles exactly as Python’s float(Fraction).Exact points, rankings and metrics.
The norm-5 tree P exactGenerators 1±2i, 1±2j, 1±2k, exactly the Lubotzky–Phillips–Sarnak set for p = 5 (Explainer 2); six children at the root, five after. 2,000/2,000 address round trips (Engram spike B).The address space for every synset and token, with no training (claim L3).
Hyperboloid tools H floatPoincaré and Klein maps, exp/log, distance, boosts; the Lorentz centroid (a weighted mean put back on the sheet), Einstein-midpoint weights, softmax and Sinkhorn (optimal-transport) weights.Drawing, and distance attention in floats: softmax of −distance, then a Lorentz centroid.
Exact H³ tree exactTreeEmbedding3D: each letter a boost of t = 3/4 along an octahedral direction, step τ = ln 7; pointExact, decodeExact, nearestExact, certifyWord. 28/28 parity; exact to depth 28.The primary exact store, and, as an exploratory test, a codebook from learned points to tree words (Explainer 3).
Exact snapping exactX.ghost (a rational Poincaré point to an exact hyperboloid point), X.snap onto a 2−24 grid, and fence.js dyadic/lift onto a 2−32 grid.Learned tables stored and ranked exactly (L4(c), supported in Phase 4: Explainer 12).
The fenceTukey’s box-plot fence on the mass of hyperbolic balls about a Fréchet median (the point of least total distance), exact in H², certified in H³, with the ln 2 guard. 101/101 parity; CF-A CF-B CF-C.Descriptors only. CF-C, the registered weakness: 6.05% flagged on wrapped-Gaussian clouds at σ 0.5 in H², against 1.15% for distance-Tukey.
Frames exacttwin3d.js: exact quaternion frames, transport, rotOfQuat. 21/21 parity.A frame per token on the planned 3D page.

The orbital core

orbital_core.js (scripts/geometric-build) holds the orbital calculators’ exact code: BigInt fractions and quaternions, the Cayley map, SHA-256, the 64-bit Einstein tile, Hurwitz Form 1 (flagged lossy), the Lemma 15 chain, the triple-quad formula, the invertible gauge (s, X, Y), the readout and the 720 → 72 → 10 pump. Its Node test passes 18/18 and the four orbital pages rebuild byte-identical (how). For language it offers SHA-256 and byte helpers for the Lexicon’s records. None of it learns.

Two things called “Merkle”

A Merkle root is one hash that commits to a whole list: hash each item, then hash the hashes in pairs, level by level, to a single value. Change any item and the root changes. Biochains use this binary tree. The orbital core’s “Lemma 15 Merkle chain” is a linear backward chain instead, each link hashing its item with the next link’s hash. They are not interchangeable, so the Lexicon names them apart (Lemma 15 note).

Measured costs. A 1,572-packet conversation runs in 1.4 s; 2,000 address round trips take 63 ms. The fence takes 292 ms on 300 points in H³ and grows as N²; the guard takes 13 ms on 37 points and grows as N⁴. Neither reaches a vocabulary of 10⁴–10⁵ points without sampling.

03

engram/1: a checksum, not a token id

engram/1 is where the existing systems turn a word into numbers. So it is worth knowing exactly how little it carries.

How a key is made. Each letter A–Z has a fixed 64-bit grid from a seeded generator (Mulberry32), and a word’s key is the XOR of its letters’ grids. Case is ignored; only A–Z count, so digits, apostrophes and non-ASCII letters are ignored.

What survives. XOR is addition in GF(2), so a letter that appears twice cancels itself. The key depends only on which letters appear an odd number of times: at most 226 ≈ 67 million keys out of 264. The survey found the 26 grids independent over GF(2) (rank 26), so distinct letter-parity patterns always give distinct keys.

Wordsengram/1 keyWhy they share it
LISTEN = SILENTc67bb3c08e31a33aanagrams: the same letters, once each
DOG = GOD334b201534da139banagrams
EYE = Ycd256ab50832b4aathe two Es cancel
NOON = ABBA = 2024 = 420000000000000000every letter an even number of times, or no letters at all: the zero key

No similarity. Distances between distinct words look random: a mean Hamming distance of 32.4 of 64 over 190 pairs (min 20, max 44); cat/cats 30, run/running 31, king/queen 26. Engram’s E9b found recall after a one-letter substitution at chance: 0.0002 against 0.0021, the difference’s interval [−0.0017, 0.0004]. Engram’s 477-token dialogue store has 458 distinct keys.

Why it cannot be a token id

A token id must give every vocabulary entry its own number, and a model learns one embedding per id. engram/1 fails the first test, and its bits carry nothing a model could use as a feature. Engram froze it on purpose (its D4) so Owl Academy’s chains stay readable.

The Lexicon keeps it only as an Owl-compatibility checksum, off by default for corpora and never an input (D4 here; Explainer 3). Claim L2 registers the collision rate: on the WordNet 3.0 lemma vocabulary (147,306 types in the pin), at least 1% of types share a key with another type; predicted 2–10%. Phase 1 found 52.6%: L2 is supported, and the prediction was wrong (Explainer 9). A 64-bit SHA-256-prefix key on the same types is the control and must give no collisions (Explainer 8).

Addresses are 5-adic, not semantic

The 28-letter address reads the 64-bit value in base 5, least significant digit first, each digit picking one of five children. Two values therefore share a k-letter prefix exactly when they agree mod 5k: their last k base-5 digits match. That is 5-adic closeness, of low digits, not of meaning; for hash-like engram values the tree distance is as random as the keys. In a chain a word’s letters also depend on the previous packet’s last letter, so only the 64-bit value is a stable id.

The design’s re-check of the code found one more limit: engram_core.encode always writes 28 letters, never uses the sixth root generator, and records no length. The Lexicon uses its own bijective id instead: 64 bits for words up to 27 letters, 59 bits up to 25 (Explainer 3).

What would give the prefix a meaning

Assign the ids by a hierarchy, and a shared prefix becomes a shared ancestor. That is the Lexicon’s address rule. WordNet’s own noun tree chooses the letters, and claim L3 tests whether the result is exact and invertible for all 82,115 noun synsets; Phase 1 found no failure on its Python side (Explainer 9). The lexicon address is the candidate for an engram/2 key, to be preregistered later in Engram’s own folder.

04

What is missing everywhere

The survey searched Ebayednoob, Owl Academy, BioChain-AI and SHD-CCP for language machinery. Most of what a BERT needs is absent from all four.

A BERT needsAcross the four repositoriesThe Lexicon’s answer
A subword tokenizerNone: no WordPiece, BPE or SentencePiece. There are five word splitters, using regex or whitespace. Two of them disagree: don't 3.14 e-mail gives DON, T, 3, 14, E, MAIL in Engram’s splitter and don’t, 3, 14, e, mail in biomesh.js (Owl notes).One pinned normaliser and WordPiece tokenizer for every track (normalise, tokenize)
A vocabularyNo subword vocabulary and no special tokens ([CLS], [SEP], [MASK]). Owl’s text_to_codex.py gives word-level ids. It is the nearest precedent: an exact token-id stream beside a geometric chain.V0 “lex0” (8,192 entries, trained on WordNet glosses in Phase 1) first; BERT’s 30,522-entry vocabulary, pinned in Phase 1 as V1
Unicode handlingNon-ASCII letters split words, and the key drops them.Unicode 15.1 tables pinned as data. Node 22.23.4 here carries Unicode 17.0; Python 3.13.18 carries 15.1.0
Learned embeddingsNone. Every hyperbolic position in Engram is structural or a tree node.Lorentz against Euclidean tables at matched dimension, trained in Phase 4 (L6, supported: Explainer 12)
An encoderNo attention layer, masked-language-model objective, positional encoding or loss over text. The nearest piece is PolyStep’s softmax weights followed by a Lorentz centroid.Stage 2, only after every Stage-1 claim is decided (encoder)
GradientsNo autodiff in the JavaScript or in the Python reference. Owl’s “pretrained” codex priors are byte statistics, and its bulk trainer has only a toy bit-overlap “attention”.A numpy float64 trainer (D9); chapter 5
Language dataNo datasets. Owl’s code has no WordNet, word2vec or GloVe.Phase 0 pinned WordNet 3.0 and UD English EWT (pins)
NLP benchmarksNone: no GLUE, SentEval, WordNet reconstruction or perplexity. The only learning metric is the codex attunement ε on synthetic wiki-style text.A five-stage ladder (Explainer 7)
A language modelOnly BERT fill-mask: Xenova/bert-base-uncased via Transformers.js 2.6.0 fills one [MASK] in a template, in Owl’s Engram Mind Eye and Language Growing (whose “BART” mode is the same BERT) and BioChain-AI’s Language Studio. Turns are logged as attested; Engram left it out of its core (its D6).Not reused; a Stage-2 encoder of its own, registered by amendment first

WordPiece, BERT’s subword tokenizer, splits each word greedily into the longest pieces found in a fixed vocabulary (a list of pieces, each with an id), marking continuations with “##”, so a rare word still gets ids. [CLS], [SEP] and [MASK] are reserved entries: sentence start, separator, and the hidden word a BERT learns to predict.

Nearly there: the softmax-then-Lorentz-centroid step (an attention-like average, in floats); one deterministic generator in JavaScript and Python (xoshiro128** seeded by splitmix32), so data splits and masked positions can be drawn identically everywhere; exact dyadic snapping; and the way of building, Python first, then a browser core with trace parity, claims registered before code.

A framing to drop

The site’s AI hub pages are tutorials with no runnable NLP code, and a PDF in research_papers argues that tokens should be compressed into quaternions. The repository’s own measurement disagrees: an exact quaternion chain costs about 130 bits per 64-bit packet. It stores; it does not compress.

05

Learning without gradients

The existing systems can learn, but only without gradients and only at toy scale. That decides where learning happens in the Lexicon.

Hyperbolic PolyStep is zeroth-order: it uses only values of the objective, never its gradient. One step works like this. Take a random block of factors. For each particle, score the 2·D corners of an orthoplex around it (one step each way along every axis). Weight the corners by a softmax or a Sinkhorn transport of their costs. Move each factor to the Lorentz centroid of its weighted corners. The step builds on polystep’s optimal-transport step (An T. Le, TMLR 2026) (how it works).

Claim (7,740 runs)CellsSupported / refuted / inconclusiveDecision
C1: hyperbolic beats curvature 0 at equal budget130 / 12 / 1REFUTED
C2: the built-in annealing works (Spearman about −0.90)1212 / 0 / 0SUPPORTED
C3: three channels beat one with three times the particles90 / 9 / 0REFUTED

On the problem benchmarks flat did better. On MAX-3-SAT at n = 500 (B2), hyper3 reached 0.935 against flat3’s 0.962; on tree search (B3), flat3 beat hyper3 by 0.40–0.59 in success rate. The largest model, B4, is an encoder W in R32 plus 8 prototypes in H²: 48 numbers, 8 classes, 2×10⁵ evaluations, about 19 s per Python run. Its test accuracy: hyper3 0.325, flat3 0.334, polystep 0.336, random search 0.224, chance 0.125. Every learned method landed within about 0.014 of the others, hyper3 the weakest (the results).

The survey measured about 2,900 evaluations per second in Node. The smallest encoder the Lexicon plans, 1 million parameters on CPU, is more than 20,000 times the size of B4.

What gradient-free methods are good for

The literature agrees. MeZO runs zeroth-order SGD at inference memory cost: on one 80 GB A100 it trains a 30B-parameter model where backpropagation fits about 2.7B, and with OPT-13B it lands within 1% of Adam on 7 of 11 tasks. But it relies on pretraining and prompts. ZO-Bench and Evolution Strategies at scale tell the same story: they fine-tune, and none pretrains from scratch (MeZO; verified).

So PolyStep is kept for small jobs: heads, curvature and small adapters, in the literature’s terms. Decision D11 limits it to heads of at most a few hundred parameters. In the Lexicon it would tune the hierarchy head’s weight, threshold and temperature in the browser (Explainer 3). A fair comparison with MeZO and plain ZO-SGD, at equal evaluations on a fixed head, is a candidate claim for Phase 6. It will be registered by amendment before any code.

Where learning happens instead

Static embeddings are trained in Python float64 by a numpy trainer, the authority (D9), built in Phase 4: Nickel and Kiela’s Riemannian SGD in the Lorentz model (take the gradient, project it onto the sheet’s tangent plane, move along the sheet with the exponential map), and plain SGD for the Euclidean control. geoopt is a reported cross-check if torch installs. It is not installed here: PyPI’s Linux wheel brings the CUDA libraries, download.pytorch.org is blocked, and there is no GPU (4 CPU cores, 15 GB RAM; Explainer 6). Phase 4 did not run the cross-check: on 2026-11-06 the proxy refused download.pytorch.org, and a 60-digit decimal recomputation of one step and finite-difference gradients in the tests stand in its place (Explainer 12).

The honest frame

FindingGrade
Poincaré embeddings beat Euclidean ones on latent hierarchies such as WordNet nouns, most clearly in low dimensions (Nickel & Kiela 2017).verified
On general NLP, mixed: hyperbolic text embeddings helped some tasks and not others (Dhingra et al. 2018); hyperbolic skip-gram was promising in low dimensions but not clearly better (Leimeister & Wilson 2018).verified
A Lorentz-model BERT claims gains on GLUE, SuperGLUE and extractive QA; its architecture and numbers could not be seen (TASLP 2024).likely
HELM’s fully hyperbolic LLMs: “up to 4%”, a figure the paper does not define, matches only its largest single-benchmark gain, about 4 points on OpenbookQA at about 120M parameters; at 1B its gains are +2.3 points on MMLU, +1.0 on ARC-Challenging and +1.0 on average, all near chance accuracy (arXiv:2505.24722v2, Table 1; code: HELM).verified
Hyperbolic attention on the hyperboloid and Klein models (Gulcehre et al. 2019); that its Klein aggregation is the Einstein midpoint comes from a summary.verified; midpoint secondary
What C1 means for this system

Hyperbolic geometry clearly helps on explicit hierarchies, and modestly or not at all on general NLP. C1 tested optimisation and found no hyperbolic advantage. The Lexicon bets instead on representation (low-dimensional trees, which hyperbolic space has room for) and on certification (exactness, invertibility, identical results across engines). Every hyperbolic claim has a matched Euclidean control, including learned Euclidean tables at matched dimension (L6), and encoder-level gains are predicted small or null.

06

Exact against float

Hyperbolic space grows exponentially, and so do the numbers that describe deep points in it. Floats run out at a depth WordNet passes easily. Exact rationals do not run out, but they cost bits.

A float64 number keeps 53 significant bits, about 16 decimal digits, and rounds after every operation. An exact rational keeps a numerator and a denominator as integers of any size, and never rounds. In the H³ tree each step multiplies by cosh = 25/7 and sinh = 24/7, so a point at word length n has coordinates over 7ⁿ.

Objectexactfloat64
H³ octahedral tree, τ = ln 7Points and decoding exact to depth 28: about 138-bit numerators, 79-bit denominators, ~3 ms per pointDecodes 50/50 words to depth 12, 36/50 at 14, 9/50 at 16, 0/50 at 18 (Engram spike B)
H² tree (TreeEmbedding)None yet: it is built from cos and sinWithout local charts it leaves the sheet near distance 17–24 (depth 8 at τ = 3), so PolyStep runs clamp to a horizon of radius 8
Ranking by distanceInteger keys, ties counted exactly (built in Phase 1; in Phase 2 Python and JavaScript gave identical rank lists and exact MAPs, so L4(a) is supported: Explainer 10)A planning check found straight paths invert at depth 11–12. Coordinates of words longer than about 19 letters exceed 253. In Phase 2, float64 inverted an exactly ordered pair in 997 of 1,000 noun queries (L4(b))
Chain quaternionsGrow about 32.5 bits per packet per component; a 720-packet chain has 23,405-bit components—

The chain’s cost is easy to see per packet. Forty packets took 5,204 bits (four components of 1,301 bits) to hold 2,560 bits of data:

Unfolding grows roughly quadratically with chain length, so chains must be segmented. A 90-packet register, or one shard, is the natural unit (Explainer 4).

Why this bites on WordNet. The pinned noun spanning tree reaches depth 19 below entity.n.01. One node has 659 children, 3,291 nodes have more than five, and 396 have more than 25. Under the address rule, each child of a node with c children takes max(1, ⌈log₅ c⌉) letters. So the addresses of deep synsets run past depth 12, beyond which float decoding starts to fail. The design concludes that float64 is not certifiable at WordNet depth, and claim L4 registers that (Explainer 3).

The missing exact H² tree, and the one designed

No exact tree exists in H². The existing TreeEmbedding uses Math.cos and Math.sin. The Lexicon designs a new one on rational directions only: (1, 0), (3/5, ±4/5), (−7/25, ±24/25) and (−1, 0), with a boost of t = 11/13, so cosh = 145/24 and τ = ln 12.

A planning check, run in memory before any spike, found the following. Exact greedy decoding worked for 100/100 random words at depth 12 and 40/40 at depth 28. With the H³ step t = 3/4, the same directions decoded only 48/100 at depth 12. At depth 28 the new tree cost up to 217/143 bits (numerator/denominator) for random words and 229/188 in the worst case, against about 138/79 in H³. That is 1.5–2.4 times the bits. Spike S2 measures this properly; this page does not quote it (Explainer 3, Explainer 8).

Exactness moves the cost; it does not remove it

WordNet reconstruction is scored by MAP, mean average precision. For each node, rank every other node by distance, and measure how high its true neighbours come. Then average over all nodes; 1 is perfect. A combinatorial tree embedding reached a MAP of 0.989 in 2 dimensions, against 0.87 for learned Poincaré embeddings in 200. It needed almost 500 bits of precision, or 10 dimensions at 32 bits (Sala, De Sa, Gu & Ré 2018; verified; the 0.87 for Poincaré is Nickel & Kiela’s Table 1, noun-closure reconstruction at 200 dimensions, verified; Sala et al. score their 0.989 on the graph’s edges, so the pair is their framing, not a like-for-like comparison). Exact points pay that price in BigInt, as the 138 and 217 bits above show. Benchmarks will therefore compare at matched dimension and at matched bits.

07

Words, live

This lab runs the shared cores unchanged in your browser: the verbatim engram/1 core, Engram’s address code and Hyperbolic Oracles’ exact H³ tree. Type some words and look for three things. Words that share a key. Addresses that share a prefix only by base-5 accident. And the size of an exact point.

Lab · key, address and exact point for each word
Loading the cores…

The keys

Tokenengram/1 keyLetters an odd number of timesSame key asHamming to the token above

The addresses and the exact points

Token28-letter addressPrefix shared with the token aboveCertifiedExact H³ point (numerator / denominator bits), and the same in float64

Tokens come from Engram’s splitter (anything but A–Z and 0–9 splits; upper-cased; the first 12 shown). Keys print as chiralKey does. The address encodes the packet value (bit i = grid cell i) from the root, as EngramCore.encode does; letters 0–5 are 1+2i, 1−2i, 1+2j, 1−2j, 1+2k, 1−2k. Certified: certifyWord holds (norm exactly 5²⁸, right division returns the word, the word is reduced) and decoding returns the 64 bits. The point is TreeEmbedding3D.pointExact, checked on the sheet and decoded back exactly; the float64 line places the same word in floats and decodes it again.

Try it
  • listen silent: one key, so one address and one point. Everything downstream inherits the collision.
  • noon, deed, abba, 2024, 42: the zero key. Its address takes the first child at every letter, the straight path in the H³ tree (decoder3d.js LOCAL[0]); compare its numerator bits with a typical word’s.
  • cat cats: one letter more, 30 of 64 bits different, no shared prefix. Nothing says the words are related.
  • don’t e-mail café: the splitter breaks words and drops the é, the Unicode gap of chapter 4.
  • The float64 line: most words decode wrongly somewhere past letter 12, while the exact point decodes all 28.
08

The short answer

What have we built, for language? An exact, tested base for geometry, bookkeeping and integrity, and nothing that learns language.

Reuse as it is

The norm-5 tree and its LPS generators. The exact H³ tree with exact decoding. Q, the shared Rng, dyadic snapping and SHA-256. The verbatim shdccp/2 codec and Engram’s importer. The method: reference, parity, preregistration.

loaded unchanged, by relative path

Reuse, demoted

engram/1 as an Owl-compatibility checksum only. The fence and guard as descriptors. PolyStep for heads of a few hundred parameters. The float H² tree for drawing. Registers and the coupler stay out of the model: they are bookkeeping.

D4 · D11

Build new

A pinned normaliser and WordPiece tokenizer. The address rule and a bijective id code. An exact H² tree and exact ranking. A float64 trainer with Euclidean controls. Records and manifests for shards. An encoder only at Stage 2.

Phases 1–7 · README

The rest of the library takes these pieces in turn. Explainer 2 sorts out SHD-CCP’s layers and layouts and fixes the one bridge. Explainer 3 follows a sentence through the front end in H² and H³. Explainer 4 grows language shards as biochains. Explainer 5 gives every alternative a role. Explainer 6 sets out the browser, CPU and GPU tracks. Explainer 7 builds the benchmark ladder. Explainer 8 holds the spikes and claims L1–L11.

What this page decides

Nothing. It is an inventory. Decisions are made by the claims in PREREGISTRATION.md, on the instances and rules fixed there, after the spikes and before any code that tests them (ledger).