Engram Mind’s Eye · Explainer 4 · Phase 2

The Reference and the Results

The Python reference rebuilds the engram system on exact arithmetic and decides the nine preregistered claims. Eight are supported. The ninth, whether the guard names the right corrupted distance, is inconclusive: right 96 times in 100 at the registered threshold, where the rule asked for 99.

The decisions Amendment 1 What they mean Claims ledger
Contents
  1. Where this sits
  2. What was built
  3. How it was checked
  4. Amendment 1
  5. The decisions
  6. Claim by claim
  7. What they mean
  8. Running it yourself
01

Where this sits

The reference takes the golden corpus, the preregistration and the shared cores, and feeds the browser core of Phase 3, which must reproduce its traces.

02

What was built

Twelve modules in reference/engram/, pure Python with numpy. Hyperbolic PolyStep’s exact modules are imported in place, without torch, and the orbital code is ported line by line from orbital_core.js.

ModuleHoldsLayer
ttmptengram/1 from Owl Academy’s page: Mulberry32, the letter grids, XOR crystallization, chiral key, J, both tokenizers, the engram stream, the 128-bit packet chainL0
orbitalTiles, the Merkle chain, the 2⁻²⁴ rationalization, frames, TQF, the gauge, the readout and the pump, from orbital_core.jsshared
addressThe 28-letter norm-5 address, the chain word and quaternion, unfolding by right divisionL2
memoryThe GF(2) triple-quad word, its Form 5 tiles and leaves, the Merkle chain, parity, locate, rebuild and repairL3
clockThe zero-point clock, zero-point words, registers with 72 blocks and 10 groups, the compensator, the engagement pump, the membrane turnL3, L5
couplerThe mirror law between the human and STRIX streamsL6
session, dialogueA dialogue run end to end; the store, the golden session and the synthetic dialoguesall
recall, watch, statsHamming recall and its variants; the fence screen, the exact address check and the guard; the bootstrapL7, E9
03

How it was checked

  • 41 unit tests, one file per module, each claim’s mechanics with its control.
  • Parity with the pages’ own code. test_orbital_parity.py runs orbital_core.js through Node and compares: 300 tiles, every wheel sector and mux index, Merkle chains, the 2⁻²⁴ rounding including its ties, toNum beyond 2¹⁰²⁴, 300 gauges, every landing node of 129 readouts, and the pump. All exact.
  • A dry run. run_claims.py --dry moves every seed up by 8000, shrinks every set and swaps the store and the golden session for stand-ins, so the runner was exercised without touching a registered instance. It found one crash (an empty token, which the registered store cannot hold) before the decisive run.
  • The runner was committed before it ran on the registered instances (commit 735b91c); the results are a separate commit (ab04cbe).
A disclosure

While the modules were being debugged, a few unit tests briefly used registered instances to check mechanics: synthetic dialogues 1000–1004, two E7 seeds and one E8 instance. Nothing was tuned on them, and the tests were moved to seeds of 9000 and above before the runner was written. E1’s unit test compares the same fields as the claim; for a port whose job is to match Owl Academy bit for bit, that comparison is how the port was made correct.

04

Amendment 1

Written in Phase 2, before any decisive run, and added to the end of PREREGISTRATION.md.

E1’s control was void. The registered control, a per-character seed multiplier of 37 in place of 31, cannot fail: the page seeds each letter on its own, so the multiplier only ever multiplies zero. A control that cannot fail proves nothing, and the common rules make such a test void. It was replaced by a change to Mulberry32’s increment, which changes 527 of 536 entries. The void control still runs, and still changes 0.

Definitions the preregistration left open were fixed and listed: slots filled first in, first out; the word at a zero point is the last three latched packets, oldest first; tile headers and leaves; the memory links; the membrane turn, 13/675 of a turn; how chains, windows, triples, variants and substitutions are drawn; how a misplaced memory’s recorded address is read.

05

The decisions

Rendered from reference/results/claims.json, the runner’s own record. Run on 2026-11-04 with Python 3.13 and numpy 2.5, in about three minutes.

#DecisionCasesFailuresControls
Loading results/claims.json… If it does not load, the commit message of ab04cbe and claims.md hold the same record.
06

Claim by claim

E1 · Compatibility

All 536 entries, both tokenizers on all three sentences, the engram stream and all 69 packets of the fresh session match Owl Academy. Rechecked against the Owl-Academy checkout at run time: still matching.

E2 · The chain quaternion

PacketsChainsBits per componentBits per packetSeconds per chain
12033128–132< 0.001
10203251300.003
72202,3411300.04
720523,4051302.5

A packet of 64 bits costs 130 bits in the chain quaternion, about 2×, at every length. Every chain unfolds exactly; a backtracking packet breaks recovery in 80 of 80 chains, and swapping two packets changes the quaternion in 65 of 65.

E3 · The triple-quad memory

5,639 windows (67 from the golden session, 4,572 from the dialogues, 1,000 random): every one of 1,443,584 single-bit alterations failed the parity, was located by the chain, rebuilt, and left the root as recorded. All 600 double alterations were detected and refused. Parity alone was fooled by all 150 same-position doubles, which is why the chain is part of the word.

E4 · The register

40 complete registers: packet, block and group products equal, the compensator exact, and every register closed in free-run. Both controls broke the equality in 40 of 40. Every register’s product also unfolds back to its packets, which the claim did not require. In the hold setting (reported only) each channel leaves 360/720 of a turn, 354 on the first channel of register 0.

E5 · The coupler

At all 1,554 zero points of 21 runs the binding was unchanged; with the coupler carrying, every output matched the run without it; the same-chirality control changed the binding in 21 of 21 runs.

E6 · The gauge and the lock

All 274,625 triples recovered exactly, with X = Y = 0 exactly when the three were equal; 9,746 readouts locked exactly when their triple was equal. 31 of 4,681 real footer triples locked, which is how often a new word sits at the same distance from all three cells of the window. The wrong gauge failed on 270,400 triples.

E7 · The fence on misplaced memories

DepthToo deep byDetection, k = 5Detection, k = 10False flags
210.85 [0.80, 0.90]0.85 [0.81, 0.88]0
221.00 [1.00, 1.00]1.00 [1.00, 1.00]0
310.83 [0.78, 0.88]0.83 [0.80, 0.86]3.21%
321.00 [1.00, 1.00]1.00 [1.00, 1.00]3.21%

The exact address check settled all 3,958 flags correctly. The false flags at depth 3 are 6 of 187 memories, the six straightest leaves the preregistration predicted.

E8 · The guard

Distance raised byBlamed on the right pairIntervalQuads above ln 2 (median)
0.50.42[0.28, 0.56]1
1.00.92[0.84, 0.98]26
1.50.96[0.90, 1.00]95
3.01.00[1.00, 1.00]204

No clean matrix broke the bound (the worst defect was 0.6923, below ln 2 = 0.6931). Blame was right every time at +3.0 but 48 of 50 at +1.5: above the 0.90 that would refute, below the 0.99 that would support. The dry run, on three unregistered instances, had already hinted at this; the rule was left as registered.

E9 · Hamming recall

Every parity-keeping variant of every stored word has its exact key (2,385 queries). For 2,210 one-letter substitutions, recall@1 was 0.0002 from the engram store and 0.0007 from the shuffled store: a difference of −0.0005, interval [−0.0017, 0.0004], inside ±0.05. Recall from a misspelling is at chance, as predicted, and chance here is about 1 in 477.

07

What they mean for the system

  • The exact bookkeeping holds. Addresses, chains, memory words, registers, the coupler’s binding and the gauge behave exactly as designed on every registered case, so Phases 3 to 5 can build on them.
  • The chain quaternion is a lossless store at about twice the size. It earns its place as the register’s exact record. It is not compression.
  • The memory word needs its chain. Parity alone misses a matched pair of flips every time; with the chain, nothing in 1.4 million alterations slipped through.
  • The fence screens and the exact check decides, as designed. Two levels too deep is always caught; one level too deep about 84% of the time; the depth-3 false flags are exactly the predicted straight leaves.
  • The guard proves, but naming is not settled. The ln 2 bound held exactly. Naming the corrupted pair is reliable at +3.0 and right 96 times in 100 at +1.5. The 3D page will show the guard’s top pair as a suspect, with these rates, not as a verdict. A stronger test would be a new claim on new seeds, not a re-run of this one.
  • Recall is what the key allows. Exact for anything with the same letter-count parities, chance for a single misspelling. Better recall needs engram/2.
08

Running it yourself

cd "Pages/Engram Minds Eye/reference"
pip install -r requirements.txt
python3 -m pytest -q tests
python3 run_claims.py --dry
python3 run_claims.py

Torch is not needed. Node is used by the parity tests and by E1’s check against an Owl-Academy checkout next to this one; neither decides anything.