Proof · run it yourself
Run the QUMOND proof yourself
The rigorous solve behind the Galaxy Sandbox — clone it, run one command, watch it self-verify.
The Galaxy Sandbox is a fast, honest algebraic-MOND toy. This is the real thing it points to: mond-nbody, a from-scratch QUMOND particle-mesh N-body solver with isolated boundary conditions, where the particles source their own gravity. It doesn't ask you to trust a screenshot — it ships as code that runs in seconds and checks itself, printing measured gate results and exiting non-zero if any gate fails. Below: complete instructions from an empty machine, and — so you can see the exact terminal output before committing a single command — a live replay of a real run, played back from prerendered data at $0 of compute per visit.
From an empty machine to a green run
Three steps. You need Python 3.9+ and one dependency — NumPy. Nothing else: no build, no GPU, no accounts. (NumPy is the one exception to the rest of the proofs, which are standard-library only — an FFT Poisson solve is the reason, and it's stated here rather than hidden.)
Get the code
Clone the repository (recommended — you get every proof), or download just this folder.
# clone the repo, then step into the proof
git clone https://github.com/ajgreyling/congosky-cloud.git
cd congosky-cloud/the420code/proofs/mond-nbody
No git? Install it (brew install git on macOS,
sudo apt install git on Debian/Ubuntu, or
git-scm.com/downloads), or use the ZIP tab.
# download + unzip the whole repo, then step into the proof
curl -L -o congosky-cloud.zip https://github.com/ajgreyling/congosky-cloud/archive/refs/heads/main.zip
unzip congosky-cloud.zip
cd congosky-cloud-main/the420code/proofs/mond-nbody
Or click Code ▸ Download ZIP on the GitHub page and unzip it by hand.
The proof lives at the420code/proofs/mond-nbody/.
Install the one dependency
A clean virtual environment keeps NumPy off your system Python. This is the whole install.
# create + activate a venv, then install NumPy python3 -m venv .venv . .venv/bin/activate # Windows: .venv\Scripts\activate pip install numpy
Prefer not to make a venv? pip install --user numpy works too.
The GPU (mlx) path is picked up automatically only if present — it is never required.
Run it — it verifies itself
One command. It settles the disk under QUMOND, Newton, and “a₀ off”, measures the three gates from the simulation, prints the table you'll see replayed on the right, and exits non-zero if anything fails.
# the demo gates: G=64, N=200k, < 60 s on a laptop CPU python3 demo.py # force the CI/CPU path explicitly (skip GPU autodetect) NBODY_BACKEND=numpy python3 demo.py # the big one: G=256, N=2M, long settle (uses mlx GPU if present), # and re-bakes the prerendered data this page replays python3 demo.py --showcase
Measured on an Apple M4: demo 9.9 s on NumPy, 6.7 s on the mlx GPU path. You should see PASS and every gate marked pass.
See it run first — a real run, replayed
This is not a live simulation and it is not a mock. It is the exact output a real
demo.py run printed (NumPy backend, Apple M4), replayed byte-for-byte,
with the rotation curve and disk evolution drawn from the prerendered data the showcase
run bakes. No Python runs in your browser, no CDN loads, nothing is fetched — so it costs
nothing to serve and works offline. Press a button to watch it play.
Rotation curve — v(r), from the field
The three gates
Prerendered once on the compute box (QUMOND isolated-BC particle mesh, one idealized exponential disk); replayed here for $0 per visit. NOT a fit to any real galaxy.
What a green run proves — and what it does not
It proves: a from-scratch QUMOND particle-mesh solver with isolated boundary conditions produces, for one idealized self-gravitating disk, a flat outer rotation curve where Newtonian gravity on the same disk produces a declining one — with the deep-MOND normalization in the expected place and a clean Newtonian limit. That is a solver-correctness demonstration.
It does not prove anything about real galaxies. This is a fixed-baryon QUMOND relaxation of one idealized disk — not galaxy formation, not hydrodynamics, not a fit to any real galaxy, not validated against SPARC per-object. The ν-function is a stated modelling choice. Serious MOND N-body work (Phantom of Ramses / RAyMOND) sets the real bar; this is a pedagogical build. Consistency, not proof. The full honest register is in the proof README.
What the gates check
- Gate 1 — flat curve, contrast, survival. The QUMOND circular-speed curve is flat to < 15% RMS; the same disk under Newton must fail that and decline (the contrast is the result); and the disk must structurally survive its settle, checked from the particles, not the field.
- Gate 2 — BTFR normalization. V_flat⁴ / (G·M·a₀) lands within 25% of 1 — the deep-MOND value — converging from above as the finite outer radius expects.
- Gate 3 — Newtonian limit. Turn a₀ effectively off and the same full pipeline must give a Keplerian-declining curve, so “MOND flatness” can't be a bug that flattens everything.
The thresholds are written in demo.py ahead of the numbers and
everything is computed from the simulation — nothing hardcoded. (Honestly: gates and results
live in the same tree, so this isn't “pre-registered” — only that you can reread and rerun both.)