Engram Mind’s Eye · Explainer 1

The Architecture

Eight layers, each built from a system this site already has. This page follows one word from the moment it is typed to the register that closes over it, and says which system does each part and which claim will test it.

Try one word, live System map The evidence
Contents
  1. Where this sits
  2. Eight layers
  3. The key
  4. Five tiers
  5. The packet
  6. Window and memory
  7. Resonance
  8. The register
  9. Geometry
  10. The watch layer
  11. One word, live
  12. Outside the core
01

Where this sits

The window and memory layer sits at the centre: it takes the clock and the triple quad from the orbital calculators and the packet from the layer before it, and feeds the resonance reading, the register and the 2D page.

02

Eight layers

Every layer replaces one piece of Owl Academy’s engram system with something exact from this site. The key itself does not change.

LayerOwl Academy todayHereFromClaim
L0 KeyTTMPT coreThe same, verbatim and frozenOwl AcademyE1
L1 PipelinelogPacketOne word as one calculation, T4 to T0Engine v10—
L2 Packet128-bit packet; quat32The packet kept, plus an exact address and two Form 5 tilesPolyStep, engine v10E2
L3 Window and memoryα/β/γ window; codex parityThree channels on the clock; triple-quad words with Merkle repairZero-Point Tri-Engine, ConvergenceE3
L4 ResonanceConcept chips, J meter, SVG pulseThe exact gauge, the lock and the soliton crystalConvergence, SolitonE6
L5 RegisterEpochs, text crystal, Engram Codec720 frames telescoping through 72 and 10Zero-Point Tri-EngineE4
L6 GeometrySVG manifold; Three.js latticeThe memory tree in H² and H³, frames, the twin systemPolyStepE5
L7 WatchNoneFence screen, exact address check, ln 2 guardThe 0.7 Claude fenceE7, E8

Recall itself, STRIX answering by the nearest stored key, stays as Owl Academy built it. Claim E9 records in advance what it can and cannot do.

03

L0 · The key

Each letter of the alphabet has a fixed 8 × 8 grid of bits, drawn by Mulberry32 from a seed made of the letter. A word’s engram is the XOR of its letters’ grids. That is all engram/1 is.

Because XOR cancels in pairs and does not care about order, the engram records only whether each letter appears an odd or even number of times. LISTEN and SILENT share a key; so do EYE and Y; every number is the empty key, because digits are skipped. The 26 letter grids are independent over GF(2), so exactly 2²⁶ of the 2⁶⁴ possible keys can occur.

Why freeze it anyway

Every chain, seed, export and biochain engram stream in Owl Academy is built on this key. Changing it would cut the two repositories apart. So it is copied verbatim (ttmpt_core_v1.js) and pinned by a golden corpus of 536 entries taken from Owl Academy’s own files (claim E1). A better key would be engram/2, with its own preregistration (decision D4).

04

L1 · One word on five tiers

On the one-engine calculator a calculation starts on the outer torus T4 and winds inward to T0, one stage per tier. A word does the same, and each stage keeps its meaning.

T4 · ingestCrystallize the word into its engram/1 grid. In the engine: numbers become exact fractions.
T3 · alignMeasure its Hamming distance to α, β and γ: the packet’s footer. In the engine: common denominators.
T2 · superposeXOR it into the parity Y and multiply its address into the chain quaternion. In the engine: the operator acts.
T1 · pruneKeep the chain word reduced and the quaternion coprime. In the engine: common factors removed.
T0 · latchWrite the two tiles, the Merkle leaf and the memory word. In the engine: the result is written out.

The tiers keep engine v10’s laws, Rₙ = 5n² + 15n + 15, rₙ = 2n + 4 and Wₙ = 16 − 2n, and its 30-node clock. They are read from TIERS_SPEC in the build templates, so engine v10’s own file is never touched. On the 2D page each word will be drawn winding inward like a calculation; in compute mode the five stages simply run in order.

05

L2 · The packet

A word leaves the pipeline as three things: Owl Academy’s 128-bit packet, kept so exports stay compatible; an exact address; and two Einstein tiles for the wire.

The address

The six quaternions 1 ± 2i, 1 ± 2j, 1 ± 2k generate a tree: a reduced word in them has a unique integer quaternion, and right division recovers the word. Each letter after the first has five choices, and 5²⁸ is larger than 2⁶⁴, so a 28-letter word holds the packet’s 64 bits. The digits are read in base 5, least significant first, and each letter is one of the five children of the word so far, so a chain of packets is one reduced word and one quaternion. Right division unfolds it again, in order (claim E2). Owl Academy’s quat32 field, a float quaternion folded from a hash into four bytes, cannot be inverted; this can.

The tiles

Engine v10’s Einstein tile is a 64-bit word with a 32-bit core. An engram travels as two tiles. Their form is 5, a form defined for this system as an engram/1 half, because Form 3 already means a binary32 value (decision D3).

FieldBitsFor an engram
Step, wheel63–58The cycle step and wheel unit of the frame it latched on
Structure57–56Which cell: α = 0, β = 1, γ = 2, Y = 3
Gate, mux55–44As on the orbital pages
Form43–405: an engram/1 half
Slot39–364h + structure, h = 0 for the high half and 1 for the low half
Core31–0Cells 32–63 of the grid (h = 0) or cells 0–31 (h = 1)
06

L3 · The window and the memory

Owl Academy keeps the last three engrams in a window, α oldest and γ newest. Here the window rides the three engines of the Zero-Point Tri-Engine.

  • The clock. Joint frame n = F mod 24. Channel α onloads a packet at n = 18, β at 10 and γ at 2, and each offloads twelve frames later. The three pair at the zero point, n = 0.
  • The word. At each zero point the three cells and their parity Y = α ⊕ β ⊕ γ form a triple-quad word over GF(2), written at one of 30 addresses on the outer and inner manifolds, as Tri-Engine Convergence writes its words.
  • The chain. A Merkle chain over the four leaves (Lemma 15). If one cell is altered, the parity fails, the deepest layer of the chain that differs names the cell, and XOR of the other three rebuilds it (claim E3).
  • The lineage. A SHA-256 memory word is chained at every zero point. Owl Academy’s codex parity is kept as a field, but it is linear and its own continuity check always passes, so it carries no integrity here.
Why the chain is needed

If the same bit flips in two cells, the flips cancel in the parity and the word looks whole. Only the chain sees it. Spike C showed this on the orbital pages’ own Merkle code.

07

L4 · Resonance

Each new word has three distances, to α, β and γ. Owl Academy packs them into the footer; here they are read through the convergence engine’s gauge.

Proposition 7.14 turns three values a, b, c into s = a + b + c, X = a − (b + c)/2 and Y = b − c, and back again exactly. s says how far the word is from the window as a whole; X and Y say which cell it leans toward. When the three are equal, X = Y = 0 and the landing triangle of the convergence readout is exactly equilateral: the lock (claim E6). In Spike C’s dialogue, 1 packet in 57 locked.

The soliton crystal of the Tri-Engine Soliton becomes the memory’s health display. It sits at the centre while every word’s parity holds and the chains match, moves off the axis with the gauge’s lean, and shears when the coupler’s binding (L6) is broken.

08

L5 · The register

Every 720 frames a register closes. Its packets fall into 72 ten-frame blocks and the blocks into 10 inner groups, the same 720 → 72 → 10 scales as Owl Academy’s Ontological Codex.

Each block holds the ordered product of its packets’ addresses, and each group the ordered product of its blocks. All three products must be the same integer quaternion, and its conjugate is the compensator that undoes it (claim E4). This replaces Owl Academy’s Engram Codec, which keeps rotations on one axis so they commute and reaches its block boundaries to about 10⁻¹⁵; integer products need no fixed axis and have no error. The 72- and 720-section exports become these slots, now holding real quaternions where Owl Academy’s export holds XOR grids under the name quaternion_chain.

The clutch

The memory channels run in the Zero-Point Tri-Engine’s free-run + membrane setting: every channel turns on every frame, so the engagement pump closes each register (P = 0), and the membrane removes the differential at each zero point (decision D5). In the hold setting a channel turns only while a packet is in flight, and Spike C measured the cost: half a turn left over per register.

09

L6 · Geometry

The Mind’s Eye draws the memory in hyperbolic space. Two things about a packet are drawn, and they are kept apart on purpose.

  • Position: where it sits in the memory. Its register, section and slot form a short word in the same norm-5 tree, laid out by PolyStep’s tree embedding in H² and H³. Spike B measured that float placement decodes cleanly to depth 12 and fails from depth 14, so short structural words are what can be drawn.
  • Frame: what it holds. The exact quaternion of its 28-letter address, drawn as the packet’s orientation. Engram bits behave like a hash, so placing packets by content would scatter them at random; placing them by structure gives a map you can read.
  • The twin system. The human stream and the STRIX stream are PolyStep’s two structures. Every packet’s address is the twist its structure issues, the coupler applies it to both sides by the mirror law, and the binding B = q₂q₁ is checked exactly at every zero point (claim E5). The coupler writes a third memory chain beside the two streams’.
10

L7 · The watch layer

The 0.7 Claude fence has a job here that matches what it was preregistered to do: find points that sit too far out in a hierarchy-shaped cloud.

  • Screen. At each register close the fence runs on the H³ layout and flags memories beyond it.
  • Decide. Each flag is settled exactly: a memory is in its place when its point equals, in rationals, the point of its recorded address. Spike D showed why the second step is needed: the fence measures distance from the centre, not depth, so it also flags the straightest leaves of the deepest level, and the exact check clears them (claim E7).
  • Guard. No four points of Hⁿ break the ln 2 four-point bound, so a quadruple of stored distances that does proves one of them wrong; the pair in the most such quadruples is named (claim E8).
11

One word, live

This lab runs the verbatim engram/1 core and Hyperbolic PolyStep’s browser core in your browser. It shows layers L0 to L3 for one word; nothing here is the system itself, which is built in Phases 2 and 3.

Lab · a word enters the window

T4 · ingest: the engram/1 grid

The grid, cell i = 8r + c
Readout

T3 · align: distances to the window, and the gauge

T2 · superpose: the new window and its parity Y

Press the button to drop α, then β, then γ, and rebuild each from the other two and Y.

T1 and T0 · the exact address, and back

12

Outside the core

Some of Owl Academy’s engram system stays out of this one, by design.

  • Firebase, seals and biochain publishing. Owl Academy binds the familiar to a signed-in account and publishes chains through Firestore with seal signatures. Here everything runs offline; the bridges (Phase 6) import and export the same JSON, so a chain can still go back to Owl Academy to be published there.
  • BERT and other language models. STRIX answers by retrieval in the core, which can be replayed bit for bit. A language model can be added as a plugin, and its turns are logged as attested, as Owl Academy’s Language Growing page does (decision D6).
  • A better key. engram/2, if it is built, is a separate experiment with its own preregistration. Only with a key whose bits carry meaning would the fence become a detector of new ideas.