BLOCH

A deterministic, offline Bloch-sphere trajectory, lookup-table, state-space, replay and extrapolation laboratory.

Launch the BLOCH State-Space Lab →

BLOCH implements the missing path-memory layer described by 罔 rō'nin (@theronin42):

plot points on a Bloch sphere, map the sphere onto a 2D grid, turn the grid into a LUT, record each point's movement as encoded frames in a dedicated state space, then extrapolate from the recorded path.

The result is not just a sphere animation. It is a complete, inspectable instrument in which every observed point receives a grid address, every frame joins a domain-separated SHA-256 chain, every trajectory can be replayed from its beginning, and forecasts are derived from recorded angular motion.

flowchart LR
    A["Bloch vectors"] --> B["Octahedral grid"]
    B --> C["LUT addresses"]
    C --> D["Encoded frame chain"]
    D --> E["Replay + forecast"]

Loading

The important distinction

rō'nin and QSOLKCB/QEC use different recovery architectures.

Layer	QSOLKCB/QEC	BLOCH / rō'nin model
Error representation	Syndrome / finite-code error	Tangent deviation from a reference manifold
Recovery path	Syndrome → decoder → correction	Parallel transport → fixed contraction → exponential map
Learned or adaptive component	Not required by the exact QEC decoder	None
Natural zero	Zero syndrome / stabilizer closure	e = 0, meaning observed state equals its reference
Path memory	Proof, event and recovery receipts	Per-point grid and vector frames from start to finish

In BLOCH, zero does not mean the Bloch north pole (|0\rangle). It means zero local deviation from the relevant reference point:

eᵢ,t = 0  ⇔  observedᵢ,t = referenceᵢ,t

That reference may move. A point can follow a braided or closed path while remaining at zero deviation for the entire traversal.

What the lab provides

• rotatable pure-state Bloch sphere with reference, observed and forecast paths;
• reversible octahedral sphere-to-square mapping;
• generated 8×8 through 128×128 Bloch-vector LUTs;
• fixed RONIN-ZERO restitution profile with no decoder and no tuning loop;
• deterministic manual and scenario perturbations;
• local CSV/JSON ingestion for external x,y,z or theta,phi trajectories, with optional reference vectors and a committed source-file SHA-256;
• 64-byte BLSF binary frame records;
• canonical integer JSON identities and domain-separated SHA-256 frame chains;
• exact replay from the initial state and declared manual impulse events;
• constant-angular-velocity geodesic extrapolation;
• short/long transition windows with Forman, spectral-moment and relative holonomy witnesses;
• MATLAB-style restoration surface and return-to-zero contours;
• JSON, CSV, LUT, binary, WAV and audio-receipt export;
• deterministic trajectory sonification derived from the SPECTRAL / SONIFICATION workbench lineage;
• browser known-answer tests and a dependency-free Node test suite;
• GitHub Pages deployment after changes reach main.

Start offline

Download or clone this repository and open index.html directly in a modern desktop browser.

git clone https://github.com/QSOLKCB/BLOCH.git
cd BLOCH

No server, CDN, framework, package install, build step, cloud service, network request, service worker or analytics client is used. The application works through file://.

Node.js is optional and used only for development verification:

npm test
npm run check

The browser suite can also be opened directly from tests/index.html.

Natural return without a decoder

For reference point (r_t \in S^2), observed point (s_t \in S^2), and local tangent deviation (e_t), the profile applies

[ e_{t+1} = \frac{5}{8},\mathcal P_{r_t\rightarrow r_{t+1}}(e_t)

• \eta_{t+1}, \qquad s_{t+1}=\exp_{r_{t+1}}(e_{t+1}), ]

where:

• (\mathcal P) is deterministic geodesic parallel transport;
• (3/8) is the fixed restitution fraction;
• (5/8) is the residual deviation after one unforced step;
• (\eta) is a declared deterministic perturbation;
• no syndrome, decoder table, optimizer, model training or adaptive tuning is consulted.

The default impulse is 480,000 μrad; its next unforced state is exactly 300,000 μrad before integer frame quantization.

See the mathematical and replay contract for the full model.

Sphere → grid → LUT

BLOCH uses octahedral normal-vector encoding rather than an equirectangular map. It folds the unit sphere onto one square with no longitude seam and provides a direct reversible address for every unit Bloch vector.

For grid resolution (N):

column = min(N − 1, floor(uN))
row    = min(N − 1, floor(vN))
index  = rowN + column

Each LUT entry stores its cell-centre Bloch vector as three signed integers at scale 1,000,000. The exported LUT has its own receipt.

Encoded state-space frames

Each point/frame record commits:

• sequence and point index;
• manual/automatic impulse, contraction and forecast flags;
• observed, reference and forecast LUT addresses;
• quantized 2D map coordinate;
• observed and reference Bloch vectors;
• deviation and per-step recovery in microradians;
• forecast horizon;
• previous frame hash and current frame hash.

The chain is global and ordered by (sequence, point). Changing one coordinate, flag, address or predecessor breaks verification. A recording also commits the configuration, fixed profile, manual impulse schedule, frame chain and dual-window geometry bundle.

Available exports:

Artifact	Purpose
*.recording.json	Complete replayable frame chain, profile, geometry bundle and receipt
*.frames.csv	Flat research table for external analysis
*.blsf	Compact fixed-record binary state space
bloch-oct-lut-*.json	Resolution-specific sphere lookup table
*.wav	Authored audible receiver containing every recorded sequence
*.audio-receipt.json	WAV hash, mapping, source-frame head and output measurements

Import external trajectory data

Select IMPORT CSV / JSON. Nothing is uploaded.

CSV accepts:

sequence,point,x,y,z,target_x,target_y,target_z
0,A,1,0,0,1,0,0
1,A,0.995,0.0998,0,1,0,0

frame can replace sequence; id can replace point. Angular input may use theta,phi in radians. reference_x,reference_y,reference_z are accepted as aliases for target_*. If no reference vector is supplied, the observed vector is its own reference and therefore has zero declared deviation.

JSON accepts an array of objects with the same field names. The importer normalizes vectors, maps sequence and point labels to dense integer addresses, quantizes the source, and commits both the quantized samples and original file SHA-256 to the replay configuration. Imported paths are read-only; the generated scenarios remain available for active perturbation experiments. Every point must have a sample in the first normalized sequence; BLOCH rejects datasets that would otherwise fabricate a point's earlier state.

Audio export includes every normalized sequence. For paths longer than 512 sequences, the receiver deterministically compresses the complete timeline into a 38.4-second sequence span instead of discarding the beginning. The audio receipt records the rendered sequence range and effective step duration.

Try fixtures/sample-trajectory.csv directly in the importer. The pinned engine profile is also committed as fixtures/ronin-zero-profile.json and checked against the runtime by the test suite.

Dual-window geometry witness

The state-space trajectory becomes a transition multigraph over visited LUT cells. Short (16) and long (64) windows each emit a companion triple:

1. Forman witness — integer (F(e)=4-\deg(u)-\deg(v)), plus maximum absolute and window-L1 statistics;
2. spectral-moment witness — exact integer (\operatorname{tr}(L)) and (\operatorname{tr}(L^2)) of the undirected transition Laplacian;
3. relative holonomy witness — quantized difference between observed and reference discrete Berry phase when the reference window closes.

The optional weighted mode uses a pinned integer multiplicity map:

drift = 1 · recovery = 2 · impulse = 3

This keeps identity arithmetic integral. The geometry bundle is a diagnostic witness around the trajectory; it is not a physical QEC authority and does not cause the manifold contraction.

QSOLKCB lineage used

Repository	Contribution to BLOCH
QEC	Exact replay discipline, clear decoder boundary, qutrit-state visual research and recovery-path comparison
HERESY-SEC	Strict canonical identity, domain-separated receipts and Forman / spectral / holonomy companion geometry
SPECTRAL	Offline browser research-instrument architecture, deterministic WAV and provenance boundary
SONIFICATION	Separation of mathematical source, receiver mapping and acoustic claim
VIZ	Dependency-free Canvas visualisation, direct file:// operation and Pages packaging
E8_MUSIC	Seeded browser synthesis, PCM writer and hash-bound audio receipts

The implementation is purpose-built for BLOCH. It does not silently replace or reinterpret the exact contracts of those projects.

Determinism boundary

Layer	Guarantee
Frame and receipt identities	Safe integers, canonical key order, fixed domains and SHA-256
Same engine/runtime replay	Bit-identical frame chain, geometry bundle and WAV
Cross-runtime trigonometric state	Quantized replay-safe identity; no claim of a cross-engine transcendental ABI
Canvas, viewport, playback and UI	Display only; excluded from identity
Wall clock, locale, filename and network	Excluded

Claim boundary

BLOCH is a deterministic classical model and research visualisation for pure-state Bloch vectors and their recorded trajectories. It does not:

• access quantum hardware;
• measure or reconstruct an unknown physical quantum state;
• simulate a complete open quantum system;
• prove a passively self-correcting quantum memory;
• demonstrate fault tolerance or a threshold theorem;
• replace a stabilizer, subsystem, topological or bosonic QEC decoder;
• establish that an engineered physical manifold will “snap” real qubits back to a code state.

The lab makes rō'nin's computational architecture explicit and falsifiable. A separate physical model and experiment would be required to make hardware or fault-tolerance claims.

Project structure

index.html                 Offline laboratory shell
style.css                  Responsive industrial visual system
js/hash.js                 Strict canonical JSON and synchronous SHA-256
js/bloch-core.js           Sphere map, LUT, manifold, recorder, replay and geometry
js/bloch-audio.js          Deterministic trajectory synthesis and PCM WAV writer
js/visuals.js              Bloch, LUT, state, mesh and contour Canvas receivers
js/app.js                  Controls, inspection, import/export and playback
docs/MODEL.md              Mathematical, frame and determinism contract
docs/BLSF.md               Fixed 64-byte binary frame format
fixtures/                   Pinned profile and local import example
tests/                     Node and direct-browser known-answer suites
.github/workflows/         Verification and static GitHub Pages deployment

Attribution

Concept direction and the sphere → grid → LUT → frame-state-space requirement: 罔 rō'nin (@theronin42).

Implementation and QSOLKCB integration: Trent Slade / QSOL-IMC.

See NOTICE.md for source-lineage notes.

Licence

Mozilla Public License Version 2.0. Copyright 2026 Trent Slade / QSOL-IMC.