BioChain AI · Engram Mind’s Eye

Engram Mind’s Eye

Owl Academy’s engram memory and Mind’s Eye, the STRIX familiar and its 3D lattice, rebuilt as a standalone system on the exact machinery of this site: the one-engine and three-engine orbital calculators, the soliton convergence engine, Hyperbolic PolyStep in H² and H³, and the 0.7 Claude fence. Every claim is preregistered before the code that tests it exists.

Open the 2D page Open the 3D page Read the architecture The evidence System map Roadmap Claims ledger Decisions
Phases 0–8 done · reachable from the site · one command checks it all Claims decided: 9 supported · 2 inconclusive · 0 refuted orbital_core.js: 15 segments · pages byte-identical · 18/18 in Node The 2D page: talk with STRIX · v1 exports byte-identical to Owl Academy The 3D page: the memory in H³ · fence, guard, twin system Bridges: Owl Academy restores a session grown here, byte for byte engram_core.js: 849/849 parity lines · live in the browser Golden corpus: 536 entries · 69 chain packets
Contents
  1. What this is
  2. Five systems, one role each
  3. System map
  4. Explainer library
  5. Roadmap
  6. Claims ledger
  7. Decisions
  8. How the folder grows
  9. Glossary
00

What this is

In Owl Academy, STRIX is a familiar that remembers a conversation as engrams: each word becomes a 64-bit grid, the last three sit in a window, and every word is logged as a 128-bit packet. The Mind’s Eye draws that memory as a lattice. Its quaternion side, the S.P.I.R.E. layer, runs in floating point and is spread over three places, none of them exact.

This system keeps the engram key exactly as Owl Academy defines it and rebuilds everything above it on code that is already exact here. A word runs through the five tiers of the one-engine calculator. The window runs on the three-engine clock. The memory is a triple quad with a Merkle chain that finds and repairs an altered cell. The soliton gauge reads every word’s place in the window. Hyperbolic PolyStep gives every word an exact quaternion address and lays the memory out in H² and H³. The fence watches the layout.

What it will not do

Exact here means exact bookkeeping: addresses, chains, memory words, registers, frames and gauges. It does not make recall understand meaning. The engram/1 key records only whether each letter appears an odd or even number of times, so LISTEN and SILENT share a key, and no geometry placed on top of it adds meaning. The fence finds misplaced memories, not new ideas. Claim E9 states this in advance.

01

Five systems, one role each

Each existing system takes over one job, and none of them is changed to do it. Engine v10 is an uploaded export and stays exactly as it is.

SystemRole hereWhat it supplies
Geometric Harmonics Calculator
one engine · five tiers
The pipeline for one wordTiers T4 to T0 and their stage roles, the 30-node clock, the 64-bit Einstein tile as the wire format
Zero-Point Tri-Engine
three engines · the clock
The clock for the windowOnload at joint frames 18, 10 and 2, offload twelve frames later, pairing at the zero point, the 720-frame register with its pump
Tri-Engine Convergence and Soliton
soliton convergence
Memory and resonanceThe triple-quad word at 30 addresses, the Lemma 15 Merkle chain with locate and repair, the Proposition 7.14 gauge, the lock and the soliton crystal
Hyperbolic PolyStep
H² and H³
Addresses and geometryExact quaternion addresses in the norm-5 tree, tree layouts in H² and H³, frames, and the twin system with its coupler
The 0.7 Claude fence
H² and H³
The watch layerA screen for misplaced memories, settled by an exact address check, and the ln 2 guard that names a corrupted stored distance
Built on this system

Hyperbolic Lexicon plans a staged hyperbolic BERT front end. It treats engram/1 as a compatibility checksum, not a token id: letter-count parity cannot tell anagrams apart. It grows its language data as shdccp/2 shards with this system’s pinned codec (biochain_v1.js), so every shard imports here through importBiochain. Its exact address, a word of the same norm-5 tree, is the candidate for an engram/2 key, to be registered here by amendment once the Lexicon’s address claims are decided.

02

System map

Every part of the system and what feeds what: Owl Academy’s sources and this site’s systems on the left, the pages, data and code on the right. Hover a box to light up its connections; click it for what it is and where it is explained.

Reading the map

Every box is solid: the sources, the five systems, the mathematics they rest on, and everything built in Phases 0 to 8. The eight layers are built in the Python reference and the browser core and shown on the pages; click one to see where. A new module joins as a dashed box and turns solid when its phase ships.

03

Explainer library

One full explainer per topic. Each opens with its place on the map.

1 · The architecture

The five systems and the eight layers, one word followed from its keystroke to its register, why position and frame are kept apart, and a live lab that crystallizes a word, triangulates it, gives it its quaternion address and rebuilds a lost window cell.

Phase 0

2 · The evidence and the claims

The four feasibility spikes with their captured outputs, the golden corpus and how it was pinned, the nine preregistered claims with their decision rules, and what each spike can and cannot decide.

Phase 0

3 · The shared cores

The orbital pages’ exact code moved into one module, orbital_core.js, that the build writes back byte for byte; how that was proved; the module running live in the page; and PolyStep’s exact modules importing without torch.

Phase 1

4 · The reference and the results

The Python reference, how it was checked against the pages’ own code, Amendment 1, and the decisions: E1–E7 and E9 supported, E8 inconclusive, every number from the runner’s record.

Phase 2

5 · The browser core

engram_core.js: the whole engram system in one module on the shared cores, what it loads and what it adds, how it reproduces the golden corpus and the reference’s traces (849/849 lines), the parity check running live, and a session on your own words.

Phase 3

6 · The 2D page manual

STRIX on the clock: the dialogue and its reply rule, the three-engine clock, one word on the five tiers, resonance, memory you can damage and repair, the register, the memory tree in H², the exports and how the page is tested.

Phase 4

7 · The 3D page manual

The memory tree in H³, a frame per word from its exact quaternion, the twin system and its binding, the crystal at the core, the fence with its exact check, the guard, the breath, and LATTICE-SEED/1 import.

Phase 5

8 · The bridges

Owl Academy in and out: a session grown here that Owl Academy restores and continues exactly, and its sessions, exports, biochains, engram streams, lattice seeds and environments coming in, each verified against its own code.

Phase 6

9 · The follow-ups

E10 and E11, registered before any code for them: a sharper guard, inconclusive, which shows E8’s shortfall to be a shortage of witnesses; and the way back to Owl Academy, supported on 50 drawn conversations.

Phase 7

10 · Integration and upkeep

How the system is reached from the rest of the site, the five shared cores it loads unchanged and what it uses from each, one command that checks the system and everything under it, and what to do when something upstream changes.

Phase 8
04

Roadmap

Nine phases. Each ends with its code, its explainer, its node on the map moved from dashed to solid, a row in the claims ledger for anything it claims, and its tests passing.

0 · Scaffolddone 1 · Shared coresdone 2 · Referencedone 3 · Browser coredone 4 · The 2D pagedone 5 · The 3D pagedone 6 · Bridgesdone 7 · Follow-upsdone 8 · Integratedone
PhaseDeliversStatus
0 · ScaffoldThis hub with its system map, claims ledger and decisions; explainers 1 and 2; PREREGISTRATION.md with E1–E9; the golden corpus pinned from Owl Academy; the reference skeleton; the site bardone
1 · Shared coresscripts/geometric-build/orbital_core.js: 15 segments holding the exact core, tiers, tiles, Merkle chain, tier frames, TQF, gauge, readout, memory repair and pump, written back into the four orbital pages by build.py, which stay byte-identical; its Node test (18/18) and the browser tests passing; a lazy hpstep/__init__.py, with PolyStep’s suite at 137/137 before and after and its exact modules importing without torch. Explainer 3done
2 · Python referencereference/engram/: twelve modules, 41 tests with exact parity against orbital_core.js, traces for the browser core, Amendment 1, and the runner, committed before it ran. Decisions: E1–E7 and E9 supported, E8 inconclusive. Explainer 4done
3 · Browser coreengram_core.js: the engram layer on the shared cores and PolyStep’s browser modules (fence included). It reproduces the golden corpus and the reference’s traces line for line, 829/829 (849/849 since Phase 7), and passes the Python tests’ 27 behaviour checks; tests/parity-engram.cjs in Node and a live check in the page. Explainer 5done
4 · The 2D pagemind-eye.html: STRIX on the three-engine clock (Owl Academy’s reply rule and library, pinned by make_owl_v1.cjs), each word on the five tiers, memory you can damage and repair, the gauge, lock and crystal, registers that telescope, unfold and close, the memory tree in H², v1 exports byte-identical to Owl Academy’s (9/9) and an exact v2. Its engine Live equals the reference Session turn by turn; tests/page-engine.cjs 26/26. Explainer 6done
5 · The 3D pagemind-eye-3d.html: the memory tree in H³, a frame per word from its exact quaternion, you and STRIX as the twin system with the binding as a third chain, the soliton crystal at the core, the fence on every closing register with each flag settled exactly, the guard, the register’s breath, and LATTICE-SEED/1 import pinned from Owl Academy’s code; tests/page3d-engine.cjs 19/19. Explainer 7done
6 · BridgesOut: a session exported as Owl Academy’s Engram Mind Eye saves it, which that page restores and continues exactly. In: its saved sessions, v1 chains and crystals, biochains (text recreated by its own decoder), engram streams, and ENVIRONMENT/1 on the 3D page, each verified by recomputing it. biochain_v1.js and bridges_v1.json pinned from Owl Academy’s code by make_bridges_v1.cjs; tests/bridges.cjs 34/34. Explainer 8done
7 · Follow-upsAmendment 2 registered E10 (a sharper guard) and E11 (the way back to Owl Academy) before any code for them; runners committed and run dry first; decided on fresh seeds. E10 inconclusive, its exact parts supported, showing E8’s shortfall to be a shortage of witnesses; E11 supported, 50/50. The matching guard is ported with 20 parity lines and shown on the 3D page. Explainer 9done
8 · IntegrationA card in the site catalog; the hub in the Hyperbolic Oracles and Geometric Calculator menus; a note and a map node on the Hyperbolic Oracles hub, and the names Engram uses recorded in its README; tests/links.cjs (every link and way in, with controls) and tests/all.cjs (every Node check of the system and the cores it loads, 15/15). Explainer 10done
05

Claims ledger

Every claim the system makes, its status and where it was settled. E1–E9 were preregistered in PREREGISTRATION.md (with Amendment 1) and decided on 2026-11-04 by the Phase 2 reference, whose runner was committed before it ran. E10 and E11 were registered in Amendment 2 before any code for them, and decided in Phase 7 the same way (Explainer 9). Tags: SUPPORTED, REFUTED, INCONCLUSIVE. Every number is in results/claims.json, followups.json and e11.json, and in Explainers 4 and 9.

#ClaimStatus nowSettled in
E1engram/1 is bit-identical to Owl Academy on the golden corpusSUPPORTEDAll 613 cases match; the amended control differs on 527 entries (the registered one was void); still matching the Owl-Academy checkout
E2The chain quaternion recovers every packet exactly and in order, for any chain lengthSUPPORTED85 chains up to 720 packets unfold exactly, 130 bits per packet; controls 80/80 and 65/65
E3The triple-quad memory locates and repairs any single altered cell, and its chain detects any alteration of two cellsSUPPORTED1,443,584 single alterations repaired; 600 doubles detected and refused; parity alone fooled 150/150
E4Every register telescopes exactly through 720 → 72 → 10, and in the free-run + membrane setting every register closesSUPPORTED40 complete registers telescope and close; both controls 40/40; every register product unfolds
E5The coupler’s binding B = q₂q₁ is unchanged at every zero point (K1), and carry is bit-identical to no coupler (K2)SUPPORTED1,554 zero points; carry bit-identical to no coupler; the control changed B in 21/21 runs
E6The gauge recovers a packet’s three distances exactly, and the landing triangle locks exactly when they are equalSUPPORTEDAll 274,625 gauge triples; lock exactly when equal on 9,746 readouts
E7The fence flags memories placed two levels too deep, and the exact address check settles every flag correctlySUPPORTEDAll 3,958 flags settled exactly; detection 1.0 two levels deep in every cell; depth-3 false flags 3.21%, as predicted
E8The ln 2 guard blames a single corrupted stored distance on its own pairINCONCLUSIVEThe clean bound exact (worst 0.6923 < ln 2); naming right 1.00 at +3.0 but 0.96 [0.90, 1.00] at +1.5, short of 0.99
E9Hamming recall is exact for variants that keep every letter count’s parity, and at chance for one-letter substitutionsSUPPORTEDVariants exact; misspelling recall 0.0002 against 0.0007 shuffled, difference inside ±0.05
E10A sharper guard: every quadruple above ln 2 holds the corrupted pair in its largest matching, and the matching guard names it whenever two or more do (Amendment 2)INCONCLUSIVEExact parts supported on 1,600 matrices (control 1,373/1,373); naming 0.965 [0.94, 0.99] at +1.5 in E8’s setting, exactly the share with two or more witnesses. E8’s shortfall is a shortage of witnesses, not of blame
E11The way back: a session exported here is what Owl Academy saves, and Owl Academy restores and continues it exactly (Amendment 2)SUPPORTED50/50 conversations, 8,090 packets, against Owl Academy’s own code; the control changed its continuation in 50/50

Phase 3 adds no claim. The browser core reproduces E1’s 613 cases and the reference’s traces line for line (849/849 since Phase 7, COMPUTED), so the pages compute what decided these claims. Explainer 5 runs the check in your browser. Phase 4 adds none either: the 2D page’s engine equals the reference turn by turn, and its replies and v1 exports equal Owl Academy’s (Explainer 6). Phase 5 adds none: the 3D page shows E5’s binding, E7’s fence and exact check and E8’s guard at work on the dialogue’s own memory (Explainer 7). Phase 6 adds none: its bridges are checked against Owl Academy’s own code (Explainer 8). Phase 7 adds E10 and E11 above. Phase 8 adds none: it connects the system to the rest of the site (Explainer 10).

Findings so far

Measured by the spikes on the existing code. They are COMPUTED facts about that code, reported here because the design depends on them, and they are not the claims above.

FindingMeasuredSpike
An engram is the parity of each letter’s count; at most 2²⁶ keys occur; numeric tokens are the zero engramrank 26 over GF(2); LISTEN = SILENTA
64 bits fit in one integer quaternion of the norm-5 tree, and a chain of them is one quaternion2000/2000 and 40/40 round-tripsB
Float placement in H³ holds to depth 12 and fails from depth 1450/50 at 12; 36/50 at 14; 0/50 at 18B
The orbital code’s tiles, Merkle chain, gauge and pump work on engrams unchanged58/58 windows repaired; 57/57 gauges recoveredC
The same bit flipped in two cells passes the parity, so the Merkle chain is neededcaught only by the chainC
In the hold setting a register leaves a half turn; free-run closes itP = 360/720 against P = 0C
The fence measures distance from the centre, not depth, so it also flags the straightest leaves; the exact address check clears them6/187 at depth 3, all clearedD
06

Decisions

Adopted on 2026-11-04, before registration. They are fixed design inputs of the preregistration, so changing one is an amendment.

#DecisionAlternative not taken
D1The system lives in its own folder, Pages/Engram Minds Eye/, with its own menus, and loads shared cores by relative pathA module inside Hyperbolic Oracles
D2The orbital code is extracted into one orbital_core.js that build.py inlines into the four orbital pagesReading functions from the templates by name, as Spike C did in Phase 0
D3On the wire an engram is two Einstein tiles of Form 5, a new form defined as an engram/1 half (high and low 32 bits), with the structure field α = 0, β = 1, γ = 2, Y = 3; Owl Academy’s SHD-CCP word appears only at the bridgeOwl Academy’s word inside the system; Form 3, which means a binary32 value
D4engram/1 is frozen; an order-aware key that keeps digits would be engram/2, with its own preregistrationImproving the key in place
D5The memory channels run in the Zero-Point Tri-Engine’s free-run + membrane setting, so every register closesThe hold setting, which leaves a half turn per register
D6STRIX replies by retrieval only in the core; BERT or an API comes as a plugin whose turns are logged as attestedA language model in the core
D7hpstep/__init__.py imports lazily, so the exact modules import without torchCopying the exact modules into a second package
07

How the folder grows

The same rule as Hyperbolic Oracles: every module added here ships with five things.

  1. The code, in reference/ (Python) or beside this page (browser).
  2. A full explainer in explainers/, built on assets/em.css, opening with its focused chart (<div data-em-map="focus" data-node="…">).
  3. A node on the system map in assets/em-map.js, with its edges and its explainer. Every chart in the folder updates from that one list.
  4. A row in the claims ledger for anything it claims, with a status tag.
  5. Tests, added to tests/all.cjs, and a line in the folder’s README.md.

Before committing, run node "Pages/Engram Minds Eye/tests/all.cjs": it checks this system and every core it loads (Explainer 10).

PathHolds
index.htmlThis hub
explainers/One full explainer per topic
assets/em.css, assets/em-map.jsShared style; the system map data and its chart renderer
reference/The Python reference (Phase 2) and golden/, the corpus pinned from Owl Academy
tests/The Node checks; all.cjs runs them all
spikes/The four feasibility spikes and their captured outputs
README.md, PREREGISTRATION.mdThe plan and file map; the claims fixed in advance
08

Glossary

Engram
A 64-bit grid, 8 × 8, made by XOR-ing a grid per letter of a word. engram/1 is Owl Academy’s definition, frozen here.
STRIX
Owl Academy’s familiar: it remembers a conversation as engrams and answers by recalling the nearest one.
Window α, β, γ
The last three engrams. Here they ride the three engines of the zero-point clock.
Y
The parity cell, α ⊕ β ⊕ γ. With it any one lost cell is rebuilt.
Packet
One word’s record. In Owl Academy, 128 bits: codex parity, the grid, and its distances to the window. Here also its exact address and two Einstein tiles.
Address
A 28-letter reduced word in 1 ± 2i, 1 ± 2j, 1 ± 2k: one integer quaternion that holds a packet’s 64 bits exactly.
Chain quaternion
The product of a chain’s addresses in order. Right division unfolds it back into its packets.
Einstein tile
Engine v10’s 64-bit word: halo (step, wheel, structure), gate, control (form, slot, scale) and a 32-bit core.
Register
720 frames. Its packets telescope through 72 blocks and 10 groups, as in the 720 → 72 → 10 pump.
Gauge
Proposition 7.14’s exact, invertible reading of three values as their total and their lean. Equal values lock.
Free-run + membrane
The Zero-Point Tri-Engine’s clutch setting in which every engine turns on every frame and the membrane removes the differential at each zero point.
Fence, guard
The 0.7 Claude fence flags points too far from the centre; the guard proves a stored distance wrong when four points break the ln 2 bound.