diff --git a/404.html b/404.html
index dc168ad..d4f57f6 100644
--- a/404.html
+++ b/404.html
@@ -90,7 +90,7 @@
Not on the map
Source code under the Apache License 2.0.
diff --git a/README.md b/README.md
index 627d845..24e9509 100644
--- a/README.md
+++ b/README.md
@@ -358,7 +358,8 @@ nobody tunes: the flow's Reynolds number, or the time gravity has had to act, se
smooth on the largest scales, as the [opening section](#where-the-intuition-holds-and-where-it-breaks) describes).
Real fluids have the same mechanism with three-dimensional exponents: ξ grows 4.27-fold for each tenfold approach
to T_c (ν = 0.630; Kos, Poland, Simmons-Duffin and Vichi 2016), against tenfold for the 2D lattice. `npm test`
-checks the study against the exact results (`tests/critical.mjs`).
+checks the study against the exact results and, for percolation at finite sizes, against Ziff and Newman's
+measurements (`tests/critical.mjs`).
Mistakes found along the way are in [CORRECTIONS.md](CORRECTIONS.md). Open questions are the
[issues](https://github.com/Foundation-0/fractals/issues).
diff --git a/critical/README.md b/critical/README.md
index 4d72ded..4b5d696 100644
--- a/critical/README.md
+++ b/critical/README.md
@@ -4,11 +4,16 @@ Notes for [issue #20](https://github.com/Foundation-0/fractals/issues/20). Explo
result claimed. `node critical/table.mjs` (about 65 s) prints the Monte Carlo numbers below, the percolation ones
for each of nine seeds and as their mean. No script prints three kinds of number: the results of a one-off repeat
of the checks with 120 other sets of seeds, described under [What it reproduces](#what-it-reproduces); γ/ν's
-finite-size bias of +0.0012, worked out from a published formula; and the 11% and 25% uncertainties of an error
-bar. `npm test` (`tests/critical.mjs`) checks the numbers compared with an exact value: the table under "What it
-reproduces", the ξ table, the measurement-trap cumulants and the same numbers in the short answer. The rest are
-printed but not checked: the slopes over other ranges of L, the cluster shares, the size ratios and each
-percolation seed's results. Exact values are quoted from the sources named beside them. Started 18 October 2026.
+finite-size bias of +0.0012 and the Binder cumulant's offset of 0.0007 at L = 16, worked out from published
+results; and the 11% and 25% uncertainties of an error bar. `npm test` (`tests/critical.mjs`) checks the numbers
+compared with an exact value: the table under "What it reproduces", the ξ table, the measurement-trap cumulant with
+a fixed count and the same numbers in the short answer. It checks the cumulant measured the other way only against
+that one, and the point where the spanning probability at L = 32 is one half against Ziff and Newman's measurement
+there. Without Monte Carlo, it also checks the open-edge shift against their measured crossings for L = 64 to 256.
+The rest are printed but not checked: the slopes over other ranges of L, the cluster shares, the size ratios, the
+point where the spanning probability at L = 256 is one half, the other comparisons with Ziff and Newman's
+measurements and each percolation seed's results. Exact values are quoted from the sources named beside them.
+Started 18 October 2026.
The other studies find self-similarity over a range of scales and ask where it stops. This one asks why it appears
at all, in the one case where the exact answers are known and both ends of the range can be moved at will.
@@ -52,12 +57,16 @@ r^(−1/4), a power law, which looks the same at any magnification. Patches cont
smaller ones.
The renormalisation group gives the reason and its consequences (for a review, Pelissetto and Vicari 2002). Replace
-each block of spins by one spin, and the lattice looks coarser. At T_c the coarse lattice has the same statistics
-as the fine one: the critical point is a fixed point of this zooming out. Away from T_c each step of zooming out
-carries the effective temperature further from T_c, so a small mistuning t = (T − T_c)/T_c is invisible on short
-scales and takes over at ξ ∝ |t|^(−ν). The lattice's details fade with every step. That is why the exponents are
-universal: they are the same for every model with short-range forces, the same symmetry and the same number of
-dimensions.
+each block of spins by one spin, and the lattice looks coarser. At T_c the coarse lattice's large-scale statistics
+are those of the fine one; only the lattice-scale details differ, and they fade with every step. So the lattice at
+T_c is not itself a fixed point of this zooming out, but repeated zooming out carries it to one, which looks the
+same at every scale. Away from T_c each step of zooming out carries the effective temperature further from T_c, so
+a small mistuning t = (T − T_c)/T_c is invisible on short scales and takes over at ξ ∝ |t|^(−ν). Because the
+details fade, the exponents are universal: they are the same for every model with short-range forces, the same
+symmetry and the same number of dimensions. At the sizes modelled here finite size still shows. The susceptibility
+has a non-universal part set at short distances, its analytic background, which does not fade: the critical part
+outgrows it, as L^(7/4). That background, more than the fading details, shifts the Binder cumulant at L = 16 and
+γ/ν a little. Corrections to scaling lower the measured percolation dimension. All three are described below.
An Ising magnet has two settings to tune: the temperature, to T_c, and the magnetic field, to zero. Percolation has
one: the fraction p of occupied sites, to p_c = 0.592746 on the square lattice (Newman and Ziff 2000). At p_c the
@@ -86,7 +95,7 @@ Werner 2001). The square lattice is expected to share it, by universality.
the top and the bottom row. Averages at any p follow by weighting each number of occupied sites binomially. The
runs are made with nine independent seeds, and the checks use their mean.
- **Random numbers.** `xoshiro128**`, seeded, integer arithmetic only. The same seed gives the same numbers on
- every engine; the checks print identical values on Node 18 and 22, so they cannot flake.
+ every engine; the checks print identical values on Node 18, 20 and 22, so they cannot flake.
- **Error bars.** One standard deviation, from a jackknife over 40 blocks of each run. Error bars of this kind are
themselves uncertain by about 1/√(2 × 39) = 11%. For a mean over the nine percolation seeds the error bar is the
standard error of the mean, the scatter between seeds over 3, uncertain by about 1/√(2 × 8) = 25%.
@@ -117,31 +126,47 @@ values of Pelissetto and Vicari (2002, sec. 3.5). The Binder cumulant at T_c ten
V₄ = 1.1679229(47) on a periodic square (Salas and Sokal 2000).
Each tolerance is a fixed number, 3 to 5 standard deviations of the noisiest estimate it covers, plus any
-finite-size shift: worked out from published results, except for D, whose shortfall is measured from these runs.
-For D, for the two p_c crossings and for the Binder cumulant at L = 16, the two sides are bounded separately, so
-the shift widens one side only. Every other check has one tolerance for both sides. Runs at several temperatures
-share one tolerance, so the quieter runs are held to it more loosely: ⟨|m|⟩ at T = 2.0 and 2.1 to 17 and 10
-standard deviations, the energy at T = 2.0, 2.1, 2.4 and 2.5 to between 5 and 8. For the Ising runs the standard
-deviation is the jackknife error. Over the 120-seed repeat below it matches the scatter between seeds within about
-10% on average, but this seed's errors from the runs reweighted to T_c (L = 8 to 128) come out 6% to 17% below that
-scatter, so the checks quote both. For percolation it is the standard error of the nine-seed mean. It comes out 9%
-above the repeat's scatter of a nine-seed mean (its scatter between seeds over 3) for the crossing of L = 32 and
-128, 44% above for 64 and 256 and 20% below for D, so those checks quote both too. `tests/critical.mjs` prints how
-far inside its tolerance each result falls.
-
-Counting standard deviations of the scatter between seeds, beyond any shift, the tightest checks are three. γ/ν
-comes to 3.0 after a finite-size bias of +0.0012: over these sizes the slope of the susceptibility on a periodic
-square exceeds 7/4 by that much (Caselle, Hasenbusch, Pelissetto and Vicari 2002, sec. 7.2, exact up to L = 17 and
-from their expansion beyond). The percolation dimension D comes to 3.1 on each side, beyond its measured shortfall
-on the low side (below), against the repeat's scatter of a nine-seed mean, 0.0026. The T_c crossing of L = 64 and
-128 comes to 3.5. In a one-off repeat at these tolerances with 120 other sets of seeds (each study seed plus
-10000k, k = 1 to 120; not one of the repository's scripts), 119 passed every Ising check and the other missed the
-crossing of L = 64 and 128 by 0.0003. The repeat predates the pooled percolation checks, but it saved each seed's
-percolation crossings and D. Split into 13 sets of nine seeds, all 13 pass the pooled checks; of 200,000 sets of
-nine drawn at random from the 120 seeds, 3 fail, all on D. The closed forms are checked too: the energy against the
+finite-size shift: worked out from published results, except for D, whose shortfall is measured, in these runs and
+in the independent 120-seed repeat below, which give the same bound. For D, for the two p_c crossings and for the
+Binder cumulant at L = 16, the two sides are bounded separately, so the shift widens one side only. At L = 16 the
+cumulant sits 0.0007 above its limit: Salas and Sokal (2000) measured V₄(16) = 1.16586(38), and its leading
+correction, of order L^(−7/4), comes from the analytic background of χ (their sec. 4.1). Every other check has one
+tolerance for both sides. Runs at several temperatures share one tolerance, so the quieter runs are held to it more
+loosely: ⟨|m|⟩ at T = 2.0 and 2.1 to 17 and 10 standard deviations, the energy at T = 2.0, 2.1, 2.4 and 2.5 to
+between 5 and 8. For the Ising runs the standard deviation is the jackknife error. Over the 120-seed repeat below
+it matches the scatter between seeds within about 10% on average, but this seed's errors from the runs reweighted
+to T_c (L = 8 to 128) come out 6% to 17% below that scatter, so the checks quote both. For percolation it is the
+standard error of the nine-seed mean. It comes out 9% above the repeat's scatter of a nine-seed mean (its scatter
+between seeds over 3) for the crossing of L = 32 and 128, 44% above for 64 and 256, 16% above for the point where
+the spanning probability at L = 32 is one half and 20% below for D, so those checks quote both too.
+`tests/critical.mjs` prints how far inside its tolerance each result falls.
+
+Counting standard deviations of the scatter between seeds, beyond any shift and on the side it points to, the
+tightest checks are three. γ/ν comes to 3.0 after a finite-size bias of +0.0012: over these sizes the slope of the
+susceptibility on a periodic square exceeds 7/4 by that much (Caselle, Hasenbusch, Pelissetto and Vicari 2002,
+sec. 7.2, exact up to L = 17 and from their expansion beyond). The T_c crossing of L = 64 and 128 comes to 3.5, and
+the energy above T_c to 3.6, at T = 2.75. The percolation dimension D is not among them. Counted from the shortfall
+the 120-seed repeat below expects, 0.0142, its low side comes to 3.8 of that repeat's scatter of a nine-seed mean,
+0.00256. Its high side, like the far side of every shifted check, allows no shift: 0.008 is 3.1 of those standard
+deviations. But the value the repeat expects lies 0.0222 below that bound, 8.7 standard deviations, so the high
+side guards only against gross errors. In a one-off repeat at these tolerances with 120 other sets of seeds (each
+study seed plus 10000k, k = 1 to 120; not one of the repository's scripts), 119 passed every Ising check and the
+other missed the crossing of L = 64 and 128 by 0.0003. The repeat predates the pooled percolation checks, but it
+saved each seed's percolation crossings and D. A rerun of its percolation seeds reproduced those exactly and also
+saved each seed's spanning probability at p_c, the points where it is one half and the crossings of sizes L/2 and
+L. Split into 13 sets of nine seeds, all 13 pass the pooled checks; of 200,000 sets of nine drawn at random from
+the 120 seeds, 37 fail, 3 on D and 34 on the point where the spanning probability at L = 32 is one half. That is
+one draw, by a resampler that is not one of the repository's scripts either: 100 other draws of 200,000 give 22 to
+60 failures, about 2 in 10,000, nearly all on that point. The closed forms are checked too: the energy against the
derivative of the published free energy (Caselle et al. 2002), to 10⁻⁷; Yang's formula against the same paper's
-form, to rounding; the open-edge shift of a crossing, below, against the coefficient Ziff and Newman (2002) give
-for sizes L/2 and L, 1.04.
+form, to rounding; the open-edge shift of a crossing, below, against the coefficient Ziff and Newman (2002,
+sec. IV) predict from the same b₀ and a₁ for sizes L/2 and L, 1.04 (they measured 1.02). That catches a slip in the
+algebra. Whether the shift describes this system is checked against their measured crossings of sizes L/2 and L
+(Table 1): they sit above p_c by 0.930, 0.965 and 0.975 times the shift at L = 64, 128 and 256, and the check
+allows 10%. At L = 32, the crossing of 16 and 32, the ratio is 0.862: the terms the expansion leaves out, of
+relative order L^(−0.9) (their secs. II and IV), still matter there, so that size is left out. Neither check uses
+the Monte Carlo runs. The comparison of the runs with their measurements, below, tests something else: that the
+model is the system they measured.
The two percolation results need a word each, and neither is a disagreement:
@@ -150,24 +175,50 @@ The two percolation results need a word each, and neither is a disagreement:
Newman 2002). Their expansion, with the coefficients they use (b₀ = 0.322, a₁ = 0.765), puts the crossing of
L = 32 and 128 0.00040 above p_c and that of L = 64 and 256 0.00012 above. Averaged over nine seeds, the
crossings sit 0.00060 ± 0.00024 and 0.00017 ± 0.00023 above p_c, 0.8 and 0.2 standard errors beyond those shifts.
- The study seed alone sits 0.0012 and 0.0013 high, which one seed cannot tell from a fluctuation: single seeds
- scatter by 0.0007. The mean of nine can. At L = 64 and 256 it rules out an offset of 0.0012 by more than 4
- standard errors, and the check fails any mean more than 0.0010 above p_c (the shift plus 3.8 standard errors) or
- 0.0009 below (3.9). Against the repeat's scatter of a nine-seed mean, 0.00016, those bounds are 5.5 and 5.6
- standard deviations: these nine seeds scatter more than the repeat's 120. The crossing of L = 32 and 128 is
- checked more loosely, failing beyond +0.0013 or −0.0009 (3.8 standard errors each way, beyond its shift on the
- high side; 4.1 of the repeat's scatter, 0.00022), because its shift is more than three times larger: an offset of
- 0.0012 would pass it. The point where the spanning probability at L = 256 is one half, printed but not checked,
- averages 0.59277 ± 0.00013.
+ The study seed alone sits 0.0012 and 0.0013 high. At L = 32 and 128 that is little more than one standard
+ deviation of a single seed beyond the shift (single seeds scatter by 0.0007 there), which one seed cannot tell
+ from a fluctuation. At L = 64 and 256 it is about 2.4: single seeds scatter by about 0.0005 there in the 120-seed
+ repeat (0.0006 for the eight other seeds). That is unusual for one seed but not decisive. The mean of nine can
+ tell. At L = 64 and 256 it rules out an offset of 0.0012 by more than 4 standard errors, and the check fails any
+ mean more than 0.0010 above p_c (the shift plus 3.8 standard errors) or 0.0009 below (3.9). Against the repeat's
+ scatter of a nine-seed mean, 0.00016, those bounds are 5.5 and 5.6 standard deviations: these nine seeds scatter
+ more than the repeat's 120, and the study seed alone accounts for about half of the excess. The crossing of
+ L = 32 and 128 is checked more loosely, failing beyond +0.0013 or −0.0009 (3.8 standard errors each way, beyond
+ its shift on the high side; 4.1 of the repeat's scatter, 0.00022), because its shift is more than three times
+ larger: an offset of 0.0012 would pass it. The point where the spanning probability at L = 256 is one half,
+ printed but not checked, averages 0.59277 ± 0.00013; Ziff and Newman measured 0.5927208 (below).
- The spanning cluster's dimension comes out 1.880, 0.8% low. Single seeds scatter by 0.006 about that, so the
shortfall, 0.016 ± 0.002, is systematic. Averaged over the nine seeds, the slope between successive sizes rises
from 1.861 ± 0.002 (L = 32 to 64) to 1.876 ± 0.003 (64 to 128) and 1.884 ± 0.005 (128 to 256), as corrections to
scaling fade. The first rise, 0.014 ± 0.004, is clear; the second, 0.008 ± 0.008, is one standard error, so nine
seeds do not resolve it. Leaving out L = 32 raises the fitted slope by 0.006 ± 0.001, in all nine seeds. The
- shortfall is measured from these runs, not predicted (the 120-seed repeat gives 0.014 ± 0.001), so the check does
- not test it. It accepts D from 0.024 below 91/48, the shortfall plus 4.0 standard errors, to 0.008 above, 4.0
- standard errors with no shift, and passes with 0.0079 to spare. Against the repeat's scatter of a nine-seed mean,
- 0.0026, each side is 3.1 standard deviations, which makes it one of the three tightest checks.
+ shortfall is measured, not predicted, so the check does not test it. Its low side accepts D down to 0.024 below
+ 91/48. That bound does not rest on these runs: the independent 120-seed repeat, which shares no seeds with them,
+ expects a shortfall of 0.0142 ± 0.0007, and its scatter of a nine-seed mean is 0.00256; the bound is 3.8 of those
+ standard deviations beyond that shortfall. These runs' own shortfall plus 4.0 standard errors gives the same
+ bound. The check passes with 0.0079 to spare. The high side is not tight. It accepts D up to 0.008 above 91/48
+ with no shift, as on the far side of every shifted check here: 4.0 standard errors, 3.1 of the repeat's scatter
+ of a nine-seed mean. Finite size lowers D at these sizes, so that bound sits 0.0222 above the value the repeat
+ expects, 8.7 of those standard deviations: it guards only against gross errors. A cap at 91/48 itself, 5.5 of
+ them above the expected value, would be tighter. It is not used, so that this side follows the same rule as the
+ far side of every other shifted check.
+
+Ziff and Newman (2002, Table 1) measured three of the model's finite-size quantities on this same system, an L × L
+square with open edges, crossed in one direction, with 4 × 10⁹ to 3 × 10¹⁰ samples at each size; their errors are
+generally in the last digit they quote. `critical/table.mjs` prints the nine-seed means beside their values for
+L = 32 to 256: the spanning probability R at p_c, the point where R is one half and, above L = 32, the crossing of
+sizes L/2 and L. All eleven agree within 1.04 standard errors. They amount to about four independent comparisons,
+one per size: at each size R at p_c and the point where R is one half are read off the same curve and move together
+from seed to seed (correlation −1.00 in the 120-seed repeat), and each crossing is nearly fixed by the points where
+R is one half at its two sizes. The 120-seed repeat's means, with errors about four times smaller, agree within 2
+of their own standard errors (largest 1.8). Of the eleven, the point where R is one half at L = 32 shows the open
+edges most clearly: they put it 0.00091 below p_c, 4.3 standard errors of the nine-seed mean (the same shift shows
+in R at p_c at that size, as 4.2; the rest are under 2). The nine-seed mean, 0.59178 ± 0.00021, sits 0.00006 below
+Ziff and Newman's 0.5918352. The check fails a mean more than 0.0007 from it (3.3 standard errors; 3.9 of the
+repeat's scatter of a nine-seed mean, 0.00018), and a mean at p_c would fail it by one standard error. So it tests
+the model's finite-size behaviour against published measurements, not only the threshold. Nine seeds test it only
+modestly: with the 120-seed repeat's values moved to centre on p_c, as if open edges had no effect at this size,
+about one set of nine seeds in eight would still pass. The other ten comparisons are printed but not checked.
## Where the repetition stops
@@ -280,9 +331,9 @@ size of a molecule.
- L. Onsager, *Crystal statistics. I. A two-dimensional model with an order-disorder transition*, Phys. Rev. 65, 117 (1944). Not consulted directly; T_c and the energy are checked against Caselle et al. (2002). https://doi.org/10.1103/PhysRev.65.117
- A. Pelissetto and E. Vicari, *Critical phenomena and renormalization-group theory*, Phys. Rep. 368, 549 (2002), secs. 1.3, 1.6.2, 3.1, 3.5, 5, 7.1 and 11.3. https://doi.org/10.1016/S0370-1573(02)00219-3 (https://arxiv.org/abs/cond-mat/0012164)
- Planck Collaboration, *Planck 2018 results. VI. Cosmological parameters*, A&A 641, A6 (2020). https://doi.org/10.1051/0004-6361/201833910 (https://arxiv.org/abs/1807.06209)
-- J. Salas and A. D. Sokal, *Universal amplitude ratios in the critical two-dimensional Ising model on a torus*, J. Stat. Phys. 98, 551 (2000). https://doi.org/10.1023/A:1018611122166 (https://arxiv.org/abs/cond-mat/9904038)
+- J. Salas and A. D. Sokal, *Universal amplitude ratios in the critical two-dimensional Ising model on a torus*, J. Stat. Phys. 98, 551 (2000), sec. 4.1 and Table 2. https://doi.org/10.1023/A:1018611122166 (https://arxiv.org/abs/cond-mat/9904038)
- M. Scrimgeour et al., *The WiggleZ Dark Energy Survey: the transition to large-scale cosmic homogeneity*, MNRAS 425, 116–134 (2012). https://doi.org/10.1111/j.1365-2966.2012.21402.x (https://arxiv.org/abs/1205.6812)
- S. Smirnov and W. Werner, *Critical exponents for two-dimensional percolation*, Math. Res. Lett. 8, 729 (2001). https://doi.org/10.4310/MRL.2001.v8.n6.a4 (https://arxiv.org/abs/math/0109120)
- U. Wolff, *Collective Monte Carlo updating for spin systems*, Phys. Rev. Lett. 62, 361 (1989). Not consulted directly; the add probability is as in Fujimoto and Otsuka (2020, appendix B). https://doi.org/10.1103/PhysRevLett.62.361
- C. N. Yang, *The spontaneous magnetization of a two-dimensional Ising model*, Phys. Rev. 85, 808 (1952). Not consulted directly; the formula is checked against Caselle et al. (2002). https://doi.org/10.1103/PhysRev.85.808
-- R. M. Ziff and M. E. J. Newman, *Convergence of threshold estimates for two-dimensional percolation*, Phys. Rev. E 66, 016129 (2002). https://doi.org/10.1103/PhysRevE.66.016129 (https://arxiv.org/abs/cond-mat/0203496)
+- R. M. Ziff and M. E. J. Newman, *Convergence of threshold estimates for two-dimensional percolation*, Phys. Rev. E 66, 016129 (2002), secs. I, II and IV and Table 1. https://doi.org/10.1103/PhysRevE.66.016129 (https://arxiv.org/abs/cond-mat/0203496)
diff --git a/critical/model.js b/critical/model.js
index b4579fc..edaf2ab 100644
--- a/critical/model.js
+++ b/critical/model.js
@@ -32,6 +32,9 @@
* Open edges: R_L(p) = 1/2 + a1 (p - p_c) L^(1/nu) + b0 / L + ..., nu = 4/3 (Ziff & Newman 2002, sec. I), with
* b0 = 0.322 and a1 = 0.765 (their sec. IV). As in their sec. II, the p where R_L1 and R_L2 cross then sits above
* p_c by (b0/a1)(1/L1 - 1/L2) / (L2^(3/4) - L1^(3/4)): +0.00040 for L = 32 and 128, +0.00012 for 64 and 256.
+ * Their Table 1 gives their measurements on this same system, with errors "generally in the last digit quoted".
+ * PERC.zn holds those for L = 32 to 256: R_L(p_c); p_0.5, where R_L(p) = 1/2; and the crossing of R_L/2 and R_L
+ * (their p_c-c^(2)); PERC.zn.places, the decimals each is quoted to.
* Random numbers: xoshiro128** seeded through splitmix32, integer arithmetic only, so a seed gives the same run on
* every JavaScript engine.
*/
@@ -40,7 +43,10 @@
const TC = 2 / Math.log(1 + Math.SQRT2);
const KC = 1 / TC;
const EXP = { beta: 1 / 8, nu: 1, eta: 1 / 4, gamma: 7 / 4 };
- const PERC = { pc: 0.59274621, D: 91 / 48, oneArm: 5 / 48, nu: 4 / 3, b0: 0.322, a1: 0.765 };
+ const PERC = { pc: 0.59274621, D: 91 / 48, oneArm: 5 / 48, nu: 4 / 3, b0: 0.322, a1: 0.765,
+ zn: { Ls: [32, 64, 128, 256], atPc: [0.509535, 0.504890, 0.502476, 0.50124], // Ziff & Newman 2002, Table 1
+ half: [0.5918352, 0.5924657, 0.5926613, 0.5927208], cross: [0.594825, 0.593413, 0.592952, 0.592808],
+ places: { atPc: [6, 6, 6, 5], half: [7, 7, 7, 7], cross: [6, 6, 6, 6] } } }; // decimals as Table 1 quotes them
const TWO32 = 4294967296;
// ---------- random numbers ----------
@@ -419,9 +425,10 @@
Dbig: jackknife(B, b => logSlope(Ls.slice(1), sums.slice(1).map(s => masses(s, b).big))) };
}
// Percolation pooled over nine independent seeds, the study seed and the eight of STUDY.perc.pool. Each estimate is
- // the nine seeds' mean; its error is the standard error of that mean, the scatter between seeds (sd) over 3. Also:
- // the slope of ln(mass) against ln L between successive sizes, the change from one of those slopes to the next, and
- // how much leaving out L = 32 raises the fit.
+ // the nine seeds' mean; its error is the standard error of that mean, the scatter between seeds (sd) over 3. At
+ // every L: R(p_c) and the p where R = 1/2; above L = 32, the crossing with the next smaller size. Also: the slope
+ // of ln(mass) against ln L between successive sizes, the change from one of those slopes to the next, and how much
+ // leaving out L = 32 raises the fit.
function studyPooled() {
const P = STUDY.perc, seeds = [P.seed].concat(P.pool), each = seeds.map(s => studyPercolation(s)), Ls = each[0].Ls;
const pool = f => {
@@ -432,7 +439,8 @@
const slope = (r, i) => Math.log(r.span[i + 1].value / r.span[i].value) / Math.log(Ls[i + 1] / Ls[i]);
return { seeds, Ls, each,
wide: each[0].wide.map((c, k) => ({ L1: c.L1, L2: c.L2, p: pool(r => r.wide[k].p.value) })),
- half: pool(r => r.half[r.half.length - 1].value), // p where R = 1/2 at the largest L
+ atPc: Ls.map((L, i) => pool(r => r.atPc[i].value)), half: Ls.map((L, i) => pool(r => r.half[i].value)),
+ adjacent: each[0].adjacent.map((c, k) => ({ L1: c.L1, L2: c.L2, p: pool(r => r.adjacent[k].p.value) })),
D: pool(r => r.D.value), Dall: pool(r => r.Dall.value),
local: Ls.slice(1).map((L, i) => ({ L1: Ls[i], L2: L, D: pool(r => slope(r, i)) })),
change: Ls.slice(2).map((L, i) => ({ L1: Ls[i], L2: Ls[i + 1], L3: L,
diff --git a/critical/table.mjs b/critical/table.mjs
index 73052a9..e3fe225 100644
--- a/critical/table.mjs
+++ b/critical/table.mjs
@@ -2,7 +2,8 @@
// critical/table.mjs (about 65 s). The runs are the same fixed-seed runs that tests/critical.mjs makes, so the numbers
// match; not every number printed here is checked (critical/README.md says which are). Percolation runs with nine
// seeds, and its checks use their mean: printed here with each seed's values, the standard error of the mean, the
-// slopes of the spanning cluster's mass between successive sizes, and how much leaving out L = 32 raises its fit.
+// slopes of the spanning cluster's mass between successive sizes, and how much leaving out L = 32 raises its fit; and
+// the means beside Ziff & Newman's measurements on this same system (2002, Table 1).
// (node critical/table.mjs scatter, which used to print eight of those seeds on their own, now prints the same.)
// No script prints the numbers critical/README.md takes from the one-off repeat with 120 other sets of seeds, or the
// finite-size shifts it works out from published formulas other than the open-edge shifts printed below; the README
@@ -87,7 +88,7 @@ console.log(`\nPercolation pooled over nine seeds (${seeds[0]}, then ${seeds.sli
'each seed with its jackknife error, then the mean with its standard error');
const cols = [['p_c, L = 32/128', r => r.wide[0].p, pool.wide[0].p, PERC.pc, 5, CR.edgeShift(32, 128)],
['p_c, L = 64/256', r => r.wide[1].p, pool.wide[1].p, PERC.pc, 5, CR.edgeShift(64, 256)],
- ['D, L = 64-256', r => r.D, pool.D, PERC.D, 4], ['p(R = 1/2), L = 256', r => r.half[last], pool.half, PERC.pc, 5],
+ ['D, L = 64-256', r => r.D, pool.D, PERC.D, 4], ['p(R = 1/2), L = 256', r => r.half[last], pool.half[last], PERC.pc, 5],
['D, L = 32-256', r => r.Dall, pool.Dall, PERC.D, 4]];
console.log(col('seed', 6) + cols.map(c => col(c[0], 22)).join(''));
pool.each.forEach((r, i) => console.log(col(seeds[i], 6) + cols.map(c => col(pm(c[1](r), c[4]), 22)).join('')));
@@ -104,4 +105,31 @@ console.log(' change from one of those slopes to the next, seed by seed: ' + po
`L = ${x.L1}-${x.L2} to ${x.L2}-${x.L3}: ${pm(x.D, 3)}`).join(', '));
console.log(` D over L = 64-256 less D over L = 32-256: ${pm(pool.rise, 3)}, positive for ${pool.rise.v.filter(x => x > 0).length} of ` +
`${pool.rise.v.length} seeds`);
+
+// The nine seeds' means against Ziff & Newman's measurements on this same system at the same sizes (their Table 1),
+// with z = (mean - theirs) / standard error of the mean; their own errors are in the last digit quoted. The crossing
+// at L is that of L/2 and L. Then how far open edges move their values from the L -> infinity ones, in the same units.
+const zn = PERC.zn, zi = L => zn.Ls.indexOf(L), z = (m, v) => (m.value - v) / m.err;
+const quoted = (k, j) => zn[k][j].toFixed(zn.places[k][j]); // as Table 1 prints it: 0.504890, not 0.50489
+const adj = L => pool.adjacent.find(x => x.L2 === L), zs = [];
+console.log('\nPercolation against Ziff & Newman\'s measurements on the same system (2002, Table 1), means of the nine seeds');
+console.log(col('L', 5) + col('R(p_c)', 18) + col('Z&N', 10) + col('z', 7) + col('p where R = 1/2', 20) + col('Z&N', 11) + col('z', 7) +
+ col('crossing L/2, L', 20) + col('Z&N', 10) + col('z', 7));
+p.Ls.forEach((L, i) => {
+ const R = pool.atPc[i], h = pool.half[i], c = adj(L), j = zi(L);
+ zs.push(z(R, zn.atPc[j]), z(h, zn.half[j]));
+ if (c) zs.push(z(c.p, zn.cross[j]));
+ console.log(col(L, 5) + col(pm(R, 4), 18) + col(quoted('atPc', j), 10) + col(z(R, zn.atPc[j]).toFixed(2), 7) +
+ col(pm(h, 5), 20) + col(quoted('half', j), 11) + col(z(h, zn.half[j]).toFixed(2), 7) +
+ (c ? col(pm(c.p, 5), 20) + col(quoted('cross', j), 10) + col(z(c.p, zn.cross[j]).toFixed(2), 7) : col('-', 20)));
+});
+console.log(` ${zs.length} comparisons, largest |z| ${Math.max(...zs.map(Math.abs)).toFixed(2)}`);
+const eff = (f, from) => p.Ls.map((L, i) => from(i) ? (f(i) / from(i).err).toFixed(1) : '-').join(', ');
+console.log(` open-edge effect in their values, in standard errors of the mean, L = ${p.Ls.join(', ')}:\n R(p_c) - 1/2: ` +
+ eff(i => zn.atPc[zi(p.Ls[i])] - 0.5, i => pool.atPc[i]) + '; p_c - p where R = 1/2: ' +
+ eff(i => PERC.pc - zn.half[zi(p.Ls[i])], i => pool.half[i]) + '; crossing - p_c: ' +
+ eff(i => zn.cross[zi(p.Ls[i])] - PERC.pc, i => adj(p.Ls[i]) && adj(p.Ls[i]).p));
+const h32 = pool.half[p.Ls.indexOf(32)];
+console.log(` at L = 32: p_c less their p where R = 1/2 = ${(PERC.pc - zn.half[zi(32)]).toFixed(5)}; the mean is ` +
+ `${((PERC.pc - h32.value) / h32.err).toFixed(1)} standard errors below p_c (tests/critical.mjs checks it against theirs)`);
console.log(`\nruntime ${((Date.now() - start) / 1000).toFixed(1)} s on Node ${process.versions.node}`);
diff --git a/gravitational-atom/index.html b/gravitational-atom/index.html
index c906213..ea78941 100644
--- a/gravitational-atom/index.html
+++ b/gravitational-atom/index.html
@@ -291,7 +291,7 @@ What it leaves out
Source code under the Apache License 2.0.
diff --git a/index.html b/index.html
index e822927..a843987 100644
--- a/index.html
+++ b/index.html
@@ -233,9 +233,11 @@ One question, asked at every scale.
- The Witness Map (this page): where quantum turns classical, object by object.
- Gravitational atom beside hydrogen: the same wave equation at two scales, drawn at matched size.
- - Quantum paths: where a recorded path's fractal dimension 2 starts and stops. Model and checks written; issue 16 tracks publication.
+ - Quantum paths: where a recorded path's fractal dimension 2 starts and stops.
+ - The critical point: a magnet whose spins point only up or down repeats itself across scales only when tuned to its critical point; away from it the repetition stops at the correlation length.
+ - Turbulence: between the size where a flow is stirred and the size where viscosity takes over, the same energy flux passes through every scale; the bursts do not scale exactly.
- Cosmic homogeneity: the scale where galaxy clustering stops looking fractal. Model and checks written; issue 17 tracks publication.
- - Open questions: halos within halos, turbulence's two cutoffs, and why repetition appears at all. The issue list is the programme.
+ - Open questions: halos within halos. The issue list is the programme.
@@ -250,7 +252,7 @@ One question, asked at every scale.
Source code under the Apache License 2.0.
diff --git a/tests/critical.mjs b/tests/critical.mjs
index 1b09d67..f5a7709 100644
--- a/tests/critical.mjs
+++ b/tests/critical.mjs
@@ -1,30 +1,39 @@
// Checks the critical-point study (critical/model.js, issue #20) against exact results: Onsager's T_c and energy,
// Yang's magnetisation, the exact correlation length, the 2D Ising exponents, the Binder cumulant at T_c, the
-// measurement trap in cluster runs, Newman and Ziff's percolation threshold and the 91/48 dimension. Run: npm test (or
-// node tests/critical.mjs).
-// Each check states the source, the exact value, the model's value and the tolerance. The Monte Carlo runs use fixed
-// seeds and integer-only random numbers, so every run, on every Node version, prints the same numbers. Ising error
-// bars are jackknife estimates over 40 blocks. The percolation checks use the mean over nine seeds, the study seed and
-// eight others, with the standard error of that mean as error bar: the scatter between the nine seeds over 3. Each
-// tolerance is a fixed number, 3 to 5 standard deviations of the noisiest estimate it covers, plus any finite-size
-// shift: worked out from published results, except for D, whose shortfall is measured from these runs. For D, the two
-// p_c crossings and the Binder cumulant at L = 16 the two sides are bounded separately, so the shift widens one side
-// only; every other check has one tolerance for both sides. A sigma count below is (tolerance - shift) / sigma, with
-// sigma and shift as quoted, on the side the shift points to; on the other side it is tolerance / sigma and allows no
-// shift. Runs at several temperatures share one tolerance, so the quieter runs are held to it more loosely: |m| at
-// T = 2.0 and 2.1 to 17 and 10 sigma, the energy at T = 2.0, 2.1, 2.4 and 2.5 to between 5 and 8 sigma. For the Ising
-// runs the standard deviation is the jackknife error. Over the 120 repeat seeds below it matches the scatter between
-// seeds within about 10% on average, but this seed's errors from the runs reweighted to T_c (L = 8 to 128) come out 6%
-// to 17% below that scatter, so those checks also quote the scatter. For percolation it is the standard error of the
-// nine-seed mean. It comes out 9% above the repeat's scatter of a nine-seed mean (its scatter between seeds over 3)
-// for the crossing of L = 32 and 128, 44% above for 64 and 256 and 20% below for D, so those checks also quote that
-// scatter. Against the seed-to-seed scatter the tightest checks are gamma/nu (3.0 sigma after its +0.0012 finite-size
-// bias), D (3.1 sigma on each side, beyond its measured shortfall on the low side) and the Binder crossing of L = 64
-// and 128 (3.5 sigma). In a one-off repeat at these tolerances with 120 other sets of seeds (each study seed plus
-// 10000k, k = 1 to 120; not one of the repository's scripts), 119 passed every Ising check; the other missed the
-// crossing of L = 64 and 128 by 0.0003. The repeat predates the pooled percolation checks, but it saved each seed's
-// percolation crossings and D: split into 13 sets of nine seeds, all 13 pass the pooled checks, and of 200000 sets of
-// nine drawn at random from the 120, 3 fail, all on D. Each line prints the margin it passes by.
+// measurement trap in cluster runs, Newman and Ziff's percolation threshold and the 91/48 dimension; and against Ziff
+// and Newman's measurements of the same percolation system at finite sizes: their crossings of two sizes test the
+// open-edge shift, and one point tests the runs. Run: npm test (or node tests/critical.mjs).
+// Each check states the source, the value it is compared with (an exact value, or in those two checks Ziff and
+// Newman's measurements), the model's value and the tolerance. The Monte Carlo runs use fixed seeds and integer-only
+// random numbers, so every run, on every Node version, prints the same numbers. Ising error bars are jackknife
+// estimates over 40 blocks. The percolation checks use the mean over nine seeds, the study seed and eight others, with
+// the standard error of that mean as error bar: the scatter between the nine seeds over 3. Each tolerance is a fixed
+// number, 3 to 5 standard deviations of the noisiest estimate it covers, plus any finite-size shift: worked out from
+// published results, except for D, whose shortfall is measured, in these runs and in the independent 120-seed repeat
+// below, which give the same bound. For D, the two p_c crossings and the Binder cumulant at L = 16 the two sides are
+// bounded separately, so the shift widens one side only; every other check has one tolerance for both sides. A sigma
+// count below is (tolerance - shift) / sigma, with sigma and shift as quoted, on the side the shift points to; on the
+// other side it is tolerance / sigma and allows no shift. Runs at several temperatures share one tolerance, so the
+// quieter runs are held to it more loosely: |m| at T = 2.0 and 2.1 to 17 and 10 sigma, the energy at T = 2.0, 2.1, 2.4
+// and 2.5 to between 5 and 8 sigma. For the Ising runs the standard deviation is the jackknife error. Over the 120
+// repeat seeds below it matches the scatter between seeds within about 10% on average, but this seed's errors from the
+// runs reweighted to T_c (L = 8 to 128) come out 6% to 17% below that scatter, so those checks also quote the scatter.
+// For percolation it is the standard error of the nine-seed mean. It comes out 9% above the repeat's scatter of a
+// nine-seed mean (its scatter between seeds over 3) for the crossing of L = 32 and 128, 44% above for 64 and 256, 16%
+// above for the point where R = 1/2 at L = 32 and 20% below for D, so those checks also quote that scatter. Against
+// the seed-to-seed scatter, on the side each shift points to, the tightest checks are gamma/nu (3.0 sigma after its
+// +0.0012 finite-size bias), the Binder crossing of L = 64 and 128 (3.5 sigma) and the energy above T_c (3.6 sigma, at
+// T = 2.75). D's low side is 3.8 sigma of the repeat's scatter of a nine-seed mean beyond the shortfall the repeat
+// expects. Its high side, the far side, is 3.1 sigma by the rule above, which allows no shift, but it sits 0.0222 (8.7
+// sigma) above the value the repeat expects, so the high side guards only against gross errors. In a one-off repeat at
+// these tolerances with 120 other sets of seeds (each study seed plus 10000k, k = 1 to 120; not one of the
+// repository's scripts), 119 passed every Ising check; the other missed the crossing of L = 64 and 128 by 0.0003. The
+// repeat predates the pooled percolation checks, but it saved each seed's percolation crossings and D, and a rerun of
+// its percolation seeds, which reproduced those exactly, saved the points where R = 1/2 too: split into 13 sets of
+// nine seeds, all 13 pass the pooled checks, and of 200000 sets of nine drawn at random from the 120, 37 fail, 3 on D
+// and 34 on the point where R = 1/2 at L = 32. That is one draw, by a resampler that is not one of the repository's
+// scripts either: 100 other draws of 200000 give 22 to 60 failures, about 2 in 10000, nearly all on that point. Each
+// line prints the margin it passes by.
import { createRequire } from 'node:module';
const require = createRequire(import.meta.url);
const CR = require('../critical/model.js');
@@ -40,10 +49,11 @@ function check(name, ok, detail, src) {
}
// A Monte Carlo estimate {value, err} against an exact value: passes if exact - lo <= model <= exact + hi, where tol is
// one number (lo = hi = tol) or [lo, hi], and the error bar is finite (a jackknife replicate can fail and give NaN).
-function near(name, est, want, tol, src, why, d) {
+// `label` names the value compared with when it is a published measurement rather than an exact value.
+function near(name, est, want, tol, src, why, d, label = 'exact') {
const [lo, hi] = Array.isArray(tol) ? tol : [tol, tol], dev = est.value - want;
const finite = Number.isFinite(est.err), ok = finite && dev >= -lo && dev <= hi;
- console.log(`${ok ? 'PASS' : 'FAIL'} ${name}\n model ${fmt(est.value, d)} ± ${fmt(est.err, d)} exact ${fmt(want, d)} ` +
+ console.log(`${ok ? 'PASS' : 'FAIL'} ${name}\n model ${fmt(est.value, d)} ± ${fmt(est.err, d)} ${label} ${fmt(want, d)} ` +
`(within ${lo === hi ? fmt(hi, d) : `-${fmt(lo, d)}/+${fmt(hi, d)}`}; off by ${fmt(dev, d)} = ${(dev / est.err).toFixed(1)} sigma; ` +
`margin ${fmt(Math.min(hi - dev, dev + lo), d)}) ${src}` + (finite ? '' : '\n the error bar is not finite') + (why ? `\n ${why}` : ''));
if (!ok) fails++;
@@ -84,12 +94,27 @@ check('Near T_c the same correlation length is A/t with A = 1/(4 K_c) = 0.567296
`t xi = ${amp.toFixed(8)} at t = 1e-6: it is the exponential correlation length, not the second-moment one (A = 0.5670683)`,
'Caselle, Hasenbusch, Pelissetto & Vicari 2000 (arXiv:hep-th/0003049), sec. 2');
// Percolation on a square with open edges: where the spanning probabilities of two sizes cross, from Ziff & Newman's
-// expansion of R_L(p) (critical/model.js header), against the coefficient they quote for sizes L/2 and L.
+// expansion of R_L(p) (critical/model.js header). First against the coefficient they predict from the same b0 and a1
+// for sizes L/2 and L, which catches a slip in the algebra; then against their measured crossings of L/2 and L, which
+// tests whether the expansion describes this system at these sizes. Neither uses the Monte Carlo runs: section 7
+// checks those against their measurements.
const ZN = 'Ziff & Newman 2002 (arXiv:cond-mat/0203496)', coef = CR.edgeShift(32, 64) * Math.pow(64, 7 / 4);
check('Open edges shift the crossing of R_L1(p) and R_L2(p) above p_c by (b0/a1)(1/L1 - 1/L2)/(L2^(3/4) - L1^(3/4)); for ' +
- "L1 = L/2 and L2 = L that is Ziff & Newman's 1.04 L^-7/4", Math.abs(coef - 1.04) < 0.005,
+ "L1 = L/2 and L2 = L that is the 1.04 L^-7/4 Ziff & Newman predict from the same b0 and a1 (they measured 1.02)",
+ Math.abs(coef - 1.04) < 0.005,
`coefficient ${coef.toFixed(3)} from their b0 = ${PERC.b0} and a1 = ${PERC.a1}; the shifts used in section 6 below: ` +
`+${fmt(CR.edgeShift(32, 128), 5)} for L = 32 and 128, +${fmt(CR.edgeShift(64, 256), 5)} for 64 and 256`, `${ZN}, secs. I, II and IV`);
+// Their measured crossings (Table 1, PERC.zn.cross) less p_c, over the shift. Their errors, one in the last digit,
+// are at most 1.6% of it (at L = 256); the rest of the 10% allows the terms the expansion leaves out, of relative
+// order L^-0.9 (their secs. II and IV). L = 32, the crossing of 16 and 32, is left out: there those terms still take
+// 14% off.
+const edge = [32, 64, 128, 256].map(L => {
+ const d = PERC.zn.cross[PERC.zn.Ls.indexOf(L)] - PERC.pc, s = CR.edgeShift(L / 2, L);
+ return { L, d, s, r: d / s };
+}), fit = edge.slice(1), worst = Math.max(...fit.map(x => Math.abs(x.r - 1)));
+check("Ziff & Newman's measured crossings of R_L/2(p) and R_L(p) sit above p_c by that shift, within 10% for L = 64, 128 and 256",
+ worst <= 0.1, fit.map(x => `L = ${x.L}: measured +${fmt(x.d, 6)}, shift +${fmt(x.s, 6)}, ratio ${x.r.toFixed(3)}`).join('; ') +
+ `; margin ${fmt(0.1 - worst, 3)} (L = 32, left out: ratio ${edge[0].r.toFixed(3)})`, `${ZN}, secs. II and IV and Table 1`);
const r1 = CR.rng(1);
check('Random numbers are integer-only xoshiro128**: seed 1 starts 2442144158, 3238099751, 3819917871',
[2442144158, 3238099751, 3819917871].every(v => r1() === v), 'same on every engine, so every run below is reproducible', 'model');
@@ -162,7 +187,7 @@ check('Energy per spin at the same five temperatures, within 0.005 (3.7 sigma of
`off by ${x.dev.toFixed(4)} (${(x.dev / x.err).toFixed(1)} sigma)`).join('; ') +
`; margin ${(0.005 - Math.max(...eHot.map(x => Math.abs(x.dev)))).toFixed(4)}`, ONS);
-// 6. Site percolation, open edges, spanning top to bottom. The crossings and D are means over nine independent seeds
+// 6. Site percolation, open edges, spanning top to bottom. Each result is a mean over nine independent seeds
// (the study seed and the eight of STUDY.perc.pool), and sigma is the standard error of the mean: the scatter
// between the nine seeds over 3. The tolerances are fixed numbers, set once from that scatter. The open-edge shifts
// are the ones checked in section 1. The details also quote the scatter of a nine-seed mean in the 120-seed repeat.
@@ -177,16 +202,37 @@ for (const c of pool.wide) near(`p_c from the crossing of the spanning probabili
'crossing of L = 64 and 256 is the check that rules such an offset out. The mean sits 0.8 sigma above the shift'
: 'tolerance: sigma = 0.00023; the low side is 3.9 sigma and allows no shift, the high side 3.8 sigma above the ' +
'open-edge shift, +0.00012; 5.6 and 5.5 sigma of the seed-to-seed scatter of a nine-seed mean (0.00016), as these ' +
- 'nine seeds scatter more than the repeat\'s 120. A mean more than 0.0010 above p_c or 0.0009 below fails, so an ' +
- 'offset of 0.0012 fails (the study seed alone sits 0.0013 high). The mean sits 0.2 sigma above the shift', 5);
+ 'nine seeds scatter more than the repeat\'s 120. About half of that excess is the study seed\'s: it sits 0.0013 ' +
+ 'high, about 2.4 standard deviations of a single seed beyond the shift (single seeds scatter by about 0.0005 in ' +
+ 'the repeat; 0.0006 for the eight other seeds). A mean more than 0.0010 above p_c or 0.0009 below fails, so an ' +
+ 'offset of 0.0012 fails. The mean sits 0.2 sigma above the shift', 5);
near(`Fractal dimension of the spanning cluster at p_c: mass ~ L^D, least squares over L = ${pool.Ls.slice(1).join(', ')}, mean of ${n} seeds`,
pool.D, PERC.D, [0.024, 0.008], 'D = 2 - 5/48 = 91/48: Lawler, Schramm & Werner 2002 (one-arm exponent 5/48)',
'tolerance: the slope between successive sizes rises with L (1.861, 1.876 and 1.884 from L = 32 to 256, means of the ' +
- 'nine seeds), so a fit over L = 64 to 256 falls short of 91/48. The shortfall, 0.016, is measured from these runs, not ' +
- 'predicted (the 120-seed repeat in the header gives 0.014 +- 0.001), so this check does not test it. The low side ' +
- 'allows it plus 4.0 sigma (sigma = 0.0020): a D more than 0.024 (1.3%) below 91/48 fails. The high side, 4.0 sigma, ' +
- 'allows no shift: more than 0.008 above fails. Each side is 3.1 sigma of the seed-to-seed scatter of a nine-seed ' +
- 'mean (0.0026), one of the tightest checks', 4);
+ 'nine seeds), so a fit over L = 64 to 256 falls short of 91/48. The shortfall is measured, not predicted, so this ' +
+ 'check does not test it. The low side allows the shortfall that the independent 120-seed repeat in the header ' +
+ 'expects, 0.0142 +- 0.0007 (it shares no seeds with these runs), plus 3.8 times its scatter of a nine-seed mean ' +
+ '(0.00256): a D more than 0.024 (1.3%) below 91/48 fails. These runs\' own shortfall, 0.016, plus 4.0 sigma ' +
+ '(sigma = 0.0020) gives the same bound. The high side is not tight. It allows no shift, as on the far side of every ' +
+ 'shifted check here: a D more than 0.008 above 91/48 fails, 4.0 sigma and 3.1 times the repeat\'s scatter. That is ' +
+ '0.0222 above the value the repeat expects at these sizes, 8.7 times its scatter, so the high side guards only ' +
+ 'against gross errors', 4);
+
+// 7. The same percolation runs against Ziff & Newman's measurements on this same system at the same size (their
+// Table 1), not against a value for L -> infinity. critical/table.mjs prints eleven such comparisons, for L = 32 to
+// 256, and all agree within 1.04 sigma. They amount to about four independent ones, one per size: at each size
+// R(p_c) and the point where R = 1/2 are read off the same curve (seed-to-seed correlation -1.00 in the 120-seed
+// repeat), and each crossing of L/2 and L is nearly fixed by the points where R = 1/2 at those two sizes. This one
+// is the clearest: open edges move it 4.3 sigma from its L -> infinity value, p_c (the same shift moves R(p_c) at
+// L = 32 by 4.2; the rest are under 2).
+const zn = PERC.zn, h32 = pool.half[pool.Ls.indexOf(32)];
+near(`Where the spanning probability is 1/2 at L = 32, mean of ${n} seeds, against Ziff & Newman's measurement, 0.5918352`, h32,
+ zn.half[zn.Ls.indexOf(32)], 0.0007, `${ZN}, Table 1`,
+ 'tolerance 3.3 sigma (sigma = 0.00021), 3.9 sigma of the seed-to-seed scatter of a nine-seed mean (0.00018), with ' +
+ 'no shift: both are at L = 32. Open edges put this point 0.00091 below p_c, so a mean at p_c fails, by 1.0 sigma: ' +
+ 'the check tests the model\'s finite-size behaviour against published measurements, not only the threshold. Only ' +
+ 'modestly: with the 120-seed repeat\'s values moved to centre on p_c, about one set of nine seeds in eight would ' +
+ 'still pass. The mean sits 4.5 sigma below p_c', 5, 'measured');
const secs = (Date.now() - start) / 1000;
console.log(`\nruntime ${secs.toFixed(1)} s on Node ${process.versions.node}`);