Hyperbolic Lexicon · Explainer 11 · Phase 3

Language Biochains, Measured

Phase 3 built what Explainer 4 designed in Phase 0: language shards grown as Owl Academy’s shdccp/2 biochains, in JavaScript and in Python; typed records that bind each shard to its source, tokenizer and addresses; an RFC 6962 manifest over a corpus; an exact weave; and a hardened verifier that checks ATTEST/1 signatures. The definitions came before the code, the disclosures before the run. One run then decided L8, L9, L10 and L11: all four are supported under their registered rules, L11 on packages grown with engrams off, a reading Amendment 8 fixed after the dry runs and states plainly. On this page you can grow, sign, verify and tamper with a shard of your own.

The four decisions Grow and verify a shard Amendment 8 What this does not show Claims ledger
decided: L8, L9, L10, L11 · all supported L8: 0 of 336 records differ from Owl’s L10: 0 false accepts, 0 false rejects of 500 L11: median 155.4 ms against a 250 ms bar
Contents
  1. Where this sits
  2. How Phase 3 was ordered
  3. What was built
  4. Grow, sign and verify a shard
  5. L8 · Owl-valid biochains
  6. L9 · The manifest and the weave
  7. L10 · The hardened import
  8. L11 · Cheap enough to verify
  9. What this does not show
  10. Phase 4, planned and done
01

Where this sits

A shard holds text; everything the front end derives from it travels as typed commitments; a manifest ties the shards of a corpus together; a signature says who committed. Explainer 4 designed this in Phase 0, before any measurement. Phase 3 built it and decided the four claims about it. This page’s focus node is the shards and manifests.

The code is the chain section of lexicon_core.js (lines 1,568–2,868 of its 2,928) and its Python twin in reference/lexicon/: chain.py (709 lines), records.py (303), manifest.py (201), attest.py (275) and verify.py (410). The runner is run_claims_phase3.cjs, with its Python half run_claims_phase3.py. Every number on this page comes from results/claims-phase3.json (summarised in claims-phase3.md), the console log phase3-console.txt, the registry snapshot phase3-registry.json, the dry run in results/dry/, PREREGISTRATION.md (L8–L11, D7, D8, Amendments 7 and 8), the commit messages, the source files themselves (their line counts and docstrings) and Explainer 4; the lab’s values come from your own browser. Where this page and those files differ, the files win.

How to read this page

supported means what the registered decision rule says, and nothing more. L8, L9 and L10 are exact: every case passed and every control showed its weakness. L11 is measured: the upper end of the 95% interval of the median is at most 250 ms, and its control, as Amendment 8 replaced it, holds. A prediction was written with each claim; it is not part of the rule.

Timings belong to this container. L11 is decided on time, on this container, as registered; every other time on this page is reported and marked “~”.

Shard
At most 60,000 bytes of UTF-8 grown into one unmodified shdccp/2 biochain (D8). C0 is WordNet 3.0’s noun glosses, one line per synset, offset TAB lemmas TAB gloss, cut at line boundaries: 148 shards, 147 of them at least 59,000 bytes.
Record
Owl Academy’s biochain object, fifteen fields in Owl’s order: chainId, stream, streamVersion, leafHashes, merkleRoot, weaveChiral, weaveMirror, segCuts, segments, engramStream, engramCount, engramMeanJ, origBytes, shippedBytes, value. With engrams off, the three engram fields are absent.
Engrams on, off
Owl’s growBiochain can add an engram layer: 16 hex digits of engram/1 for every word token. The Lexicon keeps engram/1 as a compatibility checksum, never an input (D4), and off by default for corpora (Explainer 3).
Commitment
A typed record kind of D7, a pipe-joined string hashed with SHA-256: LVOCAB/1, LADDR/1, LPREP/1 (one per shard), LCORPUS/1, LGROW/1.
Package
What a holder hands to the verifier: the record, its LPREP/1 string, an ATTEST/1 block, the LCORPUS/1 string with the shard’s inclusion proof, and an LGROW/1 string with its consistency proof (Amendment 7 item 6).
Session
What a verifying holder pins once: V0, the LVOCAB/1 string, the LADDR/1 string (its addrTableRoot recomputed from WordNet once per session) and the key-registry snapshot with its SHA-256.
Self-consistent, authentic
The verifier’s two verdicts. Self-consistent: the record, its derived layers and its place in the manifest agree. Authentic: a registered, unrevoked key signed exactly this LPREP/1. Explainer 4 defined both; Amendment 8 item 3 made the code follow it.
Tamper class
One of L10’s nine registered alterations, T1–T9, 50 records each (chapter 7).
Dry run
The runner on data no claim uses: Rng(4000 + i) synthetic shards, the verb and adjective gloss shards, tampers from Rng(5000 + …), the verb shards standing in for C0 (Amendment 7 item 8). It decides nothing.
Decisive run
The one run on the registered instances that decides: node "Pages/Hyperbolic Lexicon/reference/run_claims_phase3.cjs", on the code committed at 6da04be.

The four decisions at a glance

ClaimWhat it saysDecisionResultControls that must show their weakness
L8Language shards are Owl-valid biochains, field for field, in JS and Python; Owl’s and BioChain-AI’s verifiers accept them; Engram imports them; the derived layers and LPREP/1 agree across languagessupported
JS grower and Python port
0 of 336 records (148 C0 and 20 synthetic shards, engrams off and on) differ from Owl’s own growBiochain in any of the fifteen fields, for either growerBioChain-AI’s normalisation differs on 20/20 synthetic shards; leaves over binary bytes differ on 168/168 and Owl rejects them; one altered byte changes leaf and root on 168/168
L9The RFC 6962 corpus manifest, its append-only growth and the exact norm-5 weavesupportedThe manifest over C0 (K = 148) and eight synthetic lists (K up to 1,001): every root and proof equal in JS and Python, every alteration detected, every wrong proof rejected; 148 of 148 exact weaves exactThe shdccp/2 rule collides at K = 3, 7 and 1,001; an XOR summary misses every adjacent swap checked
L10The hardened importer accepts every clean attested record and rejects every registered tamper, naming the check, identically in JS and Pythonsupported50 clean and 450 tampered packages: 0 false accepts and 0 false rejects in each language, verdicts identical on all 500Owl’s verifyIntegrity accepts 50/50 of T1, T2, T8 and T9; Python without the P1363-to-DER conversion accepts 0 of 126 signatures
L11A full C0 shard verifies, every hardened check included, in a median of at most 250 ms in Nodesupported
engrams-off packages (Amendment 8)
147 shards: median 155.4 ms, 95% interval [154.2, 156.0]. Reported: engrams-on packages 243.6 ms, the address table recomputed in every verification 1,350.2 msThe step check (Amendment 8 item 2): the attestation ran inside the timed window in 441/441 full verifications and was skipped in 441/441 control verifications

With these four, ten of the eleven claims were supported: L1–L5 and L7–L11, L3 in full and L4 in its decided parts, (a) and (b) (Phase 1 in Explainer 9, Phase 2 in Explainer 10). Left open by Phase 3: L4(c) and L6, the learned embeddings, which Phase 4 decided, both supported, L6(c) against its registered prediction, so all eleven are now supported (chapter 10; Explainer 12).

02

How Phase 3 was ordered

Definitions first, then code, a review and dry runs, then an amendment, then one decisive run on the code as committed. Six commits from 2026-11-05 to 2026-11-06 (times in UTC, from git) record the order; a container restart is part of it.

  1. 1ad40d0 · 11-05 23:32 · Amendment 7, before any code for its claims. Written before any record, grower port, manifest, verifier or runner for L8–L11 existed, with no Phase 3 result known: the code and its authorities, L8’s synthetic shard generator, the exact record strings and Tier-P salted roots, the exact weave and its segments, the RFC 6962 conventions and L9’s lists, L10’s packages, keys, registry, draws and verdicts, L11’s timing, and the dry runs. Nothing registered was changed.
  2. b822237 · 11-06 00:52 · The build, saved after a restart. A container restart cut the build workflow off during its dry run. The work on disk was kept and committed as it stood: the chain section of lexicon_core.js, the five Python modules, the chain trace (traces/chain_v1.txt, reproduced by the JS line for line, parity now 19,991/19,991), the Owl and BioChain-AI compatibility pin, the tests and the runner. “No decisive run has been made; the dry run is to be redone.”
  3. Between the commits: a review and dry runs. Amendment 8 records them; no commit holds their output except the final dry run’s. Three reviewers, two skeptics for every finding, confirmed one finding: L11’s control could not show whether the attestation step is timed (item 2). The others were not confirmed. The dry runs raised the engrams-on question that became item 1. The builders timed verb shards (dry data) and hashed C0’s shard texts against their pins; no C0 shard was grown, verified or timed before the decisive run (item 5).
  4. 8c51e08 · 03:57 · The runner and verdict changes for Amendment 8, before any decisive run. Packages grown with engrams off; L11’s control read from each verification’s own record of its checks; the two verdicts as Explainer 4 defined them, changed identically in both languages (eight verdict lines of the trace changed; parity 19,991/19,991, chain tests 30/30, Python Phase 3 tests 62/62).
  5. 25b48b3 · 04:15 · The final dry run, started 03:56:57, 17 min 46 s: L8 supported for both growers (0 of 150 records differ), L9 supported, L10 supported (0 false accepts or rejects of 472 packages), L11 supported on 21 verb shards (median 156.2 ms, interval [150.1, 162.0]; engrams on 229.4 ms, reported; the step check 63/63).
  6. 6da04be · 04:15 · Amendment 8, before any decisive run (chapter 8): engrams off, disclosed with the dry-run numbers that preceded it; L11’s control replaced; the verdicts; the readings fixed in the code; the restart, the review and the environment. “No result on a registered instance was known.”
  7. The decisive run · started 04:15:30. Once, on the code at 6da04be, in 50 min 44 s. It first reran the parity (19,991 of 19,991 lines, none skipped, the chain trace 1,323/1,323) and checked that Owl Academy (7f45f35, scripts/biomesh.js 7ffd768c…) and BioChain-AI (c975161, src/biomesh/biomesh.js a2e2056f…) were unchanged.
  8. 865791f · 05:07 · The results, as they came out: claims-phase3.json and .md, the console log and the registry snapshot. Every case is reported; per-instance data (Python’s records, the packages, the L11 times) stay in the cache, outside git.

What Amendment 7 fixed

ItemWhat it fixes
1 · codeThe JS is a new section of lexicon_core.js on biochain_v1.js, engram_core.js and orbital_core.js, unchanged; the Python port is chain.py, records.py, manifest.py and attest.py. Owl’s code is the authority for L8(a, b), run unchanged in Node by name-grab; the Python reference for L8(d), L9 and L10’s verdicts, which the JS must equal
2 · synthetic shardsShard i from one Rng(1000 + i): 20,000 + below(40,001) bytes, code points by class (40% ASCII letters, 10% spaces, 5% punctuation, 30% two-byte, 10% three-byte, 5% four-byte), drawn again until a chunk’s crystal holds the byte 0x80
3 · recordsThe exact strings of LVOCAB/1, LADDR/1 (with addrTableRoot over map A’s rows), LPREP/1 (Tier S and Tier P with its salted root), LCORPUS/1 and LGROW/1 (chapter 3)
4 · exact weaveengram_core.chainQuaternion over the first 8 bytes of each leaf hash, and its segment sub-weaves over segCuts
5 · RFC 6962Leaf and node prefixes 0x00 and 0x01, the split at the largest power of two, RFC 9162’s proof algorithms; L9’s synthetic lists; what “detected” and a wrong proof mean
6 · packagesThe package, the verdicts {selfConsistent, authentic, failed}, keys made per run in WebCrypto, BioChain-AI’s own identity and key-vector functions, the registry snapshot pinned by SHA-256, the clean set and the tamper draws
7 · L11A shard’s time is the mean of repetitions 2 and 3; addrTableRoot is recomputed once per session and counted once; the literal reading, inside every verification, is measured and reported; the bootstrap of the median
8 · dry runsEvery seed +3000: Rng(4000 + i) shards, the verb and adjective gloss shards, tampers from Rng(5000 + …), verb shards for C0

Five labels to note

“Amendments 1–7”. Both result files, dry and decisive, say they ran “with PREREGISTRATION.md with Amendments 1-7”. The string was fixed in the runner (run_claims_phase3.cjs) and was not updated when Amendment 8 was added; Amendment 9 item 1 records this, and the runner now takes the label from PREREGISTRATION.md when it starts. The decisive run’s HEAD, 6da04be, holds Amendment 8, and the runner it ran is 8c51e08’s, with Amendment 8’s changes: its READING runner-1 cites Amendment 8 item 1, and its L11 rule and control cite item 2 and carry the step check.

Two READINGs that predate Amendment 8. In the same results, READING runner-11 says “the control compares the two medians”, and runner-13, which defines the step check, still says “the registered comparison of the two medians still decides the control”. The L11 rule, the control’s own description in the JSON and the .md all say what Amendment 8 item 2 says: the step check decides, and the comparison is reported. In this run both came out the registered way (the step check holds, and the skipped median is faster), so the decision does not depend on which text one reads. Amendment 9 item 2 records this, and the runner’s texts now say what its code does.

The decisive run’s uncommitted path. The results record that the system had one uncommitted path when the run started: reference/results/phase3-console.txt, untracked. That is the console log the run itself was writing; it was committed in 865791f.

The final dry run’s HEAD. Its result files record HEAD b822237 and six modified files, the six that 8c51e08 commits (lexicon_core.js, verify.py, the runner, the chain trace, tests/all.cjs, tests/chain-lexicon.cjs), with three earlier dry-run result files untracked. The run started at 03:56:57, 29 seconds before 8c51e08 was committed (03:57:26); 25b48b3’s message says it ran on the code at 8c51e08. The result files list the paths, not the contents (Amendment 9 item 3). Dry runs decide nothing.

A stale comment in the core. The comment above verifyPackage in lexicon_core.js gave the reading before Amendment 8: authentic is “attestation, inclusion and consistency all pass”. The code below it (line 2,538), changed in 8c51e08, computes Amendment 8 item 3’s verdicts, as verify.py’s docstring says: self-consistent when parity .. commitment, inclusion and consistency pass, authentic when the attestation passes. The decisive run used that code. The comment, and one in tests/chain-lexicon.cjs’s header, were corrected after the run without any change to code (Amendment 9).

03

What was built

Five pieces, each written twice, once in the browser core and once in the Python reference, and checked line for line against a trace before anything was decided. The Python reference is the authority for the exact parts; Owl Academy’s own JavaScript is the authority for what a biochain is.

The grower

Owl’s growBiochain is asynchronous (it hashes with WebCrypto) and lives in scripts/biomesh.js. growSync repeats its steps in order, synchronously, on Engram Mind’s Eye’s biochain_v1.js (Owl’s codec, verbatim) and the orbital core’s SHA-256, as spike S4’s grower did. The Python port copies the JavaScript’s quirks too.

StepWhat it doesJS (lexicon_core.js)Python (chain.py)
GrowThe whole record, field for field, in Owl’s key order; options for engrams and for the two control growersgrowSyncgrow
Chunks and codec720-byte chunks; the order-2 rank coder with Elias-gamma ranks and raw-byte escapesBC.encodeChunk, BC.decodeChunkencode_chunk, decode_chunk
PacketsThe form-9 crystal word, parity set last; Owl writes the crystal byte 0x80 rawBC.crystallizeBytescrystallize
Leaves and rootsha256Hex(i + "|" + sha256Hex(String.fromCharCode(...chunk))): each byte from 0x80 up is hashed as two bytes; the root by the shdccp/2 ruleleafHash, merkleShdccp2leaf_hash, merkle_shdccp2
Float weavesThe chiral and mirror products of the crystal quaternions, with V8’s Math.hypot algorithm and toFixed(12) exactly (Python’s own math.hypot differs on about 31% of calls)weavesOfweaves, v8_hypot, js_to_fixed
chainId"BC-" + the first 24 hex digits of SHA-256(merkleRoot + “|” + weaveChiral)growSyncchain_id
Engram layerEngram’s engramStream, token for token, each distinct token’s packet computed onceengramLayerengram.ttmpt.engram_stream
Control growers (L8)BioChain-AI’s kernel normalisation (0x80 written as 0x81, parity recomputed); leaves over binary byteskernelCrystallize, leafHashBinarykernel_crystallize, leaf_hash_binary
Synthetic shardsAmendment 7 item 2’s generatorsynthShardsynth_shard

The records, as exact strings

Each record is a pipe-joined UTF-8 string, - for an empty field; its hash is the lowercase hex SHA-256 of those bytes (Amendment 7 item 3). The namespace lives in these kinds, never in a Form nibble (D7). Two of them are global and were equal in both languages in the decisive run:

LVOCAB/1|df22705601de2e425cd090edc5df05619ce4a08df336f40bf92a1ed59f9ca1ff|4ceb92c48d9cbe92204931da3ab2ef1133f74bfb2bd53af26d482af7e69316fd|30bed6fbc1fec1f4382d212d7792de48d99f10713f728d28329f8d7506712229|wordpiece-greedy/1|lex0-bpe/1|bc86a44d55ee251c718eeb28ecd729396f82e4bca0d530097595cee9794e287f|-|[PAD]=0,[UNK]=1,[CLS]=2,[SEP]=3,[MASK]=4
  hash 55962675fc6953c82d2ddd1d239f6879faba8f9bedd8128b5fe53054ac1f3c56

LADDR/1|df22705601de2e425cd090edc5df05619ce4a08df336f40bf92a1ed59f9ca1ff|cbda5ea6eef7f36a97a43d4a75f85e07fccbb4f23657d27b4ccbc93e2646ab59|L3/1|30b17bc3992d5bab98e8955bc215c03c5706e5847b2ed4a7c7b22f39635349e1|3/4|11/13|D3
  hash 83f09be9c4de55b74aba7d0eea47fc29d9217fae06231ca8dd0fba239e760904
KindFieldsJSPython (records.py)
LVOCAB/1vocabSha256 (V0), normaliserSpecSha (SHA-256 of golden/nb_spec_v1.txt, pinned), unicodeTablesSha, wordpiece-greedy/1, lex0-bpe/1, trainSetSha (instance (a)’s digest), -, the five specials with their idslvocablvocab
LADDR/1vocabSha256, the WordNet archive’s SHA-256, L3/1, addrTableRoot, 3/4, 11/13, D3. addrTableRoot is the RFC 6962 root over map A’s 8,192 rows id|token|word|len|h3PointSha|h2PointSha, in id order: one row per V0 entry, with its word’s exact H³ and H² points hashedladdrOf, addrRows, addrTableRootladdr_v0, addr_rows, addr_table_root
LPREP/1One per shard, 15 fields: the kind LPREP/1, corpusId, shardIndex, chainId, merkleRoot, byteLen, rawSha256, spdx, sourceUrlSha, lvocabHash, idStreamSha256 (the V0 id stream of the whole shard as one instance), laddrHash, weave3Sha (the exact weave’s components in decimal, joined by commas), engramStreamSha (- with engrams off), tierlprep, lprepFieldslprep, lprep_fields
LPREP/1, Tier PchainId written -, tier P, merkleRoot kept, and a 16th field: saltedRoot = SHA-256(LPREP-SALT/1| + salt hex + | + merkleRoot + | + chainId)lprep({tier: 'P'}), saltedRootlprep(…, TIER_P), salted_root
LCORPUS/1corpusId, N, the RFC 6962 root over SHA-256(LPREP/1) in shard order, spdxSetSha (the SHA-256 of the distinct SPDX ids, sorted, joined by commas), then four fields written -: Amendment 7 leaves the evaluation-set, contamination and Croissant fields empty until Phase 6lcorpus, corpusTreelcorpus, corpus_log
LGROW/1corpusId, N_old, root_old, N_new, root_new, proofSha (SHA-256 of the consistency proof’s hashes, concatenated)lgrowlgrow

C0’s manifest, as the run wrote it: LCORPUS/1|wordnet30-c0|148|f567700daafc85f8163c6e290f8555472751335daf4728fa9a64d18ad23f19b3|13e130f4…|-|-|-|-, and its growth from 147 shards to 148, LGROW/1|wordnet30-c0|147|6725fc2a…|148|f567700d…|ccf1e2a5….

The exact weave and RFC 6962

PieceWhat it doesJSPython
Exact weaveThe first 16 hex digits of each leaf hash as a 64-bit value; engram_core.chainQuaternion writes each as a 28-letter word of the norm-5 tree and multiplies them out, in order, into one integer quaternion of norm 528KexactWeave, weaveValues, weave3Shachain.exact_weave, weave3_sha
Its checksThe norm, unfold back to the prefixes in order, and the ordered product of the 7 segment sub-weaves over segCutsweaveReport, segmentWeaveschain.exact_weave_checks, segment_weaves
RFC 6962 treeLeaf SHA-256(0x00 ‖ d), node SHA-256(0x01 ‖ left ‖ right), split at the largest power of two below n, no duplication; audit paths and consistency proofsRfcTree (mth, path, consistency)manifest.Log
Proof checksRFC 9162’s algorithms 2.1.3.2 and 2.1.4.2rfcVerifyInclusion, rfcVerifyConsistencyverify_inclusion, verify_consistency
L9’s controlsThe shdccp/2 Merkle rule; an XOR of the 64-bit prefixesmerkleShdccp2, xorSummarymerkle_shdccp2, xor_summary

ATTEST/1 and the key registry

BioChain-AI’s format, unchanged: the payload ATTEST/1|keyId|keyVector|contentHash|epochToken, with contentHash the SHA-256 of the LPREP/1 string and keyId K- plus 24 hex digits of SHA-256 over the public key’s x|y. The signature is ECDSA P-256 over SHA-256 of the payload, as WebCrypto writes it: IEEE P1363 r‖s, 128 hex digits. Python’s cryptography verifies DER, so the signature is converted first (spike S7). The registry snapshot lists keyId, public JWK, keyVector and status (active, revoked or retired) and is pinned by its SHA-256.

PieceJSPython (attest.py)
Identity and key vector (BioChain-AI’s computeIdentityId, deriveKeyVector, ported)identityIdOf, keyVectorOfidentity_id, key_vector
Keys, payload, signingnewKeyPair, attestPayload, attestSign (WebCrypto)attestation_payload, attest, sign_p1363
The signature’s encodingsp1363Of, derOf, highSTwinp1363_to_der, der_to_p1363 (r and s left-padded), high_s_twin
Registry snapshotregistrySnapshot, loadSnapshotsnapshot_text, load_snapshot
Verifying a block: the registry’s entry, its status, its key vector, the content hash, then the signatureverifyAttestationverify_attestation

The hardened verifier: ten checks, two verdicts

verifyPackage(session, package) in JS and verify.verify(package, session) in Python run the checks in the registered order (Amendment 8 item 4). The first seven stop at the first failure; the last three always run. failed names the first check that failed, or -; a package is accepted when it is -. Explainer 4 numbered the same work as eight steps (its checks).

#CheckWhat it requiresExplainer 4Verdict
1parityA shdccp/2 record whose stream parses strictly, frame by frame, with at least one frame; every packet’s parity holdsstep 1self-consistent
2canonicalThe 720-byte cut; every residual decodes, and re-encoding the chunk gives the stored residual byte for byte; the stream re-framed from its packets and residuals is the stored streamstep 2self-consistent
3crystalcrystallize(chunk) is the stored packet, for every framestep 3self-consistent
4leavesleafHashes and merkleRoot present, and equal to the recomputed onesstep 4self-consistent
5weavesweaveChiral, weaveMirror, segCuts, segments and chainId equal the recomputed onesstep 5self-consistent
6derivedThe engram layer (if present), origBytes, shippedBytes, value; the V0 id stream and the exact weave recomputed (norm, unfold, segments)step 6self-consistent
7commitmentThe LPREP/1 string equals the one rebuilt from the recomputed fields, the session’s LVOCAB and LADDR hashes and the string’s own corpusId, shardIndex, spdx and sourceUrlSha (Tier P: the salted root with the package’s salt)step 6self-consistent
8attestationThe ATTEST/1 block against SHA-256(LPREP/1) and the pinned registry: an unknown, revoked or retired key, a key-vector mismatch, another commitment or a bad signature fail. The signer is taken from the registry, never from unsigned fieldsstep 7authentic
9inclusionLCORPUS/1 parses, names the same corpus, and the audit path of SHA-256(LPREP/1) at shardIndex verifies against its rootstep 8self-consistent
10consistencyLGROW/1 grows the same corpus from N − 1 to N, ending at the LCORPUS root; its proofSha is the proof’s; the proof verifiesstep 8self-consistent

Self-consistent

Checks 1–7, 9 and 10 (Explainer 4’s steps 1–6 and 8): the record, its derived layers and its place in the manifest agree with one another. Anyone can check it, and anyone can produce it, by growing an altered text.

verdict.selfConsistent

Authentic

Check 8 (step 7): a registered, unrevoked key signed exactly this LPREP/1. The code as first built counted inclusion and consistency as authenticity; Amendment 8 item 3 records the change back to Explainer 4’s definition, made identically in both languages before the run.

verdict.authentic

Tier S and Tier P

Tier STier P
TextTravels in the stream, losslesslyStays with the holder; only commitments are public
LPREP/115 fields, tier SchainId -, tier P, saltedRoot appended
What a verifier rebuildsEverything, from the streamEverything, from a revealed stream and its salt (the salted root recomputed in the commitment check)
In this runEvery package of L10 except T6’s, and every package of L11; C0 is WordNet, redistributable with its notice26 Tier-P twins of C0 shards, salted with the registered test salts, all accepted; T6 checks them with the wrong salt

The checks before the run

Before any decisive run the JS had to reproduce the reference’s chain trace, traces/chain_v1.txt, written by traces_chain.py from seeds 8000 + i that no claim uses: the codec on eight cases, V8’s hypot and toFixed, the synthetic generator, every record field, the controls’ growers, the exact weave, the records, the Certificate Transparency reference roots and RFC 6962’s worked proofs, every inclusion, consistency and alteration case of small lists, the attestation with fixed test keys (RFC 6979 signatures, so the lines are the same on every run), and the verdict and per-check letters of every package and tamper. The parity runner, tests/parity-lexicon.cjs, passed 19,991 of 19,991 lines: Phase 2’s 18,667, the chain trace’s 1,323 and one control of the trace check (with Phase 4’s L6 trace it now passes 22,586: Explainer 12). Beside it: tests/chain-lexicon.cjs (30/30 at 8c51e08), tests/bridges-lexicon.cjs (Engram’s importer on growSync’s records, 40/40 at b822237), the Owl and BioChain-AI compatibility pin golden/biomesh_compat_v1.json, and the Python Phase 3 tests (62/62 at 8c51e08). These counts are from the commit messages.

04

Grow, sign and verify a shard

The chain section of lexicon_core.js, in the browser you are reading this in: grow a shard from your text, commit to it, sign the commitment with a key made here, wrap it in a one-shard corpus, verify it with the hardened verifier, then break it seven ways and see which check notices, and whether Owl’s own rule would have.

Lab · grow, commit, sign, verify, tamper
Loading the cores…

1 · The record growSync grew

FieldValue
not grown yet

2 · The session, and the shard’s LPREP/1

–
–
#FieldValueThe verifier gets it
not built yet

3 · The exact weave

–

4 · The signature and the one-shard corpus

–

5 · The hardened verifier on the clean package

–
#CheckResult~ms hereDetail
not verified yet

6 · Break it

or one at a time:
ClassWhat changed hereSelf-consistent /
authentic
Failing checkChecks 1–10Owl’s rule
(verifyBiochain)
In the decisive run
(50 each)
T1leafHashes and merkleRoot removed––––leaves 50; Owl accepted 50/50
T2frame 0’s crystal32, bit 0 (word bit 24), flipped, parity re-fixed––––crystal 50; Owl accepted 50/50
T3the LPREP/1’s lvocabHash, last hex digit changed––––commitment 50 (authentic 0/50); Owl not run
T4attested by the key the registry marks revoked––––attestation 50 (self-consistent 50/50); Owl not run
T7frames 0 and 1 swapped––––leaves 48, canonical 2 (the last two frames); Owl not run
T8chainId, last hex digit changed––––weaves 50; Owl accepted 50/50
T9one residual bit flipped so that the chunk decodes the same––––canonical 50; Owl accepted 50/50

The checks column has one letter per check in the registered order: P passed, F failed, – not run (the first seven stop at the first failure). “Owl’s rule” is EngramCore.verifyBiochain on the tampered record. Owl’s own verifyIntegrity is asynchronous and lives in Owl Academy’s scripts/biomesh.js, which no page here loads; verifyBiochain repeats its steps (frame parity, leaves when present, the root when present, the chiral weave, the engram layer) with a synchronous SHA-256, and Engram’s tests check its verdicts against Owl’s own, word for word, on the five records in bridges_v1.json. The decisive run ran Owl’s own function, from the Owl checkout, on T1, T2, T8 and T9 (L10’s control 1). T5 and T6 are not here: they need a second shard’s attestation and a Tier-P twin, which a one-shard corpus does not have.

How the lab handles LADDR/1

Everything in the shard’s LPREP/1 is computed here except one field. The addrTableRoot inside LADDR/1 is an RFC 6962 root over map A’s 8,192 rows, and building map A needs WordNet’s noun and verb forests, read from the pinned 10,775,600-byte archive in the cache, outside the repository. A page cannot load it (and this lab uses no fetch at all, so it works from file:// as well as over HTTP). So the lab’s session is built from a given LADDR/1: the string both languages computed in the decisive run (chapter 3). The page checks that its SHA-256 is the recorded laddrHash, 83f09be9…, and then uses it as a pinned value, as a holder would. The decisive run recomputed it from WordNet once per session (1,277.8 ms in L11’s session); the lab does not recompute it, so its laddrHash is taken on trust. LVOCAB/1 is built here from the pinned V0 and table and the two pins the core carries (the NB spec’s SHA-256 and instance (a)’s digest), and its hash is checked against the run’s.

Try it
  • Grow, sign and verify with the gloss lines: 2,222 bytes, four chunks. All ten checks pass; both verdicts are true; Owl’s rule accepts too.
  • T1, T2, T8, T9: the hardened verifier fails them at leaves, crystal, weaves and canonical; Owl’s rule accepts all four. These are the gaps L10’s control 1 measured, and the signature still verifies: authentic stays true, because the LPREP/1 string was not touched.
  • T3 breaks both verdicts: the commitment no longer matches, and the signature was made over the old string. T4 breaks only authenticity: the record and its commitment are fine, the key is revoked.
  • T7 on the gloss lines fails at leaves, and Owl’s rule rejects it too (“leaf 0 mismatch”). Cut the text to between 721 and 1,439 bytes and frame 1 is the short last frame: the swap then fails at canonical, as two of the run’s fifty T7 records did.
  • Paste a full shard (up to 60,000 bytes) to see the verifier’s time in your browser beside L11’s 155.4 ms in Node; one byte more and the grower refuses, as Owl’s does.
What this lab is, and is not

It runs the functions that decided L8–L11 in Node, in your browser, on your text. It touches no registered instance and decides nothing. Its key lives only in this page’s memory and is gone when you leave; its signature says only that this page signed. Its corpus id (lexicon-lab-v1), spdx (NOASSERTION) and sourceUrlSha (the SHA-256 of page:explainers/chains.html) are labels for the lab, not registered values. It uses the decisive run’s epoch token, EPOCH-OFFLINE-2026-11-06, so the page’s port of BioChain-AI’s identity and key-vector functions can be checked against the values the run recorded. WebCrypto needs a secure context (HTTPS, localhost or a local file); where it is missing, the lab signs with the core’s own deterministic ECDSA, skips the attestation check, and says so.

05

L8 · Language shards are Owl-valid biochains

Grow every shard with our JS grower and with the Python port, engrams off and on, and compare each record with the one Owl Academy’s own growBiochain grows from the same text. Not one field of one record differs. supported for the JS grower and for the Python port

RegisteredAs run
InstancesC0’s 148 shards (8,831,867 bytes, 12,378 chunks) and 20 synthetic shards from Rng(1000 + i) (22,605–59,903 bytes), each grown with engrams off and on: 336 records per grower
AuthoritiesOwl Academy’s scripts/biomesh.js at 7f45f35 for (a) and (b), and BioChain-AI’s src/biomesh/biomesh.js at c975161, both unchanged in Node by name-grab, in four worker threads; the Python reference for (d)
MetricThe fields that differ among the fifteen; both verifyIntegrity verdicts; importBiochain’s flag and text; Python/JS mismatches in (d)
DecisionAll-or-nothing, separately for the JS grower and the Python port; void if a control fails to show its weakness
PartCheckedResult
(a)Records differing from Owl’s in any field: growSync; the Python port; BioChain-AI’s own grower0, 0, 0 of 336
(b)Owl’s and BioChain-AI’s verifyIntegrity accept the record (engrams off; on)168/168; 168/168, each
(c)EngramCore.importBiochain accepts and recreates the text byte for byte (off; on)168/168; 168/168
(d)LVOCAB/1 and LADDR/1 equal in Python and JS (addrTableRoot 30b17bc3…, 8,192 rows; ~2.0 s in JS, ~1.6 s in Python)equal, equal
(d)Shards whose V0 id stream (SHA-256 and count) or LPREP/1 (engrams off or on) differs between Python and JS0 of 168

Because growSync’s, the Python port’s, Owl’s and BioChain-AI’s records were equal, each shard and mode had one distinct record to verify and import (READING runner-7). Owl’s authority in (a) and (b) is its own code: its functions are taken from the file by name and run as written, with only its sha256Hex (WebCrypto in the original) stood in for by Node’s SHA-256 over UTF-8, as spikes S4 and S7 ran it.

The controls

ControlMustMeasured
1 · The Python grower with BioChain-AI’s shdccp_kernel.pack normalisation (the crystal byte 0x80 written as 0x81), engrams offdiffer from Owl’s record on at least one synthetic shard20 of 20, in the stream only
(chainId and merkleRoot equal)
2 · A grower that hashes leaves over binary bytes, engrams offdiffer on every shard and be rejected by Owl’s verifyIntegritydiffers 168/168
rejected 168/168 (“leaf 0 mismatch”)
3 · Bit 0 of each shard’s first ASCII byte flipped, regrownchange that chunk’s leaf and the root168 of 168

The control growers were run in both languages: the JS kernel grower equalled the Python one on all 20 synthetic shards, and the Python binary-leaf grower equalled the JS one on all 168.

Reported, not decisive

  • The 0x80 byte, where Owl and BioChain-AI’s Python kernel disagree: 189 of C0’s 12,378 chunks (1.527%) have a crystal holding it, and 32 of the synthetic shards’ 1,175 (2.723%). Each synthetic shard needed 1–5 draws to get one (1, 1, 1, 2, 2, 2, 5, 4, 3, 2, 2, 1, 1, 2, 1, 1, 1, 1, 2, 1), and each has 29.522–30.682% two-byte characters, above the registered 25%.
  • Value (original bytes over shipped bytes): median 1.095 with engrams off, 0.466 with engrams on. The engram layer is larger than the gloss text it describes, as Explainer 4 found from spike S4.
  • Times (median per shard, ~): growSync 56 ms off and 119.1 ms on; the Python port 54.8 and 278.2 ms; Owl’s grower 70.5 ms and 9,319 ms; BioChain-AI’s 69.6 and 9,291.4 ms. Owl’s and BioChain-AI’s ran in four worker threads beside the Python half, so they were contended; growSync and Python ran alone. growSync’s engrams-on time splits into encode 32.7, crystal 5.9, hash 4.4, weave 10.9 and engram 63.6 ms. With engrams on, Owl’s grower took a median 9,319 ms against 70.5 ms off, the difference being its own engram layer; the worker threads that ran Owl’s and BioChain-AI’s code (1,848 jobs) took 1,837.6 s of the run’s 3,044.2.

The prediction was “supported for JS and for Python”, after spike S4 found its grower equal to Owl’s on 126/126 records, the 0x80 case in 1.41% of gloss chunks, and BioChain-AI’s normalised packets changing the stream but never chainId or merkleRoot. It held. The 0x80 share was 1.527% on C0 (S4: 1.41% of verb and adjective gloss chunks; analytic 1.55%), and control 1 again changed the stream field only.

06

L9 · The corpus manifest, its growth, and the exact weave

An RFC 6962 tree over the shards’ LPREP/1 hashes, with proofs of inclusion and of append-only growth, and an exact integer summary of each shard’s order. No root, proof or verdict differs between the languages, nothing altered goes undetected, and every weave is exact. supported

(a) The manifest and the synthetic lists

ListKRoot (JS = Python)Inclusion
proofs (max,
mean hashes)
Wrong leaf /
position
accepted
Consistency
proofs
(failed)
Alterations
(undetected)
JS/Python
mismatches
C0 manifest
engrams off
148f567700daafc85f8…148
(8, 7.68)
0 / 0147, every m
(0)
739 (0)0
Rng(1000)12cf8247ae9bac207…1
(0, 0)
0 / 0none for m < 1
(0)
4 (0)0
Rng(1001)2fe053b6cc39f8102…2
(1, 1)
0 / 01, every m
(0)
9 (0)0
Rng(1002)3b8cad7eb705b5538…3
(2, 1.67)
0 / 02, every m
(0)
14 (0)0
Rng(1003)7dae8490fb9c474be…7
(3, 2.86)
0 / 06, every m
(0)
34 (0)0
Rng(1004)84982fdccbe433cc94…84
(7, 6.67)
0 / 083, every m
(0)
419 (0)0
Rng(1005)200945a4fc792cd011b…200
(8, 7.88)
0 / 0199, every m
(0)
999 (0)0
Rng(1006)1,0004ff617501dca0600…1,000
(10, 9.98)
0 / 02,000 sampled
(0)
2,000 sampled
(0)
0
Rng(1007)1,001a13b2b4fa6133589…1,001
(10, 9.99)
0 / 02,000 sampled
(0)
2,000 sampled
(0)
0

Every inclusion proof verified for its own leaf and position and was rejected for leaf (i + 1) mod K at position i and for its own leaf at position (i + 1) mod K. Every consistency proof verified, and each was also rejected with a wrong old root. On C0’s manifest the 739 alterations are all six registered kinds: 148 replacements, 148 deletions, 148 insertions, 147 adjacent swaps, 147 truncations with the old size kept, and the one duplicate-last; at K = 1,000 and 1,001, 2,000 alterations each were drawn from Rng(2000 + j) (READING runner-5). C0’s root took ~1.8 ms in JS and ~0.3 ms in Python.

An RFC 6962 inclusion proof in a tree of seven entries RFC 6962's seven-entry example. Leaves a to f hash entries d0 to d5; j hashes d6 and is promoted, not duplicated. g, h and i join the pairs, k joins g and h, l joins i and j, and the root joins k and l. The proof for one entry is the list of sibling hashes along its path; the verifier rebuilds the path from the entry and compares the root. rebuilt by the verifiersent in the proof
Choose an entry.
RFC 6962’s own seven-entry example, with its node names. Choose an entry: its proof is the sibling hashes along its path, bottom up, and the verifier rebuilds the path from the entry alone. With seven entries a proof holds two or three hashes; d6’s leaf j is promoted to the next level, never duplicated, which is what keeps [a, b, c] and [a, b, c, c] apart. In C0’s manifest of 148 shards a proof holds 7.68 hashes on average, at most 8; at 1,000 and 1,001 entries, at most 10.

(b) The exact weaves

On each of C0’s 148 shardsResult
Norm exactly 528K (52352 for the 147 shards of K = 84; 5840 for the last, K = 30)148/148
unfold returns the leaf prefixes, in order148/148
The ordered product of the 7 segment sub-weaves equals the weave148/148
The four components, and every segment sub-weave, equal in JS and Python148/148
Bits per component (K = 30; K = 84)971–976; 2,720–2,731
Median time per shard (~): JS; Python45.9 ms; 51.3 ms

The controls

ControlMustMeasured
1 · The shdccp/2 Merkle rule (pairwise SHA-256 over hex, odd node duplicated)give equal roots for L and L with its last element duplicated, at every odd K ≥ 3 among the synthetic Kcollides at K = 3, 7, 1,001
(JS and Python)
2 · An XOR of the leaf prefixesmiss at least one adjacent swap that the weave detectsmisses all it was given:
1, 2, 6, 83, 199 swaps at K = 2–200;
2 of 2 at K = 1,000 and 1,001

Control 2 checked every adjacent swap for K ≤ 200 and the first and last for K = 1,000 and 1,001 (READING runner-6). K = 1 has no swap. XOR is blind to order by construction; the weave detected every swap the XOR missed, in both languages.

The prediction, “supported”, held, with spike S4’s figures: inclusion proofs of at most 10 hashes at 1,000 leaves (10 here, at 1,000 and 1,001), the shdccp/2 rule colliding at every odd K ≥ 3, and components of about 2,730 bits at K = 84 (2,720–2,731 here).

07

L10 · The hardened, attested import

Fifty clean attested packages and fifty of each of nine tamper classes, verified in JavaScript with WebCrypto and in Python with cryptography. Every clean package is accepted, every tampered one rejected with its check named, and the two languages agree on every verdict. supported

Set up for the runValue
Identity and key vector (BioChain-AI’s own computeIdentityId and deriveKeyVector on the seed hyperbolic-lexicon/phase3 and uid lexicon; the core’s port and Python’s equal)0xAE3502AC6FFBA237
9BC2024804859196
Epoch tokenEPOCH-OFFLINE-2026-11-06
Keys, made in WebCrypto for this runK-c097cdc661697dce0beb1d92 active
K-7e0fcb2cbfd856240bed45bd revoked
Registry snapshot (public JWKs only; no private key is written anywhere)phase3-registry.json, 456 bytes
36cbc21d78185642…
The clean set: Rng(1000 + i).below(148) until 50 distinct shards50 shards, 55 draws
Tier-P twins (for T6), accepted with their own salts26/26

The nine classes

ClassWhat it changes (as run)Caught by
(JS = Python)
Self-consistent /
authentic, of 50
Owl’s verifyIntegrity
(control 1)
cleanNothing: 50 packages, attested by the active keyaccepted, 5050 / 50–
T1leafHashes and merkleRoot removedleaves 500 / 50accepts 50/50
T2One packet’s crystal32 changed (a drawn frame, a drawn bit), parity re-fixedcrystal 500 / 50accepts 50/50
T3The LPREP/1’s lvocabHash, last hex digit changedcommitment 500 / 0not run: the record is unchanged
T4Attested by the key the registry marks revokedattestation 5050 / 0not run: the record is unchanged
T5The attestation of the next clean package (a valid signature over another shard’s LPREP/1)attestation 5050 / 0not run: the record is unchanged
T6The shard’s Tier-P package, checked with the next shard’s test saltcommitment 500 / 50not run: the record is unchanged
T7Two adjacent frames swapped (a drawn pair)leaves 48
canonical 2
0 / 50not run; spike S4: rejects, “leaf 0 mismatch”
T8chainId, last hex digit changedweaves 500 / 50accepts 50/50
T9One residual bit flipped so that the chunk still decodes to the same bytescanonical 500 / 50accepts 50/50
Over all 500 packagesJSPython
False accepts (a tampered package accepted)00
False rejects (a clean package rejected)00
Verdicts that differ between the languages (self-consistent, authentic, failing check)0 of 500
Median verification time per package, tampered ones included (~)135.4 ms131.5 ms
  • T7’s two canonical failures are the two draws that swapped an 84-chunk shard’s last two frames, 82 and 83 (shards c0 096 and c0 007). The last frame is short, so after the swap a short frame stands first and the 720-byte cut fails before the leaves are compared; Amendment 8 item 4 had recorded that this can happen. The other 48 failed at leaves.
  • T9’s flips: each draw’s first chosen frame had silent flips (103–232 of them); 49 of the 50 flips used lie inside a raw-byte escape’s rank code and one in the residual’s padding. Decoding cannot see them; only re-encoding can.
  • The verdicts separate what was changed: the record (T1, T2, T7, T8, T9: not self-consistent, still authentic, since the signed LPREP/1 is intact), the commitment (T3: neither; T6: not self-consistent, its signature intact), or the signature alone (T4, T5: self-consistent, not authentic).

The controls

ControlMustMeasured
1 · Owl’s verifyIntegrity, run from the Owl checkout, on T1, T2, T8 and T9accept at least one record of each, or that class’s gap claim is withdrawn and the class voidT1 50/50, T2 50/50
T8 50/50, T9 50/50
2 · Python without the P1363-to-DER conversion (the raw 64 bytes handed to cryptography as DER)reject every valid signature made in the runaccepts 0 of 126
(126 verify with it)

No class is void. The prediction was “supported”, from spike S4 (Owl accepts T1, T2, T8 and silent residual flips; rejects T7) and spike S7 (0 of 200 WebCrypto signatures verify in Python raw). It held in every class.

08

L11 · Verification is cheap enough for corpora

A holder verifies a full C0 shard, every hardened check included, in a median of 155.4 ms in Node, single-threaded: the interval’s upper end, 156.0 ms, is under the 250 ms bar. The packages timed are the ones grown with engrams off, as Amendment 8 fixed after the dry runs. supported

RegisteredAs run
InstancesEvery C0 shard of at least 59,000 bytes: 147 packages, grown with engrams off (Amendment 8 item 1)
TimingA fresh Node process with nothing else running; three passes over the shards, each shard’s full and attestation-skipped verifications back to back in alternating order; process.hrtime.bigint; a shard’s time is the mean of repetitions 2 and 3; the package passed as a parsed object (READING runner-11)
SessionLVOCAB/1, LADDR/1 recomputed from WordNet and the registry loaded once: 1,303.1 ms (the address table 1,277.8 ms), counted once in the corpus estimate (Amendment 7 item 7)
DecisionSupported if the interval’s upper end is ≤ 250 ms; refuted if its lower end exceeds 500 ms; inconclusive otherwise; void unless the step check holds
147 shards, engrams offMedian95% interval
Full hardened verification (decides)155.387 ms[154.197, 155.966]
Fastest and slowest shard140.5 ms; 246.9 ms
A 1,000-shard corpus: the session once, then 1,000 medians~156.7 s

The interval is the 95% percentile bootstrap of the median, 10,000 resamples of the 147 shard times with numpy’s default_rng(7). The claim’s gloss, “a 1,000-shard corpus therefore verifies in under about 5 minutes”, comes out at about 2.6 minutes on this container.

Where the time goes

L11: the median time of each hardened check, Node and Python Median milliseconds per check over the 147 full C0 shards. In Node the canonical check (decode and re-encode every chunk) takes 78.9 ms and the derived layers 46.4 ms; every other check takes under 14 ms, the attestation 0.71 ms. In Python the derived layers take 100.8 ms and the canonical check 72.9 ms. Node (lexicon_core.js)Python (verify.py) 0 25 50 75 100 125 parity: Node 1.066 ms, Python 0.368 ms (medians over 147 shards)1 parity1.07 / 0.368 canonical: Node 78.86 ms, Python 72.881 ms (medians over 147 shards)2 canonical78.9 / 72.9 crystal: Node 7.24 ms, Python 9.027 ms (medians over 147 shards)3 crystal7.24 / 9.03 leaves: Node 4.615 ms, Python 0.43 ms (medians over 147 shards)4 leaves4.62 / 0.430 weaves: Node 13.308 ms, Python 9.201 ms (medians over 147 shards)5 weaves13.3 / 9.20 derived: Node 46.364 ms, Python 100.753 ms (medians over 147 shards)6 derived46.4 / 100.8 commitment: Node 1.821 ms, Python 0.145 ms (medians over 147 shards)7 commitment1.82 / 0.145 attestation: Node 0.714 ms, Python 0.246 ms (medians over 147 shards)8 attestation0.714 / 0.246 inclusion: Node 0.185 ms, Python 0.04 ms (medians over 147 shards)9 inclusion0.185 / 0.040 consistency: Node 0.11 ms, Python 0.025 ms (medians over 147 shards)10 consistency0.110 / 0.025 median milliseconds per shard (Node / Python)
The median of each check over the 147 shards, Node (the decisive engine) and Python (reported). The canonical check, which decodes and re-encodes every chunk, is about half of Node’s time; the derived layers (the V0 id stream and the exact weave) most of the rest. The attestation, the step the control is about, is 0.71 ms. Hover a check for its values; the table below holds them.
The values behind the chart
#CheckNode, msPython, ms
1parity1.0660.368
2canonical78.86072.881
3crystal7.2409.027
4leaves4.6150.430
5weaves13.3089.201
6derived46.364100.753
7commitment1.8210.145
8attestation0.7140.246
9inclusion0.1850.040
10consistency0.1100.025

Each value is the median over shards of that check alone; the medians do not add up to the median of the totals (they sum to 154.3 ms in Node, against 155.4 ms).

What Amendment 8 changed, and why it says so

Disclosure: the engrams-off reading came after the dry runs

The registration does not say whether L10’s and L11’s packages are grown with engrams on or off. Amendment 8 item 1 fixed off, for three reasons it states: engram/1 was registered as a compatibility checksum, never an input (D4); the design published in Phase 0 has the engram layer “off by default for corpora” (Explainer 3); and L11’s prediction, about 50–150 ms, was built from spike S4’s codec-only timing, which has no engram layer. It also states what came first: the runner had read it the other way, as Owl’s growBiochain defaults to engrams on, and in those dry runs L11’s median on engrams-on packages was 243.5–265.5 ms, near the bar, against 157–182 ms with engrams off. The reading was fixed after seeing that. Those dry runs are not committed; the committed final dry run, already on 8c51e08’s engrams-off code, measured 156.2 ms off and 229.4 ms on.

So the decisive run timed both. On the same 147 shards’ engrams-on packages the median is 243.589 ms, interval [240.247, 246.673], reported and deciding nothing. Its upper end is also under 250 ms, by 3.3 ms; in the dry runs before the amendment it was not always.

Item 2: the control that could not show what it was for

The registered control reads: “a run with the attestation step skipped must be faster; otherwise the step is not being timed and the test is void.” The runner compared the two medians. Amendment 8 reports that in the dry runs the step cost 0.7–0.8 ms against a per-verification spread of 10–28 ms: with correct code the comparison failed by chance, voiding L11, and with the skip deliberately ignored, so that both arms did the same work, it passed. The review confirmed this as its one finding. Amendment 8 item 2 replaced the control, as Engram Mind’s Eye’s Amendment 1 had replaced one that could not fail, with the verifier’s own record of its checks: every timed full verification must record the attestation check as run and passed inside the timed window with a time above 0, and every attestation-skipped one must record it as skipped with every other check passed; otherwise L11 is void. The median comparison is still reported.

The control in the decisive runResult
Step check (decides): full verifications that ran and passed the attestation inside the timed window; skipped verifications that recorded it skipped, every other check passing441/441; 441/441
holds
Median with the attestation skipped, and its interval (reported)153.527 ms
[151.911, 154.522]
Difference of the medians; shards where skipped is faster1.86 ms; 89 of 147
Paired, full minus skipped: median and 95% interval1.858 ms [0.354, 2.999]
The attestation step’s own median; one verification’s spread0.714 ms; ~5.466 ms

The 441 are 147 shards × 3 repetitions. In this run the median comparison came out the registered way (skipped faster), but its difference, 1.86 ms, is more than twice the step’s own 0.714 ms, so it says little either way, as item 2 anticipated. The committed final dry run shows the other outcome: there the step measured 2.995 ms (more than the 0.7–0.8 ms the amendment quotes) against a spread of about 20.95 ms, and the skipped median was slower (157.9 against 156.2 ms; paired −0.7 ms, [−4.6, 2.1]). Read as the median comparison, that dry run’s control would have voided L11; its step check held, 63/63 and 63/63.

Reported beside the decision

Variant, 147 shardsMedian95% interval
Engrams-on packages (Amendment 8 item 1)243.589 ms[240.247, 246.673]
LADDR/1 recomputed inside each verification (Amendment 7 item 7’s literal reading)1,350.198 ms[1,341.062, 1,363.753]
The session instead: LADDR/1 once, then every shard1,303.1 ms once, then 155.4 ms a shard
Python, the same packages (session address table 935.5 ms)195.863 ms[192.518, 199.086]

The literal reading is what a holder pays who rebuilds the 8,192-row address table for every shard; its cost is the table, not the shard. Amendment 7 fixed the session reading before any code, and the literal one is reported only. Python is reported; Node decides.

The prediction was “supported, with a median of about 50–150 ms”, from spike S4’s 41 ms codec part on verb shards, about 25 ms for the re-encode and 0.12–0.23 ms for ECDSA. The decision held; the range did not: 155.4 ms is above it. The canonical check alone takes 78.9 ms, and the derived layers 46.4 ms.

09

What this does not show

Four supported claims about one format, two codebases and one machine. They say a good deal about integrity, and little about anything else.

  • A signature proves who committed, not licence or correctness. An authentic verdict says that a key the registry lists as active signed this exact LPREP/1. It does not show that the spdx field is true, that the text is what its source says, that WordNet’s notice was kept, or that the content is right. A holder who grows an altered text and signs it with a valid key produces a package that is self-consistent and authentic; nothing here can tell.
  • The keys were throwaway. They were made in WebCrypto for the run, belong to no person or organisation, and only their public JWKs were written. Revocation was a status in a pinned snapshot, not a live lookup; key compromise, rotation and expiry were not tested.
  • The manifest is checked as the package presents it. The attestation covers the LPREP/1 string. The LCORPUS/1 and LGROW/1 strings in a package are not signed, so inclusion and consistency show that the shard sits in the tree the package names and that the tree grew from N − 1 shards; a holder must take the corpus root itself from a source it trusts. Each package proves growth from N − 1 only; L9 tested growth from every smaller size on the lists themselves.
  • Tier P was tested only as a format. The 26 Tier-P twins used the registered test salts, SHA-256 of lexicon-test-salt/1|j, which anyone can compute, so these commitments hide nothing; a real Tier-P shard needs a secret salt. The challenge audits Explainer 4 describes were not built. No restricted corpus was used: C0 is WordNet, Tier S. Tier P remains attestation plus audit, not public recomputation.
  • Nothing was published. No record went to Owl Academy’s or BioChain-AI’s Firestore; the registry was a file; their code ran unchanged from local checkouts at 7f45f35 and c975161, and nothing in either repository was changed. A later biomesh.js is a new test.
  • The nine tamper classes are the registered ones. Replays of old packages, rollback to an older corpus root, a forged registry snapshot (it is pinned by hash, not signed) and attacks on the code itself were not part of L10.
  • One machine, two engines. Node 22.23.4 and Python 3.13.18 (cryptography 50.0.1, OpenSSL 3.5.9) on this container, 4 CPUs. L10’s JS ran on Node’s WebCrypto, not a browser’s. L11 is a Node figure; another machine is a new measurement, and the lab’s browser times decide nothing.
  • L11 is decided on engrams-off packages. That reading was fixed after the dry runs, as Amendment 8 discloses. Engrams-on packages took 243.6 ms, reported. Owl’s own grower with its engram layer took a median 9.3 s a shard (~).
  • The exact weave is an order check, not a hash. Collision resistance still comes from the SHA-256 leaves under it. It travels beside shdccp/2 as weave3Sha in LPREP/1, proposed for shdccp/3 in place of the float weave; shdccp/2 itself is unchanged, float weave and all.
  • The lab runs the same functions on your text, with a given LADDR/1 and a key made in the page. It demonstrates the code and decides nothing.
10

Phase 4, planned and done

The plan at the end of Phase 3: learned embeddings, and the two claims still open. As before: the definitions by amendment before any code, a tuning amendment before any measured run, dry runs, then one decisive run. Phase 4 has done it and decided both (Explainer 12).

  1. L6 · Learned geometry at matched dimension. On the mammal closure (1,182 synsets, 6,542 edges), with the numpy float64 trainer: (a) learned Lorentz beats learned Euclidean on closure MAP at d = 2 and 3; (b) not at d = 50; (c) the training-free exact H³ tree has graph-edge MAP at least that of learned Lorentz at d = 3, predicted refuted by spike S3’s rule; (d) learned Lorentz at d = 3 beats the exact tree on closure MAP. Learning rates tuned on seeds 9000–9023 and frozen by a dated amendment; measured runs on seeds 0–4. The protocol is the project’s own, after Nickel & Kiela’s paper and script, as Amendment 6 attributes it.
  2. L4(c) · Snapped tables rank like floats. Every L6 table at d = 2 and 3, snapped to the 2−32 grid with fence.js and ranked exactly, has MAP within 0.001 of its float64 evaluation.
  3. LBENCH/1. The benchmark receipt, the one record kind of D7 not yet defined (Amendment 7 item 3), is defined when Phase 4 first uses it.
What Phase 4 found

Amendment 10 fixed the definitions before any code. The numpy float64 trainer, the exact evaluator of snapped tables, the decisions and the runner in reference/, and the exact ranking of snapped tables in lexicon_core.js (SnapArm, evaluateSnapped), were then built on synthetic data, reviewed and dry-run on the solid.n.01 closure set; tests/parity-lexicon.cjs, now with the L6 trace, passes 22,586 of 22,586 lines. Registered tuning ran 240 runs, Amendment 11 froze the rates, and one decisive run followed at 515a4a1, 3,051 s on 4 workers. L6 is supported in all four parts. (a): learned Lorentz beats learned Euclidean on closure MAP at d = 2 (0.88–0.91 against 0.16–0.17) and d = 3 (0.95–0.97 against 0.22–0.23), every interval above 0. (b): at d = 50 Euclidean is ahead, 0.99997 against 0.968, every interval below 0, which the rule counts as support. (c): the exact H³ tree’s graph-edge MAP, 0.690653, is above learned Lorentz d = 3’s 0.458–0.477, against the registered prediction of refuted. (d): learned Lorentz d = 3’s closure MAP, 0.950–0.971, is above the exact tree’s 0.305408. L4(c) is supported: snapping to 2−32 moved no MAP by more than 9.37×10−6 over 40 tables. Every control showed its weakness. LBENCH/1 was defined by Amendment 10 item 12, and the run wrote 367 receipts. Amendment 12, an erratum, corrects one sentence of Amendment 11.

Then Phase 5 brings the 2D and 3D pages, with a shard panel and an Engram session import (the roadmap).