Contents
Where this sits
The focus node is the working SHD-CCP: the 64-bit word and the stream that Owl Academy and BioChain-AI actually write. It is the one part of SHD-CCP the Lexicon must match byte for byte, because every language shard it grows has to verify in their code.
Phase 0 is analysis, measurement spikes and a preregistration; there is no model code. This page rests on a read-only survey of four repositories (Ebayednoob 7b10514, Owl Academy 7f45f35, BioChain-AI c975161, SHD-CCP 97d90ac) and on its adversarial cross-check, whose corrections win. It also uses the design spec, the documents in proposals/ and the spikes.
The spikes S1–S7 have finished. They ran before the preregistration, on data disjoint from every registered instance, and they decide no claim. This page quotes their numbers exactly as the captured outputs print them, and calls them spike results; S4, S5, S6 and S7 matter most here (outputs: S4, S5, S6, S7; Explainer 8 has all seven). Lines the outputs mark with “~” are timings or facts about this container (Node 22.23.4, Python 3.13.18, 4 CPU cores), and are quoted as such.
exact: integers, rationals or bytes, identical in every engine. float: floating point, rounded at every step. Claims L1–L11 are registered in PREREGISTRATION.md; none was decided when this page was written, and Phase 1 has since decided L2, L3’s Python side, L5 and L7 (Explainer 9), Phase 2 L1, L3(f) and L4(a, b) (Explainer 10), Phase 3 L8–L11 (Explainer 11), and Phase 4 L6 and L4(c) (Explainer 12), all supported. Where this page names a claim, it says what the claim tests, not what it found.
- SHD-CCP
- The Symbolic High Dimensional Context Compression Protocol. Its repository calls it a hardware-level interface in which every token is one 64-bit word.
- Word, tile
- A 64-bit integer. SHD-CCP calls it an “Einstein tile”; the name refers to no tiling geometry in the code. Bit 0 is the least significant bit, so “63..60” means the top four bits.
- Layout
- Which bits mean what. The same 64 bits read under two layouts give two different sets of fields.
- Form
- A 4-bit field (a nibble: 16 values) meant to say what the rest of the word holds. Where it sits depends on the layout.
- Parity bit
- One bit set so that the word holds an even number of 1 bits. It catches any odd number of flipped bits, and no even number.
- Biochain
- Owl Academy’s and BioChain-AI’s record of one text of at most 60,000 bytes: an
shdccp/2stream that rebuilds the text exactly, plus hashes that commit to it. - Merkle root
- One hash that commits to a list: hash each item, then hash the hashes in pairs, level by level, down to one value.
- LPS, Ramanujan
- Lubotzky, Phillips and Sarnak built regular graphs that spread out as fast as a regular graph can. For a 6-regular graph, Ramanujan means every eigenvalue other than ±6 has size at most 2√5 ≈ 4.4721.
Three layers that disagree
The SHD-CCP repository pitches a hardware-level interface in which every token is a single 64-bit word. In practice the name covers three layers. They do not agree with each other, and only one of them runs.
1 · The specification
A spec scaffold. RFC 01 drafts the tile (Form at 36–39, “layout NOT frozen”) in six bindings: Python, JavaScript, C, Rust, Java, Elixir. The Kernel Ontology puts its Form header at 60–63 and records the clash as an open decision.
2 · The working SHD-CCP
The Blackwell 64-bit word inside the shdccp/2 stream, with hashes and ECDSA attestations. Engram Mind’s Eye pins it verbatim. None of this code is in the SHD-CCP repository; its manual only describes the word, as the “Blackwell Block”.
3 · Prose only
LPF-128 (a 32-bit header, the 64-bit core and a CRC32 footer), Falcon-512 chaining, and the Fokker–Planck sieve. No CRC32 or Falcon code exists; the manual itself flags the sieve as conjecture.
| What | 1 · Specification | 2 · Working | 3 · Prose |
|---|---|---|---|
| The 64-bit word | RFC 01 draft (Form 39..36); the Ontology’s header (Form 63..60) | The Blackwell word (form 63..60) | Several diagrams |
| A chain or stream | None | shdccp/2, with GROWN/1 and GROWTH/1 commitments | LPF-128 frames chained by Falcon |
| Merkle integrity | Lemma 15 is a TODO; the suite 03_merkle_collision is pending | A binary SHA-256 Merkle tree | — |
| Signatures | None | ECDSA P-256: ATTEST/1 in BioChain-AI, Minor Tome seals (SEAL/1) in Owl Academy | Falcon-512 |
| Exact arithmetic exact | Garner CRT over 881, 883, 887 (an index below 690,017,701); an integer Gram-TQF; HurwitzQuaternion in doubled coordinates | BigInt word packing; SHA-256 | — |
| Proofs and vectors | Lean proves the CRT constants only; SHDGEV01 vectors, 2,366 cases | The check word 9841D88D8B003CEA, pinned by all three repositories | — |
| Language | None. Forms 8–11, “Codex_Semantics”, are labelled “LLM embeddings, latent concepts”, but no such code exists | A lossy engram layer, 64 bits per word token | Hand-assigned concept seeds, stated to be “not learned” |
Much of the specification’s code is still stubs. Quaternion chain compression (QCC), the 12-engine memory, the handshake and the calculators raise NotImplementedError. RFC 03’s X(5, q) overlay, the hook this page follows in chapter 7, is an outline with a TODO list.
SHD-CCP’s ecosystem README calls geometric-engine-spec the “single source of truth” that BioChain consumes. The real BioChain-AI and Owl Academy code ignores it: it uses a different layout and no SHDGEV01 vectors. (A small BioChain-AI scaffold inside the SHD-CCP repository marks Merkle commitment as a TODO; the real BioChain-AI repository implements Merkle roots.) Nobody is named as the owner of the RFC 01 against Blackwell decision. The layout census asks SHD-CCP to settle it.
What the Lexicon takes from each layer. From the specification: the Ontology’s kernel pipeline (for kernel 0xA, chapter 7), HurwitzQuaternion as a cross-check, SHDGEV01 for golden vectors, and RFC 03’s X(5, q) slot. From the working layer: the Blackwell word and shdccp/2, unchanged, at the bridge only (chapter 6). From the prose: nothing.
The working SHD-CCP
What runs is the Blackwell word inside the shdccp/2 stream. It lives in Owl Academy’s scripts/biomesh.js, in BioChain-AI’s src/biomesh/biomesh.js and protocol/shdccp_kernel.py, and in Engram Mind’s Eye’s verbatim pins.
The Blackwell word, field by field
| Bits | Field | What it holds | In 9841D88D8B003CEA |
|---|---|---|---|
| 63..60 | form | What the word is. In Owl Academy’s reading, 0–7 are geometry and 8–15 are gates; a data crystal is form 9 (chapter 5). | 9 |
| 59 | parity | Even parity over the other 63 bits, so the whole word holds an even number of 1s. | 1 |
| 58..56 | spin | The spin class; in a codex, the model order. | 0 |
| 55..24 | quat32 | Four 8-bit codes w, x, y, z. BioChain-AI’s Python reads each as code/127 and forbids −128. In a crystal they are raw hash bits. | 41D88D8B |
| 23..8 | payload16 | A raw 16-bit integer; in a crystal, the chunk length in bytes. | 60 |
| 7..3 | freq | A selector; in a crystal, the top five bits of an 8-bit byte-sum checksum. | 29 |
| 2..0 | amp | A selector; in a crystal, the low three bits of that checksum. | 2 |
The check word 9841D88D8B003CEA is what crystallize gives for the 60 bytes 0, 1, …, 59. Owl Academy, BioChain-AI and Ebayednoob all pin it. Its fields read back as they should: a chunk length of 60, and a checksum of 29·8 + 2 = 234, which is 0 + 1 + … + 59 = 1,770 modulo 256. The 32 middle bits are a 64-bit fold of the bytes, folded again to 32.
SHD-CCP’s manual calls the quaternion field “FP4”. BioChain-AI’s Python kernel reads four int8 codes, value = code/127, with −128 forbidden. A crystal packet holds raw hash bits, and the weave reads them again as a float quaternion (crystalQuat). All three readings live in the code. The second one causes the 0x80 divergence of chapter 8.
The shdccp/2 stream
- Cut. UTF-8 text of at most 60,000 bytes (
MAX_GROW_BYTES, the budget of one Firestore document) is cut into 720-byte chunks. - Code. Each chunk goes through an order-2 rank coder that starts fresh for every chunk. Each byte is written as its rank, by frequency, among the bytes already seen after the same two bytes, in Elias-gamma code. A byte not seen there yet gets the next rank as an escape, followed by its 8 raw bits. It is lossless by construction.
- Crystallize. Each chunk also becomes one form-9 Blackwell word: payload16 holds the chunk length, freq and amp the checksum, and parity is set last.
- Frame. A frame is the 16-hex packet, an 8-hex (32-bit) residual length in bytes, and the residual. The frames are joined into one hex string, the stream, marked
streamVersion: "shdccp/2". - Commit. Leaf i is SHA-256 of the string
i + "|" + SHA-256(chunk), both hashed over strings (the exact rule is in chapter 8). The leaves are hashed in pairs, level by level, into a Merkle root; on a level with an odd count the last node is duplicated. - Weave. Each chunk’s crystal also gives a unit quaternion. Their ordered product, renormalised after every step with
Math.hypotand written with 12 decimals (toFixed(12)), is the chiral weave float. A mirror weave runs over the conjugates in reverse order. - Name.
chainId= “BC-” and the first 24 hex digits of SHA-256(merkleRoot + “|” + weaveChiral). An optional engram layer adds 64 bits per word token. - Sign. In BioChain-AI, publishing signs the commitment
GROWN/1|chainId|merkleRoot|weaveChiral|weaveMirror|origBytesas an ATTEST/1 attestation: ECDSA P-256 overATTEST/1|keyId|keyVector|SHA256(commitment)|epochToken, checked against a key registry. A new epoch also signs a GROWTH/1 commitment. Owl Academy signs the same commitments with a Minor Tome seal: ECDSA P-256 overSEAL/1|sealId|sealVector|SHA256(commitment)|tickToken.
Codices travel in the same word: a codex stream opens with GEAR (form 1), carries PRIME entries (form 2) and closes with HALT (form 0), a closed instruction set.
Measured. Spike S4 grew all 55 WordNet verb and adjective gloss shards, and 8 synthetic ones, with a spike-only synchronous grower built from biochain_v1.js and the orbital core’s SHA-256. Field for field, it gave the record of Owl Academy’s own growBiochain on 126/126 records, with engrams on and off. Owl’s verifyIntegrity accepted every engrams-off record (63/63). Per full 60 KB gloss shard:
| Spike S4, per full gloss shard | Value |
|---|---|
| Chunks | 84 |
| Stream, hex characters per text byte | 1.7120 |
| Residual, bits per text byte (the rank coder alone) | 6.7134 |
| Value = text bytes / shipped bytes, engrams off / on (median) | 1.1016 / 0.4860 |
| Engram layer, bytes per word token | 6.7 |
| ~ Encode, decode, whole synchronous grow (median, this container) | 24.9 / 22.3 / 40.9 ms |
“Shipped bytes” count what a record carries: the stream, 32 bytes per leaf hash, a small fixed overhead and, with engrams on, the engram layer. A value near 1 means the record is about as large as the text: the rank coder alone writes 6.7134 bits per text byte, against 8. For context only, and never claimed, the output’s “~” line gives gzip -9 at 3.1230 bits per byte on the same shards.
What verifyIntegrity checks, and what it does not
Owl’s verifyIntegrity checks, stopping at the first failure: packet parity, decoding, each leaf, the rebuilt Merkle root, the chiral weave, then the engram layer recomputed from the text. But leaves and root are checked only when present. A packet’s crystal and checksum are never compared with the rebuilt chunk. chainId and the mirror weave are not recomputed. So it proves self-consistency, not authenticity.
Spike S4 saw it accept records with leafHashes and merkleRoot deleted, with a crystal bit flipped and parity re-fixed, with chainId altered, and with residual bit flips that decode to the same bytes (3.5515% of single-bit flips of a residual; a re-encode check rejected 689 of 689). It rejects swapped frames. The Lexicon’s stricter importer is claim L10 (Explainer 4). In Phase 3, on 50 C0 packages of each class, Owl’s verifyIntegrity accepted 50 of 50 in each of T1 (leaves and root deleted), T2 (a crystal changed, parity re-fixed), T8 (chainId altered) and T9 (a residual flip that decodes the same), while the hardened importer rejected all 450 tampered packages, in JS and in Python (Explainer 11).
ATTEST/1 in two languages
Spike S7 ran BioChain-AI’s own attestation code in Node and checked it in Python. WebCrypto writes a signature as IEEE P1363 r‖s (64 bytes); Python’s cryptography expects DER. Python verified Node’s signatures 200/200 after conversion and 0/200 raw; the way back must left-pad r and s to 32 bytes. The high-S twin (r, n − s) also verifies, in WebCrypto, node:crypto and Python, so signatures are not unique and nothing may be keyed by signature bytes. (“~” timing: the whole attestation step, 0.2341 ms per shard in Node.)
The 60 KB lineage cap
A biochain grows by epochs. extendBiochain recreates the parent’s text, appends the new text and regrows the whole through growBiochain, which throws above 60,000 bytes. So the cap holds for a whole lineage, not only for one step. Corpus-scale language data must therefore be many independent shards tied together by a manifest. WordNet’s noun synsets make 148 shards (the registered set C0). Spike S4 extrapolates BabyLM strict-small (55 MB) to 918 shards and strict (550 MB) to 9,178. The manifest is an RFC 6962 Merkle tree (Explainer 4).
Eight layouts, live
At least eight bit layouts are in use for “the” 64-bit SHD-CCP word. They are not compatible. The Form sits in four different places, and one layout has no Form at all.
| # | Layout | Where it lives | Form field | Form of 9841D88D8B003CEA |
|---|---|---|---|---|
| 1 | RFC 01 draft tile: South Halo 63..56, Form 39..36, 52 opaque payload bits | geometric-engine-spec/rfcs/01_einstein_tile_64bit.md; all six bindings | 39..36 | 8 |
| 2 | Kernel Ontology header | 00_Ontology_Core/base_64bit_tile.json | 63..60 | 9 |
| 3 | Blackwell word: form 63..60, parity 59, spin 58..56, quat32 55..24, payload16 23..8, freq 7..3, amp 2..0 | Owl scripts/biomesh.js; BioChain-AI biomesh.js and shdccp_kernel.py; Ebayednoob biochain_v1.js and lattice_seed_v1.js (verbatim pins) | 63..60 | 9 |
| 4 | genesis.js BLACKWELL_SCHEMA: the same widths in another order (ST, PT, PL 58..48, CO 47..16, PL 15..11, FR 10..6, SP 5..3, AM 2..0) | genesis/assets/genesis.js | 63..60 | 9 |
| 5 | Explainer “Z-slabs”: four 16-bit slabs; in the toroidal mode Form sits at 47..44 | assets/explainer.js | 47..44 | 13 |
| 6 | Geometric Calculator V2: Halo 63..56, Gate 55..48, Ctrl 47..32, Core 31..0 | Geometric_calculator (V2).html | none | — (gate 65) |
| 7 | Ebayednoob orbital packTile: step 63..61, wheel 60..58, struct 57..56, gate 55..48, mux 47..44, form 43..40, slot 39..36, scale 35..32, core 31..0 | scripts/geometric-build/orbital_core.js | 43..40 | 8 |
| 8 | Owl text_to_codex: FP16 scaler 63..48, freq 47..43, spin 42..40, form 39..36, amp 35..33, parity 32 (over the quaternion bytes only), W X Y Z as FP8 31..0 | Owl Ontological_Codex/text_to_codex.py | 39..36 | 8 |
So the check word reads as Form 9 under three layouts (2, 3, 4), Form 8 under three (1, 7, 8) and Form 13 under one (5). Layout 6 has no Form; it reads bits 55..48 as a gate byte, 65. Seven readers, three different answers, and one that does not ask. In the Blackwell reading, the other fields are parity 1, spin 0, quat32 41D88D8B, payload16 60, freq 29 and amp 2.
The decoder is plain JavaScript on BigInt. Each strip runs from bit 63 (left) to bit 0; the gold field is that layout’s Form. The Crystallize row uses Engram’s verbatim pin of Owl’s codec, biochain_v1.js, to turn the first 720 bytes of your text into the packet a biochain of it would carry first. Presets: the check word; the chunk 75, 0, 7, whose crystal holds 0x80, as Owl’s JavaScript and BioChain-AI’s Python write it (spike S4); the first tile of an Engram memory word whose α cell is GEODESIC’s engram/1 key (F = 24, address 0), from engram_core.js; kernel 0xA holding id 1, the word [0]; packWord(2, 3, [1, 2, 3, 4], 0x1234, 5, 6).
- check word: three Form values from seven readers. Only the Blackwell reading shows a valid crystal: 60 bytes, checksum 234.
- 0x80, as JS and as Python: one chunk, two packets. Under the Blackwell layout they differ only in one quaternion code (−128 against −127) and the parity bit; both pass parity.
- Engram Form 5 tile: the orbital layout reads Form 5, the Blackwell layout Form 15 (Owl’s LINK gate), RFC 01 Form 0. This is why Engram’s tiles are never called SHD-CCP (chapter 6).
- kernel 0xA: the Ontology reads Codex_Semantics; a Blackwell reader inside an Owl stream would read the ROT gate (chapter 7).
- Change the check word’s last digit from A to B: one bit flips and the Blackwell parity fails. Change it to 9 instead (two bits) and parity passes again, though the word is wrong. Most other layouts have no parity at all.
Every Form value is taken
A Form nibble has 16 values. Each one already means something to at least one consumer. So a new kind of data, such as a language kernel, cannot be told apart by its Form.
| Form | Owl Academy (Blackwell word) | Also in the Blackwell word | Ontology domain and registry | genesis.js | RFC 01 |
|---|---|---|---|---|---|
| 0 | 0D point | codex HALT | Telemetry · Base Route | Tetrahedron | standard scaling |
| 1 | Platonic solid | codex GEAR | Telemetry · Hurwitz Core | Cube | standard scaling |
| 2 | Platonic solid | codex PRIME | Telemetry | Octahedron | standard scaling |
| 3 | Platonic solid | — | Telemetry · Exact Scalar | Icosahedron | high-precision lossless correction |
| 4 | Platonic solid | — | Geometric Pointers · Voxel Cube | Dodecahedron | — |
| 5 | Platonic solid | — (Engram’s tiles use 5 in the orbital layout) | Geometric Pointers | Truncated Tetrahedron | geometric pointer / codex amplification |
| 6 | 4D hypercube | — | Geometric Pointers · Stella Octangula | Cuboctahedron | — |
| 7 | 8D E8 lattice | — | Geometric Pointers | Truncated Icosahedron | — |
| 8 | HALT gate | — | Codex Semantics · Holographic Triplet [COMPUTED], Geodesic Icosahedron | Rhombicuboctahedron | — |
| 9 | SEED gate | the data crystal of crystallize | Codex Semantics | Icosidodecahedron | — |
| 10 | ROT gate | — (kernel 0xA proposed for the Ontology) | Codex Semantics | Truncated Cuboctahedron | — |
| 11 | XFOLD gate | — | Codex Semantics | Snub Cube | — |
| 12 | MIRROR gate | BioChain-AI Cocoon: ENTRAIN | Memory Offload · 12-Engine Parity | Snub Dodecahedron | — |
| 13 | SPLIT gate | Cocoon: SYNC | Memory Offload | Cosmohedron | — |
| 14 | MERGE gate | Cocoon: BIOFRAME | Memory Offload | Undefined Form (void / overflow) | — |
| 15 | LINK gate | — | Memory Offload | Undefined Form (void / overflow) | — |
Sources: Owl’s BIOMESH_SYSTEM.md (lines 295–302) splits the nibble by its top bit, geometry below 8 and gates from 8. The codex opcodes reuse 0–2. BioChain-AI’s Nested Harmonic Cocoon claims 12–14. The Kernel Ontology splits the 16 values into four domains, and its registry holds kernels at 0x0, 0x1, 0x3, 0x4, 0x6, 0x8 (twice) and 0xC, all [OPEN] except the Holographic Triplet. genesis.js names all 16. RFC 01 gives meanings to Forms 0–3 and 5 so far. The explainer’s slab modes add one more reading: 0–2 cymatic, 3 TTP mode A, 4–11 TTP mode B, 12–15 toroidal.
Even inside one layout the values are shared. In Owl’s own Blackwell word, 0–2 are both geometry and codex opcodes, and 9 is both the SEED gate and the data crystal, told apart only by a flag kept outside the word (r:1 in a seed). The Codex_Semantics forms 8, 10 and 11, which a language kernel might want, are Owl’s HALT, ROT and XFOLD gates.
A namespace has to live above the word: a kind field in the stream or record header. The layout census asks SHD-CCP for one, and notes that BioChain-AI’s publishBiochain drops meta.kind today. The Lexicon does not wait: it names its data by record kind (chapter 6).
One bridge
Decision D7: the Blackwell word only at the Owl/BioChain bridge. What a piece of data is lives in record kinds above the word, never in a Form nibble.
shdccp/2 streams: the Blackwell word exactly as the pinned codec writes it, form-9 crystals only. No new form ever appears inside.verifyIntegrity and Engram’s importBiochain read the shards unchanged (claim L8).Why record kinds. No Form value is free (chapter 5), and the biochain document itself has no type field. Each Lexicon record carries {kind, spec: 'hyperbolic-lexicon/0.1', compat: 'biomesh-js'}, so a reader knows what it holds before it decodes anything: a vocabulary, an address table, a pre-processed shard, a corpus manifest, its growth, or benchmark receipts (Explainer 4).
Versioning
- Shards keep
streamVersion: "shdccp/2"and the JavaScript codec’s hashing (D8), so Owl’s and BioChain-AI’s verifiers accept them as they are. - Anything that changes bytes is only proposed, under a future
shdccp/3: how to write the 0x80 byte, binary RFC 6962 leaves, mandatory leaves, root and crystal checks, a recomputedchainId, the exact weave, and a kind field. - The Lexicon’s own versions are the
/1of each record kind.
Claim L8 registers the bridge: language shards are Owl-valid biochains, field for field, in JS and Python. Owl Academy’s and BioChain-AI’s own JavaScript are the authority for compatibility (D9). Spike S4’s 126/126 is a spike result on verbs and adjectives; L8 was decided in Phase 3, on the 148 noun shards and 20 synthetic ones: supported, with 0 of 336 records differing from Owl’s in any field, for our JS grower and for our Python port (Explainer 11).
Engram’s Form 5 tiles are not SHD-CCP
Engram Mind’s Eye sends each engram/1 cell as two Einstein tiles of Form 5 (its decision D3), packed with the orbital packTile layout, Form at 43..40. Its README calls Form 5 “unused elsewhere in the repository”, a statement about Ebayednoob alone. Outside it, RFC 01 makes Form 5 a geometric pointer, genesis.js a Truncated Tetrahedron, and Owl a Platonic solid. The same tile also reads differently:
| Reader | Takes its Form from | Form of F80005004CC2C901 |
|---|---|---|
Orbital packTile (what Engram meant) | bits 43..40 | 5 |
| Blackwell word | bits 63..60, Engram’s step and wheel bits | 15 (LINK) |
| RFC 01 draft | bits 39..36, Engram’s slot bits | 0 |
(The tile is the high half of an α cell holding GEODESIC’s engram/1 key, with F = 24 and address 0, as engram_core.js writes it; try it in the lab.) So the Lexicon never calls Engram’s internal tiles SHD-CCP-conformant. They stay inside Engram. What crosses to Owl Academy is the shdccp/2 stream, through the pins that Engram’s bridges already test (Engram’s bridges).
LPS p = 5: our tree is SHD-CCP’s overlay
The strongest link between the Lexicon and SHD-CCP is mathematical. The six generators of our address tree are exactly the Lubotzky–Phillips–Sarnak generators for p = 5. So the Ramanujan graphs X(5, q) that SHD-CCP’s RFC 03 plans as its peer-to-peer overlay are finite quotients of the same tree. (RFC 03 does not yet name LPS or its generators; the proposal below asks it to.)
Hyperbolic Oracles’ P.GENS are the integer quaternions 1±2i, 1±2j, 1±2k, each of norm 5. LPS take, for a prime p ≡ 1 mod 4, the quaternions of norm p whose first coordinate is odd and positive and whose other three are even. For p = 5 the only solutions are a first coordinate of 1 and one other coordinate of ±2: exactly these six, p + 1 of them. A reduced word never follows a generator with its own conjugate; the root has 6 children and every other node 5. A word of length L multiplies out to one integer quaternion of norm exactly 5L, and right division by the generators reads the word back exact. The Lexicon uses these words as training-free addresses for WordNet synsets (Explainer 3).
X(5, q), measured by spike S5
To build X(5, q), pick a prime q ≡ 1 mod 4 and a number ι with ι² ≡ −1 mod q. Then each generator becomes a 2×2 matrix mod q of determinant 5, and a word becomes the product of its matrices, taken up to a scalar (projectively). The Cayley graph has those matrices as vertices and joins two whenever one generator carries one to the other. Spike S5 built it for the three q of claim L7, on synthetic words only:
| Spike S5 | q = 13 | q = 17 | q = 29 |
|---|---|---|---|
| ι, with ι² ≡ −1 mod q | 5 | 4 | 12 |
| (5 | q), and the group | −1 · PGL(2, Fq) | −1 · PGL(2, Fq) | +1 · PSL(2, Fq) |
| Vertices | 2,184 | 4,896 | 12,180 |
| Bipartite | yes | yes | no |
| Diameter | 7 | 9 | 8 |
| Girth g (exact, three methods) | 8 | 8 | 9 |
| r = ⌊(g − 1)/2⌋ | 3 | 3 | 4 |
| Largest |λ| other than ±6 | 4.249721 | 4.308919 | 4.442016 |
| Ramanujan margin to 2√5 = 4.4721 | 0.222415 | 0.163217 | 0.030120 |
| Reduction mod q = walk from the identity | 1000/1000 | 1000/1000 | 1000/1000 |
| Words of length ≤ r on distinct vertices | 187 of 187 | 187 of 187 | 937 of 937 |
| Collisions at length ≤ r + 1 | 200 | 72 | 724 |
Each graph is 6-regular, connected and inverse-closed. The girth is the length of the shortest cycle. Up to radius r the graph looks like the tree, so distinct reduced words of length at most r land on distinct vertices, and collisions begin at r + 1. The eigenvalues come from numpy.linalg.eigvalsh in float64 float, cross-checked by exact power sums and by Lanczos; everything else is exact. The output reports “64/64 checks pass”. As “~” timings, eigvalsh took 2.6 s, 17.4 s and 161.2 s on this container, the last on a 1,131.8 MiB matrix.
SHD-CCP’s own arithmetic agrees
SHD-CCP’s HurwitzQuaternion works in doubled coordinates, so the generators are (2, ±4, 0, 0), (2, 0, ±4, 0) and (2, 0, 0, ±4). Spike S5 imported SHD-CCP’s hurwitz.py read-only. Its product, halved, equalled P.wordQuaternion on 1,000/1,000 words, and its norm was 5len on all of them; without the halving it never matched. The registered controls failed as they must: a wrong ι = 2 broke the walk on 968/1000 words at every q, a 4-generator subset gave a 4-regular graph, and the unhalved product disagreed. Claim L7 registers these checks, with these controls, on its own instances (one tree, three readings: address, H³ point and X(5, q) vertex). It was decided in Phase 1, not by the spike: supported, with no failure and every control failing (Explainer 9).
Exact Qh on the wire
RFC 03 defines a Ghost map into H³ with Qh = sinh² d, and lists an exact (integer or rational) representation of Qh on the wire as a TODO. For two points a, b on the hyperboloid, Qh = 〈a, b〉L² − 1, where 〈·,·〉L is the Lorentz inner product; for rational points it is a rational number. For points of the octahedral H³ tree, whose coordinates at depth n are integers over 7n (spike S1), it is N / 72(na + nb) for an integer N, so it can travel exactly as the pair (N, na + nb). exact The proposal SHD-CCP-RFC03-exact-Qh-and-LPS.md asks RFC 03 to name LPS p = 5 and adopt this form.
Reducing an address mod q gives a deterministic shard key: it tells which of the 2,184, 4,896 or 12,180 vertices, and so which node of an overlay, holds a synset. It separates only words of at most r letters (3, 3 and 4 at these q). It is never an integrity check. Cayley hashes on LPS graphs have known collision attacks (Tillich and Zémor, 2008; Petit, Lauter and Quisquater, 2008). SHA-256 stays the integrity primitive.
Kernel 0xA: the Hyperbolic Address Tile
The Lexicon proposes one kernel for the Ontology’s registry, aimed at its incubator at status [OPEN] (the proposal, the kernel file). It holds one reduced word of the norm-5 tree as a 59-bit id.
| Bits | Field | Type | Meaning |
|---|---|---|---|
| 60–63 | Form_ID_Header | multiplexer | 0xA |
| 59 | Even_Parity | bool | Even parity over the other 63 bits, as the Blackwell word’s bit 59 |
| 0–58 | Norm5_Address | residual_array | The bijective mixed-radix id of a reduced word of length ≤ 25: the number of reduced words shorter than it, plus its rank among words of its length (first letter in base 6, later letters in base 5) |
Words of length up to 25 number 1 + 6·(525 − 1)/4 ≈ 4.47·1017, fewer than 259, so they fit. On the verb forest, spike S3 found that 13,762 of 13,767 verb words (99.96%) fit the 25-letter tile, and 5 would need a continuation tile; nouns are deeper: in Phase 1, L3 found 74,630 of the 82,115 noun words (90.88%) within 25 letters, so 7,485 would need a continuation tile, and the longest has 36 letters (Explainer 9). check_kernel.py runs the Ontology’s own linter and its two implemented suites on a copy of the kernel, read-only. Run here with python3 -B -I "Pages/Hyperbolic Lexicon/proposals/check_kernel.py":
kernel Hyperbolic Address Tile (norm-5, LPS p=5) · Form 0xA · Domain Codex_Semantics · Status [OPEN] lint_kernel: pass layout_integrity: pass (3 fields tile bits 0..63 exactly once) glass_box_round_trip: pass (1000 random round trips and 3 isolation checks) pending suites (block [PROVEN]): 01_tqf_parity_checks, 02_toda_kogame_stress, 03_merkle_collision Form IDs already used in the registry: 0x0, 0x1, 0x3, 0x4, 0x6, 0x8, 0xc; 0xA is FREE allocation hash: 1aefabb16b7b12c3559b19700efa999120537a5cfe2cc9769473dafed8654126 kernel check: pass
Moved into the registry, it could reach [COMPUTED] through the validation bot. It cannot reach [PROVEN] until the three pending suites are defined and its dependency, Lemma 5, has a Lean proof. Two conflicts are declared. First, 0xA is free in the Ontology’s registry but is the ROT gate inside Owl’s and BioChain-AI’s shdccp/2 streams, so the kernel is never written into them (0xB would collide with XFOLD the same way). Second, the kernel follows the Ontology’s header at 60–63; if RFC 01’s Form position wins, it must be re-encoded.
Where JavaScript and Python part
The Lexicon’s method needs Python and JavaScript to agree bit for bit. The working SHD-CCP does not always. Six cases follow: two where the deployed JavaScript and BioChain-AI’s Python reference differ, a float weave that a Python port reproduces only with care, one name shared by two structures, one check that cannot fail, and the runtimes’ Unicode versions. Each gives what the spikes measured and how it is resolved.
| Divergence | Measured | Resolution |
|---|---|---|
| 1. crystallize and the byte 0x80 | S4: 1.4131% of gloss chunks | JavaScript is normative for shdccp/2 |
| 2. Leaf and Merkle hashing | S4: 126/126 records with the JS rule | Shards keep the JS rule; manifests use RFC 6962 |
| 3. The float weave | S4: naive port differs on 2 of 1,000 | A V8-faithful port now; an exact weave proposed |
| 4. Two structures called “Merkle” | S4: duplicate-last collides at every odd K ≥ 3 | Named apart, never mixed |
| 5. An always-true continuity check | Cannot fail by construction | Never reused |
| 6. Unicode versions | S6: 9,990 code points differ | Pinned Unicode 15.1 tables (D5) |
1 · crystallize and the byte 0x80
The JavaScript crystallize writes the 32-bit crystal raw, so a byte 0x80 stays, read as code −128. BioChain-AI’s Python pack() forbids −128: it writes −127 (0x81) and recomputes parity. For the bytes [75, 0, 7], with crystal codes [−72, −128, 99, 69], JavaScript writes 98B8806345000352 and the Python kernel 90B8816345000352.
| Spike S4 | Chunks with a 0x80 crystal byte |
|---|---|
| Analytic: 1 − (255/256)4 | 1.5534% |
| All 55 WordNet gloss shards | 64 of 4529 = 1.4131% |
| 1,000 synthetic shards (counted in Python) | 659 of 42384 = 1.5548% |
| Analytic share of 84-chunk records with at least one | 73.1545% |
On 63 shards (4,992 packets), the kernel’s packets differed from Owl’s on exactly the 70 with a 0x80 byte, only by −128 → −127 and parity. The normalised stream differed on 43 of 63 shards, exactly those with such a chunk. But merkleRoot, both weaves and chainId were unchanged on 63/63, and Owl’s verifyIntegrity accepted the normalised records 63/63. The reason: leaves and the weave are computed from chunk bytes, never from packet words. So chainId and merkleRoot do not commit to the packets, and a verifier must re-crystallize to check them.
Resolution. JavaScript is normative for shdccp/2, since every deployed record was grown in JavaScript. The Lexicon’s Python is to reproduce the raw word; spike S4’s raw port already matched Owl’s JS word on 4,992/4,992 packets. The BioChain-AI proposal asks its Python to write crystals raw as well, and to settle the case for good under shdccp/3; since leaves and weaves come from chunk bytes, writing raw changes no deployed chainId. L8’s first control is a Python grower with the kernel’s normalisation, which must differ from Owl’s record on at least one synthetic shard. In Phase 3 it differed on 20 of 20, in the stream only; 189 of C0’s 12,378 chunks (1.527%) have a crystal holding 0x80; and the Lexicon’s Python port, which writes the word raw, gave Owl’s record on 336 of 336 (Explainer 11).
2 · Leaf and Merkle hashing
The JavaScript hashes strings: leaf i = SHA-256(i + "|" + sha256Hex(String.fromCharCode(...chunk))), and a parent hashes its two children’s hex strings joined; an empty list’s root is SHA-256(“empty”). String.fromCharCode turns each byte into a code point, and SHA-256 then reads the UTF-8 of that string, so every byte from 0x80 up is hashed as two bytes. BioChain-AI’s Python codex_engine.py hashes binary instead, SHA-256(4-byte index ‖ SHA-256(chunk)), with 32 zero bytes for an empty root. Neither side can verify the other’s chains.
Resolution. Shards use the JavaScript rule (D8), and the Lexicon’s Python is to reproduce its quirk exactly. Spike S4 found the orbital core’s SHA-256 equal to Node’s over UTF-8 on 1,000/1,000 strings, and the JS-rule grower equal to Owl’s on 126/126 records. L8’s second control, a grower that hashes leaves over binary bytes, must differ on every non-empty shard; in Phase 3 it differed on 168 of 168, and Owl’s verifyIntegrity rejected all 168 (Explainer 11). Manifests use RFC 6962 instead, defined once and tested with vectors (L9).
3 · The float weave
The chiral weave renormalises with Math.hypot and prints with toFixed(12) float. A one-ulp difference at a rounding edge changes the string, and so chainId. Spike S4 compared Python ports with Owl’s JavaScript on 1,000 synthetic shards:
| Python port of the weave | Shards with any difference |
|---|---|
Faithful: V8’s Math.hypot algorithm, exact toFixed(12) | 0 of 1000 |
Naive: Python’s math.hypot, format(x, '.12f') | 2 of 1000 |
The cause is hypot, not formatting: math.hypot differed from V8’s on 39,408 of 127,152 calls (30.9928%), while format and toFixed(12) differed on 0 of 8,000 weave components.
Resolution. The Lexicon’s Python port is to reproduce V8’s Math.hypot algorithm and toFixed(12) exactly, as L8 registers. For shdccp/3 it proposes the exact norm-5 weave instead: engram_core.chainQuaternion over the first 8 bytes of each leaf hash exact. Spike S4 checked it on one verb shard of 84 leaves: its norm is exactly 52352, its components have 2,729–2,730 bits, it unfolds to the leaf prefixes in order, and the 7 segment products multiply to it. Claim L9 tests it on every shard (Explainer 4). In Phase 3 the Python port matched Owl’s float weave on every record (L8), and all 148 C0 exact weaves were exact, with components of 971–2,731 bits, equal in JS and Python (L9(b); Explainer 11).
4 · Two structures called “Merkle”
The orbital core’s “Lemma 15 Merkle chain” is a linear backward chain: τN = H(GN), τd = H(Gd ‖ τd+1). Biochains use a binary tree with the last node duplicated on odd levels. They prove different things and are not interchangeable. The tree rule is also malleable: [a, b, c] and [a, b, c, c] build the same tree. Spike S4 showed this on real leaf hashes, and found that for K = 1..200 a list and the same list with its last element repeated have equal roots at every odd K ≥ 3 (99 values), but not at K = 1. RFC 6962 roots of the same lists were equal at 0 of 200.
Resolution. The two are named apart and never mixed. The Lemma 15 note proposes an RFC 6962 statement of Lemma 15 for SHD-CCP. L9’s first control is exactly this collision; in Phase 3 it occurred at K = 3, 7 and 1,001, while the RFC 6962 manifest detected every alteration (Explainer 11).
5 · An always-true continuity check
Owl Academy’s Engram Mind Eye computes each packet’s chained header as (fold32(seed64) ^ rotl32(prevParity, 1)) >>> 0 (line 872). Lines 889–890 then “check” it by recomputing the same expression from the same inputs and comparing. The check cannot fail, so it detects nothing.
Resolution. It is never reused as an integrity check. Engram Mind’s Eye does not rely on it; its integrity comes from SHA-256 and the Merkle chain. The Owl notes describe a real check: recompute the header from the stored previous packet and compare it with the stored current header.
6 · Unicode versions
Spike S6 swept every code point in three runtimes. Node 22.23.4 carries Unicode 17.0 (ICU 78.3), Chrome for Testing 153 behaves as Unicode 17.0, and Python 3.13.18 carries 15.1.0. Node and Python gave different general categories on 9,990 code points, and different lowercase, decomposition and combining-mark values on 55, 20 and 76; Node and Chromium agreed on all. On the 20,520 cases of the stress set, a normaliser built from the platform’s toLowerCase, normalize('NFD') and \p{Mn} differed from Python’s on 725, in Node and in Chromium alike. (These counts are “~” lines: they depend on the runtime versions.)
Resolution. D5: the normaliser runs on Unicode 15.1 tables exported from Python and pinned by SHA-256, fails closed on code points unassigned in 15.1, and never calls the platform’s functions. S6’s prototype table (142,041 bytes as compact JSON) reproduced Python’s lowercasing, Final_Sigma, decomposition and mark removal with 0 mismatches on all 1,112,064 code points alone and on 2,000 synthetic strings. Claim L1 tests the whole front end (Explainer 3).
Smaller ones
- Two engram hex conventions. Engram streams write a key’s bytes least significant first (GEODESIC →
5C896A4801C9C24C); Owl’s Mind Eye packet writesseed64byte-reversed (4CC2C901486A895C). Streams use the first; the Lexicon’s golden JSON is to pin both. - Two engram tokenizers. “don’t” becomes [DON, T] in Owl’s Engram Mind Eye and [don’t] in
biomesh.js. The engram layer followsbiomesh.js; the Lexicon’s tokenizer is a third, pinned one. verifyIntegrity’s scope (chapter 3). The Lexicon’s verifier is a strict superset, claim L10.- The value laws differ between the JavaScript and the Python; they are reported only, never compared.
One thing already agrees: the survey found the order-2 rank coder’s unprimed residuals (no codex prior) bit-identical in the two languages.
Golden vectors
A golden vector is a fixed input together with its exact expected output, which every implementation must reproduce. SHD-CCP already has a format for them. The Lexicon proposes six suites in it.
The format. SHD-CCP’s golden vectors have two parts: a JSON envelope that validates against schema.json (suite, spec_version, rfc, status, description, generator, binary, cases), and a little-endian binary mirror: the magic SHDGEV01, a 32-bit field count F, a 32-bit record count N, then N×F 64-bit records. Values above 253 are strings in the JSON. The suites are regenerated byte for byte and CI fails on drift. Today they hold 2,366 cases:
| SHD-CCP suite | RFC | Status | Cases |
|---|---|---|---|
einstein_tiles_forms_0_15 (the RFC 01 layout) | 01 | draft | 66 |
garner_crt_881_883_887 | 02 | normative | 2,000 |
gram_tqf_collinearity | 02 | normative | 300 |
hurwitz_primes_and_s5, memory_erasure_cases, handshake_alignment | 02, 04, 06 | pending | 0 |
Two constraints. Every suite that is not pending needs a binary object, so only fixed-width records fit SHDGEV01. Variable-length data (tokenizer outputs, address words of varying length, whole shards, exact points with hundreds of bits) cannot go in the binary mirror. It stays in the Lexicon’s own golden JSON, as Engram Mind’s Eye keeps its E1 corpus, and enters SHDGEV01 only as the four 64-bit limbs of a SHA-256.
| Proposed suite (draft, 0.1.0) | RFC | Binary fields | What it pins |
|---|---|---|---|
lexicon_address_codec | 03 | len, id, q0..q3 | A reduced norm-5 word: its 59-bit id (64-bit for lengths 26–27) and its integer quaternion |
blackwell_crystallize_compat | 01 | chunk_sha_0..3, js_word, py_word | A chunk’s crystal as the JS codec writes it and as BioChain-AI’s Python writes it, with at least 64 chunks whose crystal holds 0x80 |
lps_x5q_reduction | 03 | q, id, a, b, c, d | A word’s quaternion reduced to a projective 2×2 matrix mod q, for q ∈ {13, 17, 29} |
lexicon_h3_point_digest | 03 | id, depth, sha_0..3 | SHA-256 of the canonical exact H³ point; the full point in the JSON case |
lexicon_h2_point_digest | 03 | id, depth, sha_0..3 | The same for the exact H² tree (t = 11/13) |
rfc6962_vectors | 03 | n, root_0..3 | RFC 6962 roots of n synthetic leaves, n ∈ {1, 2, 3, 7, 84, 200, 1000, 1001}; the JSON adds proofs and the duplicate-last failing cases |
These suites are not generated yet. The Lexicon planned to write them in Phase 3, with its own generator (reference/golden/make_shdgev_v1.py --check), once claims L3, L7, L8 and L9 had code and passed. All four are now supported, but the suites were not written in Phase 3: they decide no claim, and they are carried over (README). A test will validate every envelope against SHD-CCP’s schema.json, read-only. The compatibility suite does not pick a winner for the 0x80 case; it documents the divergence so that every binding can test against it (the proposal).
Vectors the spikes already reproduced. Spike S4 reproduced the Certificate Transparency reference roots (9/9) and RFC 6962’s worked proofs (7/7). Spike S7 produced a deterministic golden ATTEST/1 under RFC 6979’s public test key (a known-answer vector, never a signing key): keyId K-ba70de20e32549d49e6bd616, verified in WebCrypto, node:crypto and Python, and through BioChain-AI’s own verifyAttestationAgainstContent.
The proposals
Hyperbolic Lexicon reads SHD-CCP, BioChain-AI and Owl Academy, and never changes them. What it would like them to change is written down as proposals, to be sent after Phase 3, when they can carry measured numbers instead of estimates. After Phase 3 they were finalised with its measurements (proposals/README.md).
| Document | For | In one line |
|---|---|---|
| README.md | all | These are proposals only; each cites the files and lines it rests on, from the read-only survey. |
| SHD-CCP-RFC01-layout-census.md | SHD-CCP | Eight incompatible 64-bit layouts and every Form value claimed: settle RFC 01 against the Blackwell word, and carry kinds above the word. |
| SHD-CCP-RFC03-exact-Qh-and-LPS.md | SHD-CCP | Name LPS p = 5 in RFC 03: our norm-5 tree is the tree X(5, q) is a quotient of; exact Qh on the wire; worked vertex counts and girths. |
| SHD-CCP-Lemma15-note.md | SHD-CCP | Two structures called “Merkle”; the biochain rule is malleable; a Lemma 15 for RFC 6962 trees, and vectors for the pending 03_merkle_collision suite. |
| SHD-CCP-kernel-hyperbolic-address.md, kernel_0xA_hyperbolic_address.json, check_kernel.py | SHD-CCP | Kernel 0xA, the Hyperbolic Address Tile, at [OPEN]; it passes the Ontology’s own lint and suites. |
| SHD-CCP-golden-vectors.md | SHD-CCP | SHDGEV01 suites for the address codec, the Blackwell compatibility case, the LPS reduction, exact points and RFC 6962 roots. |
| BioChain-AI-language-chains.md | BioChain-AI | Language pre-processing biochains: shards past the 60 KB lineage cap, typed records, a hardened verifier, two tiers for licences, and the shdccp/3 decisions. |
| Owl-Academy-notes.md | Owl Academy | The always-true continuity check, a publish path that cannot succeed, HMAC certificates keyed by a public ID, verifyIntegrity’s gaps, the tokenizer and hex mismatches, and an engram/2 key. |
Nothing. It sorts SHD-CCP’s layers and fixes where the Lexicon meets them (D7, D8). Claims L1, L3 and L7–L10, which this page touches, are registered. Phase 1 decided L7 and L3’s Python side, Phase 2 L1 and L3(f) (Explainer 10), and Phase 3 L8–L10 (Explainer 11), all supported, on the instances fixed in PREREGISTRATION.md (ledger). Whether SHD-CCP’s maintainers adopt any proposal is outside what the preregistration decides.