Contents
Where this sits
The browser core takes the Python reference’s logic and the shared cores’ code, and is what the 2D and 3D pages will run on.
One module on the shared cores
engram_core.js is UMD: a global EngramCore in a page, require() in Node. It re-implements nothing that already exists. It loads five modules and adds only the engram layer.
| It loads | From | For |
|---|---|---|
| orbital_core.js | scripts/geometric-build (Phase 1) | Exact fractions, the Einstein tile, SHA-256 and the Lemma 15 Merkle chain, the gauge, the readout and its lock, the pump |
| hyperbolic_core.js | Hyperbolic PolyStep | The norm-5 tree (generators, children, word quaternion, right division) and the seeded generator |
| decoder3d.js, twin3d.js | Hyperbolic PolyStep | The tree laid out in H³ with exact decoding; the exact quaternion product and qnormExact of the mirror law |
| fence.js | Hyperbolic PolyStep | The 0.7 Claude fence, its ln 2 guard, the distance matrix and the corruption of one distance |
| ttmpt_core_v1.js | this folder (verbatim from Owl Academy) | engram/1: Mulberry32, the letter grids, XOR crystallization, Hamming distance, chiral key, torsion J |
What it adds is a line-by-line twin of the reference’s modules, in the same order of operations, so that every exact value and every float comes out the same:
| Python reference | In engram_core.js |
|---|---|
| ttmpt.py | Both tokenizers, biomesh.js’s engram stream, the 128-bit packet chain (PacketChain) |
| address.py | The 28-letter address, the chain word and quaternion, unfolding by right division |
| memory.py | The triple-quad word with its Form 5 tiles, Merkle chain, locate, rebuild and repair; memory links |
| clock.py | The schedule, zero points, the membrane turn, registers with 72 blocks and 10 groups, telescoping, engagement |
| coupler.py, session.py | Coupler (the mirror law and its control) and Session, a dialogue end to end with outputs() |
| dialogue.py, recall.py | The dialogue store and synthetic dialogues; Hamming recall, the parity-keeping variants and the substitutions |
| watch.py | E7’s fence screen settled by the exact address check, and E8’s guard |
The orbital ports in orbital.py have no twin here: in the browser the original, orbital_core.js, is used directly. Neither does stats.py, the bootstrap, which only the claims runner needs.
How it is checked
Two files fix what the module must produce, and it is compared with them one case at a time.
| Target | Lines | What a line is |
|---|---|---|
reference/golden/engram_v1.json (claim E1) | 613 | Each of the 536 entries computed by Owl Academy’s own page and by biomesh.js (hex, 64-bit seed, chiral key, J, bit count); the two tokenizers on three texts; the engram stream; each of the 69 packets of the golden chain; the final codex parity. The same 613 cases E1 decided in Python |
reference/traces/engram.json | 236 | The Python reference’s exact values: 12 addresses, the chain word and quaternion and its unfolding; the schedule; all 23 memory words of the golden session (cells, tiles, Merkle root, link); 30 gauges with their readout nodes and lock; a complete register of dialogue 9000 (its packet, block and group products, telescoping, the pumps); the coupler at every zero point; the watch layer on four E7 and five E8 instances; the three guards of E10 on 20 corrupted matrices (added in Phase 7); 40 recall queries |
Quaternions and fractions are compared as exact strings, some of them hundreds of digits long; 64-bit words as hex; floats with ===. The traces use only unregistered seeds (dialogue 9000, the watch layer on 9100–9104), so checking them never touches what the claims runner decided.
On top of the parity lines, the module runs the 27 checks of the Python tests on itself with the same seeds: every single-bit flip located and repaired, double alterations refused, the controls of the address, the registers and the coupler breaking what they should, free-run closing every register, the lock exactly when the three distances are equal, the fence’s flags all settled, and recall’s variants and substitutions. One check uses different seeds from its Python twin: the substitutions, which Python draws from E9b’s registered seeds 1000 + i and the browser from 9000 + i.
Six errors were planted in copies of the two files: one 64-bit seed of the corpus, one packet’s footer, one Merkle root, one group product, the coupler’s final quaternion and one recall hit. The check failed on exactly those six lines and passed the other 823.
Parity: 849/849 lines match the reference
Behaviour: 27/27 checks of the Python tests hold (about 3.5 s in all)
Parity, live
This page loads the module and the two target files and runs every line in your browser. Open a section to read its lines.
The target files could not be fetched, which happens when the page is opened straight from disk. Serve the folder (for example python3 -m http.server at the repository root), or pick the two files here:
A session in your browser
The same code, on your words. Each token becomes a packet in the chain; the window rides the zero-point clock; a memory word is written at each zero point; the coupler binds the two streams.
| # | Token | From | Header | Body (seed64) | Footer | Nearest concept |
|---|
Using it
There is no build step. A page loads six scripts in order; Node needs one require.
<script src="Pages/Hyperbolic Oracles/hyperbolic_core.js"></script>
<script src="Pages/Hyperbolic Oracles/decoder3d.js"></script>
<script src="Pages/Hyperbolic Oracles/twin3d.js"></script>
<script src="Pages/Hyperbolic Oracles/fence.js"></script>
<script src="Pages/Engram Minds Eye/ttmpt_core_v1.js"></script>
<script src="Pages/Engram Minds Eye/engram_core.js"></script>
const EC = window.EngramCore;
const run = new EC.Session([['strix', EC.tokenize('I am STRIX')], ['human', EC.tokenize('Show me a geodesic')]], 'carry');
run.chain.packets; // header, seed64, footer, triangulation of every token
run.words; // the memory words written at the zero points, with roots and links
run.registers; // 720-frame registers with block and group products
run.coupler.log; // the binding at every zero point
// Node
const EC = require('./Pages/Engram Minds Eye/engram_core.js');
The pages of Phases 4 and 5 will be built on this, so what they show is what the reference computed.
Smaller changes
ttmpt_core_v1.jsmoved fromspikes/to the system’s folder, where the browser core and the pages load it. Its text is unchanged; the spikes and the architecture lab now load it from there, and the four spikes give the same output as before.- The traces gained a
watchsection: four E7 instances and five E8 instances on seeds 9100–9104, so the browser’s fence and guard are checked too. Every other section of the file is unchanged, and the reference’s 41 tests still pass. run_traces.pysays which seeds the watch section uses, and why they stay clear of the registered ones.