BTW Abelian sandpile

Every critical point the lab had met (Ising, percolation, logistic, Kuramoto, standard map) required tuning a knob to one magic value. Does a driven dissipative pile really tune ITSELF to a critical state — and does it land on the exactly-known critical density 17/8, measurable from the toppling rule alone with nothing to plug in?

Units: grains per site, heights 0..3 (17/8 exact; 25/8 in the 1..4 convention)

▶ Run this simulationRead how it works

The finding

BTW Abelian sandpile — self-organized criticality weighed exactly, and now the SCREEN is the instrument that weighs it: with NOTHING coded but the integer toppling rule, the shipped module's own interior-window readout states ⟨z⟩ bulk = 2.1251 against the proven 17/8 = 2.125 and P(0) = 0.0733 against Majumdar–Dhar's 2/π² − 4/π³ = 0.0736, live, at seed 7 — the oracle's quadratic-1/L intercept independently recovers 2.124489 ± 0.000402 (rel 2.4e-4, 1.3 SE), the boundary-depletion law holds at 63σ, Dhar's Abelian property is verified grain-for-grain, and the maximum-entropy rival (⟨z⟩ = 1.5, P(0) = 0.25) is falsified at 389/293 SE — with no knob tuned anywhere

Method

Bare BTW substrate in integer arithmetic: L×L grid, drop a grain on a uniform random site, any site reaching 4 topples (sheds its full excess t = ⌊h/4⌋, t to each neighbour), off-edge grains lost; heights 0..3 between drives. Per seed (6 mulberry32 seeds) and per L ∈ {32, 48, 64, 96, 128}: warm up 6L² drives to stationarity (prototype showed plateau by ~4L²), then time-average the full-lattice density over 30L² further drives (O(1) per drive via an incrementally tracked grain count). PRIMARY estimator = per-seed quadratic-in-1/L intercept of ρ(L), mean ± SE over seeds — the 1/L term IS the open-boundary depletion (perimeter/area), and the prototype showed the bare linear fit is curvature-biased by ~5e-4 (4.3σ) while the quadratic intercept is unbiased (1.3 SE); estimator lesson #1 (fit the correction the physics predicts) applied at design time. Cross-checks at L = 128: interior-window (margin 32) mean and zero-height fraction from 120 snapshots spaced 4096 drives (lag-1 autocorrelation 0.09 — effectively independent). Substrate gates are integer-exact: grain conservation residual ≡ 0, and Dhar's Abelian theorem verified operationally (LIFO stack vs FIFO queue relaxation of the identical 15360-drop sequence ends in the identical configuration). 12 gates in scripts/sandpile-derisk.mjs (~32 s); 17/8 and 2/π² − 4/π³ live in scripts/oracles/sandpile.reference.json, loaded ONLY to score; tamper ⇒ exit 1. ?world=sandpile.

Measurements, controls & cross-checks

Recovered se

0.000402

Bulk window cross check

Value

2.124515

Se

0.000248

Rel error

0.000228

Note

independent second estimator (L = 128 interior window, margin 32; boundary deviations decay ~ r⁻²) with different systematics agrees with both 17/8 and the sweep intercept; its small negative residual (−2.3e-4 rel) is the disclosed remaining boundary bias

P0 exact

Measured

0.07374

Se

8.3000e-5

Known

0.07363623

Rel error

0.0014

Note

P(height = 0) = 2/π² − 4/π³ (Majumdar–Dhar 1991) — a SECOND exact constant, containing π, emerging from pure integer dynamics; the +1.4e-3 residual matches the expected window boundary bias (near an open edge, low heights are over-represented)

Perturbation

Rho by L

32

2.08327

48

2.09679

64

2.10331

96

2.11035

128

2.11393

Slope b

-1.304

Slope se

0.021

Slope sigma

63.3

Deficit ratio 32 128

3.77

Note

the full-lattice deficit 17/8 − ρ(L) is boundary dissipation ∝ perimeter/area: ρ strictly increasing in L, 1/L slope negative at 63σ, deficit(32)/deficit(128) = 3.77 vs the 1/L law's 4 (the shortfall is the same 1/L² curvature the quadratic intercept absorbs)

Substrate exact

Conservation

on-grid = added − lost, residual exactly 0 (integer) in every one of the 30 runs

Abelian

Dhar's theorem checked operationally: LIFO vs FIFO relaxation orders on the identical drop sequence produce the identical final configuration grain-for-grain (15360 drops, L = 32)

Rival maximum entropy

Prediction mean

1.5

Prediction p0

0.25

Rival measured

⟨z⟩ = 1.4996 (z = 0.2), P(0) = 0.2504 (z = 0.6) — the same window machinery applied to iid-uniform stable configs lands on the rival's own numbers, so nothing is baked in

Separation se

Mean

389

P0

293

Note

the natural pre-Dhar null — every stable configuration equally likely — fails by ~400 SE on both observables; the stationary measure is uniform over the RECURRENT subset only (Dhar 1990), and that selection alone lifts 1.5 → 17/8 and cuts 1/4 → 0.0736

Module certificate

Gates

L–Q, on top of the physics gates A–H and the two new screen-science gates I–K (21/21 in ~48 s; run `npm run derisk -- sandpile`)

What was executed

The shipped file, not a description of it: src/modules/SandpileModule.ts sha-pinned (a86b3aad193e…), 56 mechanical type-strip pairs each asserted to hit exactly once plus an empty TS-residue scan, loaded via `new Function` against recorder stubs for the Babylon/DOM surface. Gate M pins the EXECUTED init at seed 7 (empty grid, all three 147456-float thin-instance buffers, pitch/cell, three emissive-PBR meshes at thinInstanceCount 0, camera, environment dimming, and the panel/chart/style bytes) bit-exact against an independent hand replica and sha pins. Gate N runs 600 calls at fl(1/120) comparing the whole grid, every counter, the 28 log-bins, τ, the accumulator, all three buffers and all 100 HUD/chart writes at EVERY call. Gate Q pins the teardown.

Clock

An accumulator is present (TICK_DT = 1/60, a guard of 3 ticks, an overflow reset) and carries NO residual: fl(1/60) is EXACTLY 2·fl(1/120) (asserted by Object.is), so a tick lands on every 2nd engine call — census {0:300, 1:300} over 600 calls — and the accumulator is exactly 0 at the end. Gate O executes the branches a real frame never reaches: dt = fl(1/60) twin (200 calls bit-exact, census {1:200}), dt = 0 ×120 (grid, relaxation count and accumulator frozen), dt = 999 ×1 (the guard-3 clamp runs 3 ticks = 1,393 drops and the overflow guard resets acc to 0).

Free invariants

Three hold at every one of the 600 calls, and they are the module's own claims rather than added assertions: grain conservation is integer-exact (on-grid = added − lost, residual 0 — the number the HUD prints); every height is ≤ 3 (the configuration is stable between drives); and onGrid ≡ n₁ + 2n₂ + 3n₃ over the three instance buffers — the picture IS the number, so a render bug cannot hide behind a correct counter. The relaxation stack peaked at 195 of its L² = 9216 slots, so the dedup marker's bound is not merely argued.

Closure

Zero instrument gap on the headline: the estimator the screen prints is the de-risk's own gate-D estimator (interior window, margin = L/4) — same window rule, same fixed-drive cadence — measured here at every L of the sweep (gate J) and compared to the executed screen at two sizes (gate P).

Tampers

Six module tampers plus the reference tamper, all exiting 1 with surgical blast radii and the physics gates A–K untouched where they should be (21 gates total): sha (one byte appended to the source before hashing) ⇒ gate L only, 20/21 green; cadence (revert the window snapshot to the block-end rule this run retired — statistically the SAME physics, only the sampling moment moves) ⇒ N at call 4 (`snaps`) + P, with every physics gate green and the screen quietly reading ⟨z⟩ bulk 2.1229 instead of the certified 2.1251 — the exact −0.0013 bias gate K measures; margin (BULK_MARGIN_FRAC 0.25 → 0.2) ⇒ N at call 4 (`bulkSum`) + P; budget (TOPPLE_BUDGET 160,000 → 159,000 — a scheduling change, not a physics one) ⇒ N at call 4 (`h@30`) + O + P; hud (one character in the HUD guide text, '2.125' → '2.1250') ⇒ N at call 1 (`hud`) + P; topple (shed one unit at a time instead of the full excess t = ⌊h/4⌋ — identical except in the rare cascade where a site reaches h ≥ 8) ⇒ N at call 18 (`p0Sum`) + O + P, while the displayed bulk value barely moves (2.1243 vs 2.1245), which is precisely why a lockstep and not a plausibility check is required. Reference tamper: known_value 2.125 → 2.225 by hand ⇒ five gates fail (A, C, D, F3 and J — every gate that scores against the constant) with the recovered 2.124489 ± 0.000402 byte-unchanged, so the scorer really reads the reference rather than a duplicated literal; the file was restored by hand and diffed byte-identical.

Module systematics

The cadence bias found and fixed

The module used to snapshot its interior window at the END of each 160,000-toppling block. That moment is not neutral: the avalanche that crosses the budget is drawn SIZE-BIASED (in proportion to its own size), so the interior it has just flattened reads low. Gate K measures it on the same trajectories with both rules: block-end ⟨z⟩ 2.12345 vs fixed-cadence 2.12474, Δ = −0.00128 ± 0.00010 (12.3σ), persistent across halves (not a warm-up transient). The module now samples every 64 drives; the old rule is kept as a falsifiable control gate.

Lattice vs bulk

The full-lattice mean can never be 17/8 at finite L — open-boundary dissipation depletes a layer ~perimeter/area. The screen states this instead of implying convergence: at L = 96 its lattice line reads −0.61% below 17/8 and at L = 48 −1.62%, matching this oracle's own ρ(L) sweep (2.11035 / 2.09679, gate F) rather than the known value.

Window residual

The bulk estimator keeps a residual boundary bias that shrinks with the grid: 2.54e-3 rel at L = 32 (a 16×16 window) → 1.05e-3 at L = 48 → 2.57e-4 at L = 96. Gate J requires the shrink (≥ 2×, measured 9.9×) and scores the two certified sizes within 2e-3 rel.

Tau is effective not exact

The displayed slope is an EFFECTIVE fit over s ≤ 0.3L², and the module now says so on screen. Measured with one estimator across the sweep it drifts upward with size — τ_eff(L) = 1.0628 → 1.0681 → 1.0737 → 1.0817 → 1.0890 for L = 32…128, +0.0131 per doubling (gate I) — and with the fit window (1.078 → 1.088 as the upper cut goes 0.15 → 0.6 L²). So the 1.08 on screen is a size- and window-limited effective slope, well below the literature asymptotic τ_s ≈ 1.27, and no claim is made that it is an exact exponent.

Screen vs oracle

Gate P: the executed module's four displayed numbers over seeds 7/8/9, against THIS run's own per-L measurements (never against 17/8). L = 96: lattice 2.1120 vs 2.1104 (+0.0016), bulk 2.1242 vs 2.1245 (−0.0002), P(0) 0.0735 vs 0.0735 (+0.0001), τ 1.0833 vs 1.0817 (+0.0016). L = 48: lattice 2.0907 vs 2.0968 (−0.0061), bulk 2.1221 vs 2.1228 (−0.0007), P(0) 0.0737 vs 0.0737, τ 1.0700 vs 1.0681 (+0.0019). Every displayed number moves with ?seed= (lattice spread 0.0040 at L = 96 — it is an instantaneous snapshot of a fluctuating sum, not a constant).

Certified screen

seed 7, 600 calls at fl(1/120), L = 96: '⟨z⟩ lattice 2.112 (open edge depletes it ∝ 1/L)' · '⟨z⟩ bulk 2.1251 (→ 17/8 = 2.125)' · 'P(0) bulk 0.0733 (→ 2/π²−4/π³ = 0.0736)' · 'slope τ 1.08 (effective, s ≤ 0.3 L²)'; twin seed 9 shows '⟨z⟩ bulk 2.1228' — the digits move, so the screen is a measurement.

What it reduces to

The exactly-known stationary height statistics of the 2-D Abelian sandpile: mean height 17/8 (Grassberger's conjecture, computed via Priezzhev's 1994 height probabilities and PROVEN by Poghosyan–Priezzhev–Ruelle 2011 through the loop-erased-random-walk return probability; independently by Kenyon–Wilson) and P(0) = 2/π² − 4/π³ (Majumdar–Dhar 1991, exact via the spanning-tree correspondence). Non-circular by construction: the generator is the bare integer toppling rule — no measure, no Green function, no π, no 17/8 anywhere in the recovery path; the constants are properties of the recurrent-set combinatorics that the DYNAMICS must find on its own, and they are loaded from the reference only to score. Non-circularity is additionally checked in-script: the rival gate proves the identical measurement machinery returns 1.5/0.25 on a different measure, and the tamper self-test proves the scoring actually bites. This is the lab's FIRST exactly-validated self-organized-criticality result — unlike ising/percolation/logistic/kuramoto/stdmap, where the lab had to DIAL a parameter to the critical value, here the criticality is an attractor of the driven dynamics itself: the 'tuning' is done by the pile, and the lab only verifies where it lands (17/8, with no knob in the entire model).

Module systematics

The module (?world=sandpile, src/modules/SandpileModule.ts, untouched this run) is honest at its core: the on-screen mean density is a REAL measurement of the live pile (incrementally tracked grain count, same convention 0..3 as the oracle), conservation is displayed as an exact integer residual, and the same mulberry32 PRNG family drives both. Disclosed systematics: (1) at the default grid L = 96 the on-screen stationary density reads ≈ 2.110, i.e. −0.7% below 17/8 — this is NOT an error but exactly the oracle's boundary-depletion law: 2.125 − 1.304/96 = 2.1114, within noise of the sweep's measured ρ(96) = 2.11035; the screen shows the finite-L value, the oracle extrapolates the L → ∞ constant. (2) The on-screen avalanche exponent τ ≈ 1.1 is an effective log-log slope over the scaling window; the 2-D BTW size distribution is multifractal (no single clean exponent exists), which the module itself discloses in its header comment and is why τ is NOT an oracle gate — the exact constants 17/8 and 2/π² − 4/π³ are.

Notes

0 retries — 12/12 gates on the first full run (~32 s), scratchpad-prototype-first recipe (2 prototype scripts before authoring). The estimator trap caught at design time: the bare linear 1/L extrapolation of ρ(L) is curvature-biased by −5e-4 (4.3σ with 6 seeds) — the quadratic intercept absorbs the 1/L² term and lands 1.3 SE from 17/8 (estimator lesson: fit the correction the physics predicts, like blackbody's cubic-vs-quadratic vertex). Tolerances itemized from prototype SEs plus disclosed bias bounds, never padded (tolerance.note in the reference). Manual tamper test: known_value 2.125 → 2.155 ⇒ gates A/C/D/F3 FAIL, exit 1, recovered value unchanged (2.124489); restored by hand. Module untouched → gate = build + derisk only, per the ROUTINES table.

Confidence & reproduction

Confidence

high

Validation

derisk-pass

Re-run the check

npm run derisk -- sandpile (scripts/sandpile-derisk.mjs)

Oracle

scripts/oracles/sandpile.reference.json

Sources

P. Bak, C. Tang, K. Wiesenfeld, 'Self-organized criticality: an explanation of 1/f noise', Phys. Rev. Lett. 59, 381 (1987); D. Dhar, 'Self-organized critical state of sandpile automaton models', Phys. Rev. Lett. 64, 1613 (1990); S. N. Majumdar, D. Dhar, 'Height correlations in the Abelian sandpile model', J. Phys. A 24, L357 (1991); V. B. Priezzhev, 'Structure of the two-dimensional sandpile. I. Height probabilities', J. Stat. Phys. 74, 955 (1994); V. S. Poghosyan, V. B. Priezzhev, P. Ruelle, 'Return probability for the loop-erased random walk and mean height in the Abelian sandpile model: a proof', J. Stat. Mech. (2011) P10004.