The Simulation Manual

Where this sits

The simulation is the end of the build: it runs the browser core, which reproduces the Python reference, and shows the three channels, the step, the memory and Helix B working together. Its results feed the proofs-and-results page of Phase 4.

Quick start

1. Open the page. It opens paused at frame 0 with B1 (60 vertices) built, and replays six of the reference’s trace files through the core. The Self-test panel should read 105/105 match within a second or two.
2. Press Play (or Space). The clock turns, each channel steps at its offload frame, and every 24 frames a zero point certifies the three incumbents and writes a memory word.
3. Watch the answer. On B1, red edges are conflicts in the best certified colouring. The count falls as the channels work. The run pauses itself when the evaluation budget is spent.
4. Change something. Every setting except speed rebuilds the run from frame 0, so two runs with the same settings and seed are identical.

How it is wired

The page holds no solver logic of its own. Controls build objects from the core, the core advances them, and the panels read them. The chart shows which control reaches which object and which panel reads which object.

A build makes one problem instance from problem, size, objective and seed; three PolyStepH solvers, one per channel, each with its own generator (seeded \(1000\,s + 10 + j\)) and its own starting particles (seeded \(1000\,s + 20 + j\)); and one TriChannel that owns the clock. Play calls TriChannel.run({ frames }) in batches of at most 24 frames, spending no more than about 28 ms per animation frame, so the page stays responsive at any speed.

Controls

The control bar stays at the top of the screen while you scroll. Changing any setting except speed pauses the run and rebuilds it.

B3’s budget equals the number of addresses, so the search is allowed exactly what exhaustive enumeration would need.

Panels and readouts

The Poincaré view

What it draws depends on the problem.

• B1 and B2: one factor of the product space, as a Poincaré disk (or, at curvature 0, the plane scaled so the horizon of radius 8 is the edge). Solid dots are each channel’s particles; rings are each channel’s incumbent. The faint spokes are the last step’s polytope: geodesics from each particle to its \(2d\) corners, with corner dots sized by their softmax weight. On B1 the three tinted sectors are the three colours; a vertex takes the colour of the sector its point lies in. On B2 the factor is a point of \(H^8\) and the view shows its first two axes; a variable is true when its point lies on the positive side. The view starts on factor 0; on B1, click a vertex in the answer panel to show its factor. The spokes appear only when the last step moved the factor on show, so with 8 of 60 factors per step they come and go.
• B3: the tree drawn in the frame of channel A’s best particle’s anchor node, one level up and three down. Every edge is a geodesic, so the tree fans out towards the rim, as trees do in hyperbolic space. The gold path leads to the target. The dots are particles anchored at this node.
• B4: the eight class prototypes of the best certified network (rings, numbered) and up to 250 test inputs mapped through its encoder, coloured by true class. The network assigns each input to its nearest prototype.

The clock

The dial shows the eight spinor stages (Snap, Seed, Onload, Project, Invert, Fold, Offload, Index) with the current one lit, \(k = F \bmod 8\). The three inner arcs are the branches, \(j = F \bmod 3\). Beside the dial, each channel’s packet: in flight for the 12 frames from its onload (\(n\) = 18, 10, 2) to its offload (\(n\) = 6, 22, 14), where it steps. The strip below lays out the whole 24-frame joint cycle, with ▼ at each offload. The readouts give the register (720 frames), the spinor cycle (90 per register), the joint cycle (30 per register) and, on the exact track, the pump result. The bar fills through the current register.

The answer

Helix B’s view: the best certified answer so far, decoded and checked exactly.

• B1: the graph on a circle, vertices coloured by their decoded colour, conflicting edges in red. conflicts (exact) is the integer count; 0 means a proper colouring.
• B2: one cell per variable (green true), and the share of clauses satisfied. unsatisfied clauses (exact) is the integer count.
• B3: the target address and each channel’s decoded incumbent, digit by digit; green digits agree with the target from the root. best tree distance 0 means the target was found, and certified by right-division confirms the decoded word divides back out of its quaternion of norm \(5^L\).
• B4: the confusion matrix on held-out test data (rows true class, columns predicted), test accuracy, accuracy at the coarse level of the class tree, and the exact count of training errors, which is what Helix B certifies.

Channels

One row per channel: steps taken, evaluations used, the incumbent’s objective value (the search’s own, possibly graded, score), its best certified cost, how many zero points since it last improved (stale), and whether it is running or resting. The chart plots each channel’s certified cost at every zero point. Below it: evaluations against the budget, the number of zero points, the memory chain and the largest move the membrane made at the last zero point.

The memory words list the latest eight records: frame, the three certified costs, their sum Y, the winning channel and the hash. Each hash is SHA-256 of the record together with the previous hash, cut to 16 hex digits. On every redraw the page recomputes the whole chain from the first word and shows intact only if every hash follows.

Self-test and log

The self-test replays the reference’s trace files through the core on this page, exactly as the core reference does: 105 lines from six files on load, and all 169 with Run all seven, which adds three channels over two full exact registers. The log lists builds, every improving zero point, channels resting and waking, closed registers and the self-test result, newest first.

The exact track

With the exact track on, every state is a rational point on the sheet, so its history can be checked exactly. Each register is checked with the paper’s 720 → 72 → 10 pump.

Whenever a particle’s factor moves, at a step or in the membrane, the core records the exact Lorentz matrix that moved it, \(\Delta = L_{x_\text{new}} L_{x_\text{old}}^{-1}\), in that frame’s slot. Frames where the factor did not move hold the identity. At frame 720 it forms, for every channel, particle and factor:

2397P = \Delta_{720}\cdots\Delta_1,\qquad Q_{10} = \prod_{m} \delta_m,\qquad Q_8 = \prod_{\ell}\Big(\prod_{m \in \text{block } \ell} \delta_m\Big),\qquad H = Q_8\,Q_{10}\,P,2397

where \(\delta_m\) is the inverse of the product over the \(m\)-th run of ten frames. It then checks \(Q_{10} = Q_8 = H = P^{-1}\) and that \(P\) carries the register’s starting point exactly to its final point. The clock panel’s pill reads closed with H = P⁻¹ only when every check holds for every factor of every particle of every channel.

Experiments

Each link opens the simulation with the settings filled in. The results quoted are single runs with seed 1000 to the full budget, computed with the same core. They show what to look for. They are not evidence for or against any claim (chapter 9).

Scripting and links

The page reads its settings from the address and exposes its run to the browser console.

HPSim.advance(720)          // run 720 frames now
HPSim.render()              // redraw the panels
HPSim.sim.tc.memory         // every memory word: { F, costs, Y, best, hash }
HPSim.sim.tc.registers      // [{ F: 720, pump_identity: true }, ...]
HPSim.sim.states[0].X       // channel A's particles, float coordinates
document.body.dataset.frame // the current frame, also set for tests

Reading results honestly