Contents
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.
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/2biochain (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
growBiochaincan 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/1string, an ATTEST/1 block, theLCORPUS/1string with the shard’s inclusion proof, and anLGROW/1string with its consistency proof (Amendment 7 item 6). - Session
- What a verifying holder pins once: V0, the
LVOCAB/1string, theLADDR/1string (itsaddrTableRootrecomputed 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 fromRng(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
| Claim | What it says | Decision | Result | Controls that must show their weakness |
|---|---|---|---|---|
| L8 | Language 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 languages | supported 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 grower | BioChain-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 |
| L9 | The RFC 6962 corpus manifest, its append-only growth and the exact norm-5 weave | supported | The 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 exact | The shdccp/2 rule collides at K = 3, 7 and 1,001; an XOR summary misses every adjacent swap checked |
| L10 | The hardened importer accepts every clean attested record and rejects every registered tamper, naming the check, identically in JS and Python | supported | 50 clean and 450 tampered packages: 0 false accepts and 0 false rejects in each language, verdicts identical on all 500 | Owl’s verifyIntegrity accepts 50/50 of T1, T2, T8 and T9; Python without the P1363-to-DER conversion accepts 0 of 126 signatures |
| L11 | A full C0 shard verifies, every hardened check included, in a median of at most 250 ms in Node | supported 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 ms | The 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).
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.
- 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.
- 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.” - 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).
- 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).
- 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).
- 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.”
- 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.js7ffd768c…) and BioChain-AI (c975161,src/biomesh/biomesh.jsa2e2056f…) were unchanged. - 865791f · 05:07 · The results, as they came out:
claims-phase3.jsonand.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
| Item | What it fixes |
|---|---|
| 1 · code | The 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 shards | Shard 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 · records | The 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 weave | engram_core.chainQuaternion over the first 8 bytes of each leaf hash, and its segment sub-weaves over segCuts |
| 5 · RFC 6962 | Leaf 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 · packages | The 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 · L11 | A 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 runs | Every 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).
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.
| Step | What it does | JS (lexicon_core.js) | Python (chain.py) |
|---|---|---|---|
| Grow | The whole record, field for field, in Owl’s key order; options for engrams and for the two control growers | growSync | grow |
| Chunks and codec | 720-byte chunks; the order-2 rank coder with Elias-gamma ranks and raw-byte escapes | BC.encodeChunk, BC.decodeChunk | encode_chunk, decode_chunk |
| Packets | The form-9 crystal word, parity set last; Owl writes the crystal byte 0x80 raw | BC.crystallizeBytes | crystallize |
| Leaves and root | sha256Hex(i + "|" + sha256Hex(String.fromCharCode(...chunk))): each byte from 0x80 up is hashed as two bytes; the root by the shdccp/2 rule | leafHash, merkleShdccp2 | leaf_hash, merkle_shdccp2 |
| Float weaves | The 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) | weavesOf | weaves, v8_hypot, js_to_fixed |
| chainId | "BC-" + the first 24 hex digits of SHA-256(merkleRoot + “|” + weaveChiral) | growSync | chain_id |
| Engram layer | Engram’s engramStream, token for token, each distinct token’s packet computed once | engramLayer | engram.ttmpt.engram_stream |
| Control growers (L8) | BioChain-AI’s kernel normalisation (0x80 written as 0x81, parity recomputed); leaves over binary bytes | kernelCrystallize, leafHashBinary | kernel_crystallize, leaf_hash_binary |
| Synthetic shards | Amendment 7 item 2’s generator | synthShard | synth_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
| Kind | Fields | JS | Python (records.py) |
|---|---|---|---|
| LVOCAB/1 | vocabSha256 (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 ids | lvocab | lvocab |
| LADDR/1 | vocabSha256, 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 hashed | laddrOf, addrRows, addrTableRoot | laddr_v0, addr_rows, addr_table_root |
| LPREP/1 | One 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), tier | lprep, lprepFields | lprep, lprep_fields |
| LPREP/1, Tier P | chainId written -, tier P, merkleRoot kept, and a 16th field: saltedRoot = SHA-256(LPREP-SALT/1| + salt hex + | + merkleRoot + | + chainId) | lprep({tier: 'P'}), saltedRoot | lprep(…, TIER_P), salted_root |
| LCORPUS/1 | corpusId, 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 6 | lcorpus, corpusTree | lcorpus, corpus_log |
| LGROW/1 | corpusId, N_old, root_old, N_new, root_new, proofSha (SHA-256 of the consistency proof’s hashes, concatenated) | lgrow | lgrow |
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
| Piece | What it does | JS | Python |
|---|---|---|---|
| Exact weave | The 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 528K | exactWeave, weaveValues, weave3Sha | chain.exact_weave, weave3_sha |
| Its checks | The norm, unfold back to the prefixes in order, and the ordered product of the 7 segment sub-weaves over segCuts | weaveReport, segmentWeaves | chain.exact_weave_checks, segment_weaves |
| RFC 6962 tree | Leaf 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 proofs | RfcTree (mth, path, consistency) | manifest.Log |
| Proof checks | RFC 9162’s algorithms 2.1.3.2 and 2.1.4.2 | rfcVerifyInclusion, rfcVerifyConsistency | verify_inclusion, verify_consistency |
| L9’s controls | The shdccp/2 Merkle rule; an XOR of the 64-bit prefixes | merkleShdccp2, xorSummary | merkle_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.
| Piece | JS | Python (attest.py) |
|---|---|---|
Identity and key vector (BioChain-AI’s computeIdentityId, deriveKeyVector, ported) | identityIdOf, keyVectorOf | identity_id, key_vector |
| Keys, payload, signing | newKeyPair, attestPayload, attestSign (WebCrypto) | attestation_payload, attest, sign_p1363 |
| The signature’s encodings | p1363Of, derOf, highSTwin | p1363_to_der, der_to_p1363 (r and s left-padded), high_s_twin |
| Registry snapshot | registrySnapshot, loadSnapshot | snapshot_text, load_snapshot |
| Verifying a block: the registry’s entry, its status, its key vector, the content hash, then the signature | verifyAttestation | verify_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).
| # | Check | What it requires | Explainer 4 | Verdict |
|---|---|---|---|---|
| 1 | parity | A shdccp/2 record whose stream parses strictly, frame by frame, with at least one frame; every packet’s parity holds | step 1 | self-consistent |
| 2 | canonical | The 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 stream | step 2 | self-consistent |
| 3 | crystal | crystallize(chunk) is the stored packet, for every frame | step 3 | self-consistent |
| 4 | leaves | leafHashes and merkleRoot present, and equal to the recomputed ones | step 4 | self-consistent |
| 5 | weaves | weaveChiral, weaveMirror, segCuts, segments and chainId equal the recomputed ones | step 5 | self-consistent |
| 6 | derived | The engram layer (if present), origBytes, shippedBytes, value; the V0 id stream and the exact weave recomputed (norm, unfold, segments) | step 6 | self-consistent |
| 7 | commitment | The 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 6 | self-consistent |
| 8 | attestation | The 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 fields | step 7 | authentic |
| 9 | inclusion | LCORPUS/1 parses, names the same corpus, and the audit path of SHA-256(LPREP/1) at shardIndex verifies against its root | step 8 | self-consistent |
| 10 | consistency | LGROW/1 grows the same corpus from N − 1 to N, ending at the LCORPUS root; its proofSha is the proof’s; the proof verifies | step 8 | self-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.
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.
Tier S and Tier P
| Tier S | Tier P | |
|---|---|---|
| Text | Travels in the stream, losslessly | Stays with the holder; only commitments are public |
LPREP/1 | 15 fields, tier S | chainId -, tier P, saltedRoot appended |
| What a verifier rebuilds | Everything, from the stream | Everything, from a revealed stream and its salt (the salted root recomputed in the commitment check) |
| In this run | Every package of L10 except T6’s, and every package of L11; C0 is WordNet, redistributable with its notice | 26 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.
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.
1 · The record growSync grew
| Field | Value |
|---|---|
| not grown yet | |
2 · The session, and the shard’s LPREP/1
| # | Field | Value | The 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
| # | Check | Result | ~ms here | Detail |
|---|---|---|---|---|
| not verified yet | ||||
6 · Break it
| Class | What changed here | Self-consistent / authentic | Failing check | Checks 1–10 | Owl’s rule ( verifyBiochain) | In the decisive run (50 each) |
|---|---|---|---|---|---|---|
| T1 | leafHashes and merkleRoot removed | – | – | – | – | leaves 50; Owl accepted 50/50 |
| T2 | frame 0’s crystal32, bit 0 (word bit 24), flipped, parity re-fixed | – | – | – | – | crystal 50; Owl accepted 50/50 |
| T3 | the LPREP/1’s lvocabHash, last hex digit changed | – | – | – | – | commitment 50 (authentic 0/50); Owl not run |
| T4 | attested by the key the registry marks revoked | – | – | – | – | attestation 50 (self-consistent 50/50); Owl not run |
| T7 | frames 0 and 1 swapped | – | – | – | – | leaves 48, canonical 2 (the last two frames); Owl not run |
| T8 | chainId, last hex digit changed | – | – | – | – | weaves 50; Owl accepted 50/50 |
| T9 | one 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.
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.
- 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/1string 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.
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.
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
| Registered | As run |
|---|---|
| Instances | C0’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 |
| Authorities | Owl 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) |
| Metric | The fields that differ among the fifteen; both verifyIntegrity verdicts; importBiochain’s flag and text; Python/JS mismatches in (d) |
| Decision | All-or-nothing, separately for the JS grower and the Python port; void if a control fails to show its weakness |
| Part | Checked | Result |
|---|---|---|
| (a) | Records differing from Owl’s in any field: growSync; the Python port; BioChain-AI’s own grower | 0, 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 JS | 0 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
| Control | Must | Measured |
|---|---|---|
1 · The Python grower with BioChain-AI’s shdccp_kernel.pack normalisation (the crystal byte 0x80 written as 0x81), engrams off | differ from Owl’s record on at least one synthetic shard | 20 of 20, in the stream only (chainId and merkleRoot equal) |
| 2 · A grower that hashes leaves over binary bytes, engrams off | differ on every shard and be rejected by Owl’s verifyIntegrity | differs 168/168 rejected 168/168 (“leaf 0 mismatch”) |
| 3 · Bit 0 of each shard’s first ASCII byte flipped, regrown | change that chunk’s leaf and the root | 168 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.
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
| List | K | Root (JS = Python) | Inclusion proofs (max, mean hashes) | Wrong leaf / position accepted | Consistency proofs (failed) | Alterations (undetected) | JS/Python mismatches |
|---|---|---|---|---|---|---|---|
| C0 manifest engrams off | 148 | f567700daafc85f8… | 148 (8, 7.68) | 0 / 0 | 147, every m (0) | 739 (0) | 0 |
| Rng(1000) | 1 | 2cf8247ae9bac207… | 1 (0, 0) | 0 / 0 | none for m < 1 (0) | 4 (0) | 0 |
| Rng(1001) | 2 | fe053b6cc39f8102… | 2 (1, 1) | 0 / 0 | 1, every m (0) | 9 (0) | 0 |
| Rng(1002) | 3 | b8cad7eb705b5538… | 3 (2, 1.67) | 0 / 0 | 2, every m (0) | 14 (0) | 0 |
| Rng(1003) | 7 | dae8490fb9c474be… | 7 (3, 2.86) | 0 / 0 | 6, every m (0) | 34 (0) | 0 |
| Rng(1004) | 84 | 982fdccbe433cc94… | 84 (7, 6.67) | 0 / 0 | 83, every m (0) | 419 (0) | 0 |
| Rng(1005) | 200 | 945a4fc792cd011b… | 200 (8, 7.88) | 0 / 0 | 199, every m (0) | 999 (0) | 0 |
| Rng(1006) | 1,000 | 4ff617501dca0600… | 1,000 (10, 9.98) | 0 / 0 | 2,000 sampled (0) | 2,000 sampled (0) | 0 |
| Rng(1007) | 1,001 | a13b2b4fa6133589… | 1,001 (10, 9.99) | 0 / 0 | 2,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.
(b) The exact weaves
| On each of C0’s 148 shards | Result |
|---|---|
| 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 order | 148/148 |
| The ordered product of the 7 segment sub-weaves equals the weave | 148/148 |
| The four components, and every segment sub-weave, equal in JS and Python | 148/148 |
| Bits per component (K = 30; K = 84) | 971–976; 2,720–2,731 |
| Median time per shard (~): JS; Python | 45.9 ms; 51.3 ms |
The controls
| Control | Must | Measured |
|---|---|---|
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 K | collides at K = 3, 7, 1,001 (JS and Python) |
| 2 · An XOR of the leaf prefixes | miss at least one adjacent swap that the weave detects | misses 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).
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 run | Value |
|---|---|
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 token | EPOCH-OFFLINE-2026-11-06 |
| Keys, made in WebCrypto for this run | K-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 shards | 50 shards, 55 draws |
| Tier-P twins (for T6), accepted with their own salts | 26/26 |
The nine classes
| Class | What it changes (as run) | Caught by (JS = Python) | Self-consistent / authentic, of 50 | Owl’s verifyIntegrity(control 1) |
|---|---|---|---|---|
| clean | Nothing: 50 packages, attested by the active key | accepted, 50 | 50 / 50 | – |
| T1 | leafHashes and merkleRoot removed | leaves 50 | 0 / 50 | accepts 50/50 |
| T2 | One packet’s crystal32 changed (a drawn frame, a drawn bit), parity re-fixed | crystal 50 | 0 / 50 | accepts 50/50 |
| T3 | The LPREP/1’s lvocabHash, last hex digit changed | commitment 50 | 0 / 0 | not run: the record is unchanged |
| T4 | Attested by the key the registry marks revoked | attestation 50 | 50 / 0 | not run: the record is unchanged |
| T5 | The attestation of the next clean package (a valid signature over another shard’s LPREP/1) | attestation 50 | 50 / 0 | not run: the record is unchanged |
| T6 | The shard’s Tier-P package, checked with the next shard’s test salt | commitment 50 | 0 / 50 | not run: the record is unchanged |
| T7 | Two adjacent frames swapped (a drawn pair) | leaves 48 canonical 2 | 0 / 50 | not run; spike S4: rejects, “leaf 0 mismatch” |
| T8 | chainId, last hex digit changed | weaves 50 | 0 / 50 | accepts 50/50 |
| T9 | One residual bit flipped so that the chunk still decodes to the same bytes | canonical 50 | 0 / 50 | accepts 50/50 |
| Over all 500 packages | JS | Python |
|---|---|---|
| False accepts (a tampered package accepted) | 0 | 0 |
| False rejects (a clean package rejected) | 0 | 0 |
| Verdicts that differ between the languages (self-consistent, authentic, failing check) | 0 of 500 | |
| Median verification time per package, tampered ones included (~) | 135.4 ms | 131.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/1is intact), the commitment (T3: neither; T6: not self-consistent, its signature intact), or the signature alone (T4, T5: self-consistent, not authentic).
The controls
| Control | Must | Measured |
|---|---|---|
1 · Owl’s verifyIntegrity, run from the Owl checkout, on T1, T2, T8 and T9 | accept at least one record of each, or that class’s gap claim is withdrawn and the class void | T1 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 run | accepts 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.
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
| Registered | As run |
|---|---|
| Instances | Every C0 shard of at least 59,000 bytes: 147 packages, grown with engrams off (Amendment 8 item 1) |
| Timing | A 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) |
| Session | LVOCAB/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) |
| Decision | Supported 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 off | Median | 95% interval |
|---|---|---|
| Full hardened verification (decides) | 155.387 ms | [154.197, 155.966] |
| Fastest and slowest shard | 140.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
The values behind the chart
| # | Check | Node, ms | Python, ms |
|---|---|---|---|
| 1 | parity | 1.066 | 0.368 |
| 2 | canonical | 78.860 | 72.881 |
| 3 | crystal | 7.240 | 9.027 |
| 4 | leaves | 4.615 | 0.430 |
| 5 | weaves | 13.308 | 9.201 |
| 6 | derived | 46.364 | 100.753 |
| 7 | commitment | 1.821 | 0.145 |
| 8 | attestation | 0.714 | 0.246 |
| 9 | inclusion | 0.185 | 0.040 |
| 10 | consistency | 0.110 | 0.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
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.
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 run | Result |
|---|---|
| Step check (decides): full verifications that ran and passed the attestation inside the timed window; skipped verifications that recorded it skipped, every other check passing | 441/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 faster | 1.86 ms; 89 of 147 |
| Paired, full minus skipped: median and 95% interval | 1.858 ms [0.354, 2.999] |
| The attestation step’s own median; one verification’s spread | 0.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 shards | Median | 95% 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 shard | 1,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.
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/1string. TheLCORPUS/1andLGROW/1strings 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.jsis 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 (
cryptography50.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/2as weave3Sha inLPREP/1, proposed forshdccp/3in place of the float weave;shdccp/2itself 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.
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).
- 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.
- L4(c) · Snapped tables rank like floats. Every L6 table at d = 2 and 3, snapped to the 2−32 grid with
fence.jsand ranked exactly, has MAP within 0.001 of its float64 evaluation. - 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.
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).