Contents
What this is
Three pieces meet here.
polystep
A gradient-free optimizer. Each step turns a polytope around the current parameters, scores its corners, weights them by optimal transport and moves to their weighted average. It trains spiking, quantized and hard-routed networks that have no useful gradient.
The zero-point paper
The exact geometry of hyperbolic space (the ghost map, the Klein model, boosts as complex rapidity), the eight-step clock and its 24-frame schedule, the 720-frame pump, and the limits of what any of it can decide.
The tri-engine pages
Three engines on one clock, pairing at the zero point, a timing clutch and membrane, and memory on the outer and inner manifolds. They become three solver channels.
Put together: polystep’s step on the hyperboloid, with every candidate an exact rational point, run by three channels that each take one step per joint cycle and pair their certified answers at the zero point. It trains small hard-threshold networks and attacks combinatorial problems (3-colouring, MAX-SAT, tree addresses) without gradients.
A heuristic solver is the paper’s Helix A: it proposes, and an exact certifier checks. Its successes or failures say nothing about P versus NP. The paper’s Theorem 5.11 makes a general solver of this kind equivalent to P = NP only if it is an integrable encoding of SAT, which is open. Proposition 5.13 makes black-box search cost the whole volume of the tree, for any method. The boundary chart lays out what the experiments can and cannot decide.
System map
Every part of the project and what feeds what, from the sources on the left to the pages and code on the right. Hover a box to light up its connections; click it for a description, its source in the paper or the code, and a link to the explainer that covers it.
Solid boxes exist now: the sources, the existing tri-engine pages, the preregistration and everything built in the Python reference (the step, the channels, pairing and memory, Helix B and the decoders). Dashed boxes are designed or planned and not built yet. Each explainer opens with a smaller chart of the same kind, centred on its own topic, so you can always see where you are.
Explainer library
Every part gets a full explainer. Four cover the design; four cover the reference, the browser core, the simulation, and the proofs and results, each written when its module landed. The ninth and tenth cover version 2.
Written
1 · The hyperbolic step
polystep’s step, then the same step on the hyperboloid: geodesic vertices, exact rational lifts, the Klein centroid. A live Poincaré and Klein diagram, the correspondence with polystep’s code, and the seven properties H1–H7 with proof sketches.
2 · Three channels on the zero-point clock
How one solver step rides one 12-frame packet, the 24-frame schedule of the three channels, pairing and Helix B at the zero point, the clutch and membrane, and the pump over each 720-frame register.
3 · Problems, benchmarks and the boundary
The four problem decoders, the preregistered benchmarks with budgets and decision rules fixed in advance, and the chart of what the results can and cannot decide.
4 · Build and verification
How the Python reference, the browser core and the page are built and checked against each other, the four arithmetic tracks, and the test plan for every phase.
5 · The Python reference
The Phase 1 implementation: installing and running it, a map of its modules, using the step, what its 80 tests check, three findings from building it, the traces for the browser, and the benchmark runner.
6 · The browser core
The Phase 2 port: a live parity check against the reference’s traces in your browser, three channels running in the page, the rules that make two languages agree, and every part of hyperbolic_core.js.
7 · The simulation manual
The Phase 3 page: how it is wired to the core, every control, panel and readout, the exact track and its register pump, seven experiments with links that open them, and how to read one run honestly.
8 · Proofs and results
The Phase 4 page: full proofs of Lemma S and H1–H7, each checked live with controls that must fail; the reduction of T1, with a live theory-mode run; and the preregistered benchmarks, every cell and decision, before and after Amendment 3.
9 · The 3D decoder
Version 2, phase A. Points of H³ become answers through one exact primitive, the anchor decoder: live in a 3D Poincaré ball, with D1–D5 proved. The norm-5 tree in H³ has exact frames (τ = ln 7) and a proof that greedy decoding returns every node. Also the version 2 design.
10 · Frames and the coupler
Version 2, phases B–D, and the manual of the 3D simulation. Frames carried exactly by transvections; a twist is the area of a triangle; spin kept by quaternions; the mirror law that binds two structures (B = q₂q₁ never changes); carry mode invisible to the six calculations.
Roadmap
Six phases. Each ends with its code, its explainer, its node on the map moved from dashed to solid, and its tests passing.
| Phase | Delivers | Done when | Status |
|---|---|---|---|
| 0 · Scaffold | This hub, the system map, four explainers, the preregistration, the reference skeleton; the calculator’s build sources moved into the repository (scripts/geometric-build/) | The pages render, every link resolves, the build reproduces every existing page byte for byte | done |
| 1 · Python reference | reference/: the hyperbolic step on polystep’s rotations and solvers, the Euclidean baseline from polystep itself, exact checks of H1–H7, seeded traces, benchmark runners | H1–H7 pass in exact arithmetic on random instances; traces written; the reference guide written | done |
| 2 · JavaScript core | hyperbolic_core.js on the existing exact core: float search, exact certificates | Every trace line matches the reference; the core reference written | done |
| 3 · Simulation page | simulation.html on the browser core: three channels live on the zero-point clock for all four problems, Poincaré view, cost traces, clutch and membrane, the exact register pump, Helix B certificates, an on-load self-test, settings by address | Opens paused; self-test passes; phone layout clean; the simulation manual written | done |
| 4 · Proofs and results | Full proofs of Lemma S and H1–H7 with live checks; the preregistered benchmarks run as registered under Amendments 2 and 3 (7,740 runs), with their decisions | Every row of the claims ledger carries its final status | done |
| 5 · Integration | Site bar, cross-links from the paper explainer and the tri-engine pages, documentation | The bar test passes on every page | next |
Version 2 · three dimensions, two structures bound by a coupler
Version 2 moves the search into H³. It runs two structures of three engines each, six calculations in all, bound by a coupler that turns the particles’ frames (orientation and spin) and never their positions. The coupler takes the twist one structure accumulates and applies its inverse to the other, both ways, so the pair’s net twist stays the identity. A switch selects steer (frames choose the next polytope rotation) or carry (frames are transported and never fed back). The full picture is in Explainer 9, the proofs and manual in Explainer 10, and it runs live in the 3D simulation.
| Phase | Delivers | Done when | Status |
|---|---|---|---|
| A · 3D decoder | Anchor decoders (exact on floats), the octahedral norm-5 tree in H³ with exact frames (τ = ln 7), the four problems in H³ with Helix B | D1–D5 and E1–E3 proved and checked live; the browser port matches the reference’s trace | done |
| B · Frame layer | Quaternion frames carried by transvections: exact, with no square root; a twist is a triangle’s area | F1, F2 and S proved and checked live | done |
| C · Coupler | The twist ledger with the steer/carry switch | The binding B = q₂q₁ checked exactly at every zero point; in carry mode the six calculations are bit-identical to a run without the coupler (K1–K3) | done |
| D · Two structures | Two tri-channels in H³, each with its own clock and memory chain | Both memory chains intact, a third for the coupler; the browser matches the reference’s exact twin trace, 21/21; the 3D simulation | done |
| E · Preregistered runs | A new preregistration with controls: coupler off, carry only, a deliberately non-inverse transfer, gauge changes on one structure only | Every cell reported with its decision | next |
Claims ledger
Every claim the project will make, its status now and where it is settled. Tags follow the papers: PROVEN ESTABLISHED CONJECTURAL OPEN, plus DESIGN for a proof sketched here whose full proof and test come later.. The preregistered claims end SUPPORTED, REFUTED or MIXED by the rules fixed in advance.
| # | Claim | Status now | Settled in |
|---|---|---|---|
| H1 | Every vertex, probe and snapped state lies exactly on the hyperboloid | PROVEN | Full proof and live exact check (Phase 4); exact on 1,000 instances in the reference (Phase 1) |
| H2 | One step moves at most the step radius: d(x, x′) ≤ r | PROVEN | Full proof via Lemma S and the Klein chart, including block moves and the horizon; live check (Phase 4); 1,600 steps in the reference (Phase 1) |
| H3 | The Lorentzian centroid is the unique minimiser of the weighted squared Lorentzian distance | PROVEN | Short proof from Lemma 0 (also Law et al. 2019); live check (Phase 4) |
| H4 | The step commutes with hyperbolic isometries | PROVEN | Full proof for orientation-preserving isometries, in law for Haar rotations; live check (Phase 4). Not claimed for the horizon or the snap |
| H5 | As the curvature goes to 0 the step becomes polystep’s Euclidean step | PROVEN | Full proof for continuous objectives; live check of the limit and of the flat step (Phase 4); polystep’s own step matched (Phase 1) |
| H6 | As ε → 0 the step goes to the best vertex; keeping the best seen never increases the incumbent cost | PROVEN | Full proof with the bound (2d − 1)e−Δ/ε; live check (Phase 4) |
| H7 | Each step’s displacement is a rational Lorentz map, so the pump returns H = P⁻¹ exactly over every register | PROVEN | Full proof; the check certifies the bookkeeping, and controls show it fails on swapped or corrupted increments (Phase 4); live on every register of the simulation’s exact track (Phase 3) |
| T1 | polystep’s convergence theorem carries over to the hyperbolic step under its theory-mode conditions (power-decay radius, flat ε, probe jitter) | OPEN | Reduced, not settled (Phase 4): by Lemma S, each step is polystep’s step on the pulled-back objective, shortened by 1 − O(r2). What remains is checking that polystep’s proof is local and robust to that shortening. Details and a live theory-mode run |
| C1 | On tree-structured problems the hyperbolic step beats the Euclidean step at equal evaluation budget | REFUTED | Preregistered runs (Phase 4): 0 of 13 cells supported, 12 refuted, 1 inconclusive. B1 sits at a success floor; curvature 0 finds B3’s targets far more often. Results |
| C2 | Hyperbolic depth acts as built-in annealing: steps of a fixed hyperbolic radius shrink in Klein coordinates as a channel commits | SUPPORTED | Supported in all 12 cells of B1 and B2, Spearman −0.88 to −0.95 (Phase 4, after the Amendment 3 fix) Results |
| C3 | Three channels on the 24-frame schedule beat one channel with three times the particles at equal budget | REFUTED | Refuted in all 9 B1 cells (8 of them floors); final conflicts show no advantage for three channels (Phase 4) Results |
| L1 | A general solver of this kind decides SAT in polynomial time only if P = NP | PROVEN (paper Thm 5.11) | Cited, not re-proved |
| L2 | Against a membership-only objective no method beats the volume of the tree | PROVEN (paper Prop 5.13) | The B3 control passes for every method at every depth: random search lands at about (N + 1)/2, and nothing beats it (Phase 4) |
| L3 | P versus NP | OPEN | Not addressed by any result here |
| D1–D5 | Version 2’s anchor decoders on H³ are the same in every radial chart (D1), exact on every float (D2) and permuted by their symmetry groups (D3). Every answer has an equal share (D4), and global axis rotations leave B1’s conflicts unchanged (D5) | PROVEN | Proofs and live checks with controls in Explainer 9; 26 reference tests; parity 28/28 (v2 phase A) |
| E1–E3 | The norm-5 tree in H³ has exact rational frames (E1). Greedy decoding returns every node at every depth when t > 1/√2 (E2). Helix B certifies the decoded word (E3) | PROVEN | Half-space proof in Explainer 9; exact round trips of all nodes to depth 4 and random ones to depth 9; below the threshold (t = 2/3, 1/2) decoding fails, as the controls show |
| F1, F2, S | Frames in H³ are carried exactly by the transvection, a product of two Lorentz reflections and rational for rational points (F1). A move’s twist is a rotation by the area of the triangle (o, x, y) (F2). Composing quaternions keeps the spin (S) | PROVEN | Proofs and live checks with controls in Explainer 10; reference tests; exact twist parity (v2 phase B) |
| K1 | The coupler’s mirror law (q₁ ← wq₁, q₂ ← q₂w⁻¹) keeps every pair’s binding B = q₂q₁ at the identity, in both directions and both modes | PROVEN | Exact at every zero point of exact runs; without the mirror it breaks, as the control shows (v2 phase C) |
| K2 | In the coupler’s carry mode the six calculations are bit-identical to a run without the coupler | PROVEN | Proof in Explainer 10; checked bit for bit on the float and exact tracks (v2 phase C; formerly design row I1) |
| K3 | Steering keeps the exact track exact: rotations orthogonal, states on the sheet, every register’s pump closing | PROVEN | Reference tests and the exact twin trace, 21/21 (v2 phase D) |
| K4 | Steering two structures through the coupler improves their search | OPEN | Not claimed; for a preregistered round (v2 phase E) with the controls built in: off, carry, no mirror |
How the folder grows
Every module added here ships with five things, so the explainers and charts stay complete.
- The code, in
reference/(Python) or beside this page (browser). - A full explainer in
explainers/, built onassets/hp.css, opening with its focused chart (<div data-hp-map="focus" data-node="…">). - A node on the system map in
assets/hp-map.js, with its edges and its explainer. Every chart in the folder updates from that one list. - A row in the claims ledger for anything it claims, with a status tag.
- Tests, and a line in the folder’s
README.md.
The folder layout:
| Path | Holds |
|---|---|
| index.html | This hub |
| explainers/ | One full explainer per topic |
| assets/hp.css, assets/hp-map.js | Shared style; the system map data and its chart renderer |
| reference/ | The Python reference (Phase 1) |
| README.md, PREREGISTRATION.md | The plan and file map; the benchmarks fixed in advance |
Glossary
- Hyperboloid
- The points with \(-t^2 + |x|^2 = -1,\ t > 0\): a model of hyperbolic space in which isometries are Lorentz matrices.
- Poincaré ball
- Hyperbolic space drawn in the unit ball, angles true, geodesics circular arcs. Used for pictures.
- Klein model
- The same space in the unit ball with straight geodesics. Used for the centroid, which becomes a convex combination.
- Ghost map
- The paper’s rational map from the ball to the hyperboloid, \(G(p) = ((1+|p|^2),\,2p)/(1-|p|^2)\).
- Particle
- One candidate solution being improved (a point, or a vector of parameters).
- Polytope, vertices, probes
- The candidate set around a particle: corners of a rotated orthoplex at the step radius, and probe points along each direction.
- ε (temperature)
- How sharply the weights favour low-cost vertices: small ε picks the best corner, large ε averages.
- Channel
- One of three particle populations, on one of the three 120° branches of the clock.
- Packet
- The 12 frames from a branch’s onload to its offload; it carries one solver step.
- Helix A / Helix B
- The proposer (the solver) and the exact certifier, as in the paper’s machine model.
- Register
- 720 frames; at its end the pump evaluates the holonomy of each channel’s exact trajectory.