run 105Settled
./perc graphs/H9.bin 6000 <seed> 2 samples105/H9_p<i>.txt for i = 0 … 7 with perc seeds 16101 + i (16101–16108); the set is their concatenation, 48,000 samples, read as one series by the analysis; each piece has its own sidecar. run105.sh draws the pieces in order and skips a piece whose file exists with exactly 6,000 lines; a piece file with any other line count is moved to discarded105/ (untracked) with a line in times105.txt, and the piece is drawn again by the same command (perc's output is a function of seed and index alone, so it is the same file). A piece is launched only when the memory available at launch (free + inactive + speculative pages by vm_stat) is at least 9 GB, the footprint being 6.0 GB at 2 threads (peak RSS 5,986,893,824 B in the sizing, 200 samples in 1250.5 s); the threshold is 9 GiB = 9,663,676,416 B; a piece that finds less waits ten minutes and tries again, each wait logged, and after 36 consecutive waits (six hours) run105.sh stops with a logged line and the lab reports it; a piece's md5 and sidecar are written the moment its file is complete, and a piece file of 6,000 lines with no logged md5 (a stop between the write and the log) is moved to discarded105/ and drawn again; run105.sh checks the binary's md5 at each piece's launch; a piece is never started at more than 2 threads. The machine is kept awake by the lab (caffeinate), and a piece stopped by a restart or a crash is drawn again whole. Before drawing — pre105.sh draws 24 samples of H9 at seed 16101 once at 1 thread and once at 2 threads (./perc graphs/H9.bin 24 16101 1 redraw105/H9_t1.txt, … 24 16101 2 redraw105/H9_t2.txt) and checks that the two files are byte-identical (the md5 of the whole file and of cut -d' ' -f1 of each, all four logged), that perc.c, graphs/H9.bin and the binary have the md5s above, and that samples105/, discarded105/, times105.txt, fit105.json (as a stage-one block; the stage-zero block is allowed) and RESULTS105.md do not exist. Its verdict is the last line of pre105_m5.log (REDRAWS_PASS or REDRAWS_FAIL), written before the first draw and not evaluated again; the log is committed before the first draw. This is a check that the draw does not depend on the thread count, which is what the arithmetic of perc.c predicts and what run 100 saw across machines at H7; it is not a check against a stored H9 file, because none exists; what ties this binary to the stored sizes is run 100's own H8 redraw on it (pre100_m5.log: the first 1,000 samples of samples079/H8.txt, seed 7905, column 0 equal, binary md5 5cf50dc6a4ede1d1abbf6082bbacfbdc, REDRAWS_PASS 2026-10-04), and what ties graphs/H9.bin to the family is the closed form checked in control (vi). pre105.sh runs after the sealing commit and before the first piece, compares md5s only and prints no sample value; the 24 redrawn samples are the first 24 of piece 0 and are not otherwise read. The sizing pilot (200 samples at seed 15001, sizing_h9/r200.txt, untracked) was never opened by the sizing lab and is not read here; it is discarded and belongs to no set. Sidecars carry the file's md5, line count, seed, graph and binary md5s, thread count and wall time, and no statistic of column 0. No script, and not the codifier, reads a piece's contents except the line-count, md5, 24-line and (ii)–(v) checks of the analysis, which runs only when all eight pieces exist. A set of fewer than eight pieces is never scored: if the draw is abandoned, the run is withdrawn by a dated note and the pieces already drawn stay unread. Seeds are unused if a scan of every script (.sh, .py, .c), every run file (lab/runs/*.md) and every seed-named JSON key, made on the M5 by seedscan100.py's method and recorded in pre105.json, committed before the first draw, finds none of 16101–16108 or 601001–603000 used or named as a seed outside this run's own files (this run file, pre105.sh, run105.sh, fit105.py, the scan's script seedscan105.py and pre105.json); the scan was made on 2026-10-06 on 330 scripts, 88 run files and 377 JSON files and returned unused (the sizing pilot's seed 15001 and run 104's withdrawn candidates 15101–15163 and 591001–591100 lie outside both ranges). Control (i) below is run and committed before the first draw too, since it reads no new sample. run105.sh refuses to draw unless pre105_m5.log ends in REDRAWS_PASS, the perc binary's md5 is the one that log records (a gate for the lab, not a scored control), pre105.json is present with the verdict unused, and fit105.json's stage-zero block records control (i) passed. Analysis on the M5 in the lab's environment (numpy 2.5.3) in two stages — stage one writes the controls and no z; stage two the z's. Moments, errors and the set's 3 × 3 covariance as run 100: x = column 0 / M over the 48,000 samples; the mean of x, ln S (S the square root of the unbiased second k-statistic), g₁ = k₃/k₂^1.5 by unbiased k-statistics (reading_pg03_moments.py's functions); the sample covariance (divisor 1,999) of 2,000 bootstrap replicates, replicate b (b = 0 … 1,999) resampling the 48,000 samples with replacement by index, numpy default_rng(601001 + b).choice(n, n, replace=True). The prediction — the three sealed values and their profile errors above, as glimpse_19683.json holds them at full precision; they come from fit100.py unchanged (md5 0328a891a35091a5085cb9a4f4731d7a; the forms, bounds, grids, starts and refinements of run 100) on the seven files named in the question (each file its own point with its covariance, fit100_stage1.json), evaluated at L = 19,683, the error per moment being half the range of the prediction over χ² ≤ χ²_min + 1 in all nine parameters, exact in the linear amplitudes and extremised over (1/ν, ω, B) inside the bounds (reading_pg03_loo.py's profile_error, md5 4e4b4755ed9f462b9fc2f0caf8cba028). Scored quantity — for each moment m, z_m = (new − sealed prediction) / √(σ²_m,boot + σ²_m,profile), the sealed profile error in the denominator; Q = max |z_m| over the three moments. Controls, all written before stage two — (i) the engine, before any draw: fit105.py's seven-file free fit gives χ² within 0.001 of 12.4058 on 12, each of the three predictions within 1 × 10⁻⁷ of its sealed value, and each profile error within one part in a thousand of its sealed value; (ii) the record: eight pieces of exactly 6,000 lines, every x in (0, 1), the md5s of perc.c and graphs/H9.bin as recorded, the redraw verdict REDRAWS_PASS, the seed scan's verdict unused (made before the draws and not evaluated again), each piece's md5 at analysis equal to the one times105.txt logged when it was written, the md5 of the first 24 lines of piece 0 equal to the md5 of redraw105/H9_t2.txt that pre105_m5.log recorded, the binary's md5 at every piece's launch the one recorded, and the 64-bit seeds x₀ of every sample of the set pairwise distinct from each other and from those of the sizing pilot (perc seed 15001, 200 samples), and none equal to another x₀ plus or minus m·0x9E3779B97F4A7C15 for m = 1, 2, 3 (where splitmix64 streams would overlap), all computed, not sampled; (iii) the gross check, in place of a twin (no earlier H9 file exists; if it fails and the stage-one rerun of (i), (ii) and (vi) passes, the run is scored as written, with the failing bound reported beside the z's): the set's mean of x within 0.002 of 0.6834 and its ln S within 0.08 of −6.62 — a wrong column, a wrong M or a wrong graph misses by far more, and a control on a gross miss, not a reach: these bounds are about five times the falsifier's reach in ln S (0.017 at 3.5 combined errors) and forty times its reach in the mean, so they cannot void a physical result of the falsifier's size; (iv) 24 consecutive blocks of 2,000 (three to a piece): for each moment the SD (divisor 23) of the block values over √24, divided by the bootstrap error; each ratio in 0.50 to 1.50 and the mean of the three in 0.70 to 1.30, the failing moment named (each ratio has a relative spread of about 0.15 on 24 blocks); (v) with k = column 0, no run of 8 consecutive k values occurs twice, at any offsets, within the set; (vi) the graph, before any draw: pre105.sh's python half reads graphs/H9.bin and checks n = 8⁹ = 134,217,728 and M = (8/5)(8⁹ − 3⁹) = 214,716,872, the closed form that holds at H7 (3,351,944) and H8 (26,833,048) as run 100 records them, every endpoint in [0, n) and no self-loop, and the terminal flags only bits 0 and 1; (i) and (vi) are rerun at stage one../lab/runs/105-h-19683-prediction.mdPredictionThe free one-term form's prediction at 19,683 from the five stored sizes holds on the new set — Q < 2.5. One clause.
FalsifierQ ≥ 3.5 — the form that fits run 100's seven files at 12.4 on 12 does not reach the sixth size; the moment is named. Between 2.5 and 3.5, unanticipated. Withdrawn (nothing scored; the run may be resealed) if control (i), (ii) or (vi) fails; reported and not scored (drawn, no outcome word, not redrawn under this seal) if (iv) or (v) fails, or (iii) fails and the stage-one rerun of (i), (ii) and (vi) fails too, whenever the failure is seen. Readings fixed now — the power is stated, and it is low. The set's error in ln S is 0.78/√48,000 = 0.0036 against a prediction error of 0.0033, so the combined error is 0.00485 (the mean's set error is 6 × 10⁻⁶ against 1.2 × 10⁻⁵, combined 1.4 × 10⁻⁵; g₁'s about 0.013, from √(6/N) = 0.011 as a floor, against 0.0075, and the bootstrap error will be larger for a skewed sample); a doubling of the samples to 96,000 would move ln S's combined error only to 0.0041, and 192,000 to 0.0037 (the prediction's 0.0033 is the floor). The pure power law's ln S at 19,683, −6.6348 ± 0.0026 (READING-PG03-L2S.md's pure-power row, ten stored points that are not run 100's files), lies 0.0130 below the sealed prediction, 2.7 combined errors on the sealed denominator. The sealed prediction is a fixed number, so under that pure power as the truth z_ln S scatters with a standard deviation of 0.74 around −2.7; the run would then confirm (|z_ln S| < 2.5) about four times in ten at most (0.40; 0.42 with the reference's own ±0.0026 folded in), falsify (z ≤ −3.5 in ln S alone) about one time in eight to one in six (0.13 to 0.18), and land between 2.5 and 3.5 about four times in ten (0.40 to 0.47); the other two moments can only lower the first and raise the second. If the free prediction is the truth, Q reaches 2.5 about four times in a hundred and 3.5 about once in a thousand (the three z's taken as independent; they are not, and the true rates are lower). The middle band, called unanticipated, is as likely under a pure power as a confirm; it reads "ln S sits between the free form's reach and the pure power's, and the run does not choose". So a confirm says the free form reaches the sixth size on three moments at once within errors of about 0.0048, 1.4 × 10⁻⁵ and 0.013, and it does not exclude a pure power law, which the sealing condition of L4 asked it to do; a falsify says the stored sizes' fit does not carry to 19,683. The tied form's sealed values sit 1.9, 6.0 and 4.4 combined errors from the free form's on ln S, the mean and g₁, so the free and tied forms cannot both be inside 2.5 on the mean; the run therefore separates them there by construction, and no reading beyond "the tied form's z's" is fixed for them. A falsify in the mean alone, with ln S and g₁ inside 2.5, reads "the mean's approach to p_c is not the free form's", not "ω is wrong". Reported, not scored: the tied form's (ω = 1/ν) seven-file prediction (ln S −6.6311972 ± 0.0028634, mean 0.6834833 ± 0.0000078, g₁ +0.3636938 ± 0.0028119; already falsified by run 100) and its three z's, on which the mean and g₁ separate from the free form by about 6.7 and 8 prediction errors; the pure power law's ln S as a fourth reference with its z; the prediction's 3 × 3 covariance by the delta method from the fit's Hessian (reading_pg03_loo.covariance_error's machinery extended to the cross terms) and the joint χ² on 3 degrees of freedom of the three differences against it plus the bootstrap covariance, read against 7.8 and 14.2 and fixed as a reading and not a rule; the prediction's lower and upper half-ranges at χ² ≤ χ²_min + 1, + 6.25 and + 12.25 for each moment, to be read against 1, 2.5 and 3.5 times the sealed error (at the first they are symmetric to 1.5% already, glimpse_19683.json); the eight-file fits (run 100's seven with the set as a point at 19,683) free and tied: χ², 1/ν, ω, T = χ²(tied) − χ²(free), with and without 81, and with the set's own covariance (run 102's set, if it is scored by then, enters in a further reported refit and not in this one)
Sealed 2026-10-06, before any new sample exists (codifier). The sealed numbers — the seven-file free fit's prediction at 19,683 and its profile errors — were computed from run 100's files on 2026-10-06 by glimpse_19683.py, a pre-seal glimpse of stored numbers only, committed beside this file; no sample of H9 is drawn or read by it. The owner approved sealing with L4's three-error condition relaxed (2026-10-06, quoted in from). A second reader on the frontmatter alone and a sighted pass with the disk changed this seal before the commit; what each changed is recorded below.
L4 asked for a sixth size whose three quantities sit inside a band sealed from five, a band that excluded the single power law by at least three combined errors. With the width read as S and the second-order systematic included, the separation on ln S is 2.7 to 3.0 and, once the fit is restricted to run 100's own seven files (the ones the free form fits at 12.4 on 12), the free prediction is −6.6218 and the pure power's −6.6348, 0.0130 apart against a combined error of 0.0048. So this run is not the test that excludes a pure power law; it is a test of whether a form fitted at 81 to 6561 reaches 19,683 on three moments at once, with the chance of a pass under a pure power law written into the falsifier line. Its value to the programme is the sixth point itself: a single H9 set of 48,000 samples pins ln S there to ±0.0036 and the mean to ±6 × 10⁻⁶, which any later fit (with run 102's sharper 2187, if that confirms) can use. The mean and g₁ are where the free and tied forms part company (about 6.7 and 8 prediction errors); the tied form is already dead (run 100, T = 96.7), so that separation is reported, not scored.
The first question the owner's go left open was whether to wait for run 102 (H7, 1,500,000 samples, about nine days on BernoullisBook) and seal on the better fit. The run does not wait, for two reasons: the M5 is idle and the draw is 3.5 days; and a prediction sealed from run 100 alone is one that run 102's outcome cannot have shaped. Run 102's result, when scored, is reported beside this one's and refits are reported, not scored.
Measured, not scaled (sizing_h9.log, committed 55bc82c): H9 at 2 threads, 200 samples in 1250.51 s (user 2203 s, sys 222 s), 0.1599 a second, peak RSS 5,986,451,456 B (34.8% of 16 GiB), marginal 6.32 s a sample; at 9 threads the same job paged (swap +6.9 GB in two minutes, stopped) and on 2026-10-04 three threads paged for 40 minutes with no sample written, so the thread count is part of the seal. 48,000 samples is 83.4 hours; eight pieces of 6,000 cost at most about 11 hours each when stopped, since perc writes only at the end. 48,000 is chosen where the combined error stops falling: 24,000 gives 0.00601 on ln S, 48,000 0.00485, 96,000 0.00414, 192,000 0.00374 (the prediction's 0.00330 alone is the floor).
Second reader, frontmatter alone (an agent given the frontmatter and nothing else). Twelve findings; changed before the commit: the parameter count was ten and is nine (21 data, χ² on 12; run 102 wrote nine for its six files); control (iii) could have turned the largest possible failure into "not scored" and now scores it as written when the stage-one rerun of (i), (ii) and (vi) passes; control (vi) is new, the graph checked against the closed form M = (8/5)(8⁹ − 3⁹) that holds at H7 and H8, with the binary's run-100 H8 redraw cited as the tie to the stored sizes (the reader's worry that H9 is the first size where a 32-bit index might bite is answered by the sighted pass below); the power statement was computed with the wrong variance — the sealed prediction is a fixed number, so under a pure power z scatters with a standard deviation of 0.74, not 1, and "two in ten at least" for a falsify was wrong (it is one in eight to one in six); the rates under a true prediction and the reading of the middle band are now stated, and the free and tied forms cannot both be inside 2.5 on the mean; control (iv) tests each ratio as well as their mean; the md5-logging race (a stop between a piece's write and its md5) now discards and redraws the piece; the 24-line check compares md5s, not a file that must survive four days; the pilot's fate (unread, discarded), what sidecars may hold, a no-glimpse rule and an abandonment rule are written; the memory gate has a byte threshold and a six-hour cap; "withdrawn" and "not scored" are defined; the prediction's covariance, a joint χ² and the profile ranges at Δχ² 6.25 and 12.25 are reported, not scored; wording: the combined error 0.00485, the mean's set error, "prediction error dominates" (it is the larger part, not the whole), "in-sample prediction" (dropped: it is the sealed number), the duration (83 to about 98 hours). Not changed, with the reason: the seed scan is not rerun during the draw (the seeds are named in this file, which any later seal's scan finds); the 4/1/4-in-ten statement keeps "at most" and "at least" as the conservative direction.
Sighted pass with the disk (codifier). perc.c lines 44–75: perm (int32) holds bond indices below M = 214,716,872 and par/sz (int32) vertex indices below n = 134,217,728, both under 2³¹; E[2 * b] with b an int32 reaches 4.3 × 10⁸, under 2³¹; every loop index and allocation is int64/size_t; the draw ubound is a 128-bit multiply, unbiased to 2⁻⁶⁴; no 32-bit overflow at H9. graphs/H9.bin: size 1,851,952,720 = 16 + 8·214,716,872 + 134,217,728; header n and M as sealed; md5 as sealed; M agrees with (8/5)(8^g − 3^g) at g = 7, 8, 9. glimpse_19683.json: χ² 12.4058 on 12, 1/ν 0.52604, ω 0.30093, hessian positive definite, profile ranges symmetric to 1.5% (ln S −6.625113 to −6.618520; mean 0.6833870 to 0.6834119; g₁ 0.41566 to 0.43064); the tied fit's χ² 109.1 on 13 (run 100's T = 96.7 on the seventeen-file fit). seedscan105.py: seedscan102.py with the run number, ranges and exempt paths changed and the 7938 ruling dropped; first drawn candidates (15101–15108, 591001–591100) hit run 104's withdrawn file and were set aside; the seal's ranges returned unused on 330 scripts, 88 run files and 377 JSON files. fit100.py's bootstrap base is 511001, reading_pg03_moments.py's 471001, run 102's 526001: none inside 601001–603000.
2026-10-06, 22:00 — the memory gate was set too high for this machine; its threshold moves to 4 GiB, and nothing else moves. (Committed at 21:50, b33c612, before the draw's 22:13 start; the label "22:00" was the codifier's estimate and is kept because the lab's commit cites it. Dated notes carry their commit's time from 2026-10-07 on.) The seal set the launch gate at 9 GiB available (free + inactive + speculative pages) against a 6.0 GB footprint. On the M5 with the owner's ordinary session open, run105_m5.log shows 28 waits between 17:15 and 21:45 at 5.0 to 6.4 GB available, never near 9.66 GB; the total resident size of every process on the machine is about 3.5 GB, so closing applications does not bridge the gap (the rest is wired and compressed memory). The sizing (sizing_h9.log) ran 200 samples at two threads with 6.3 GB of swap already in use before the run and took no paging penalty by the sys-against-user test (sys 10% of user). The gate protects the draw from the 9-thread and 3-thread failures (swap growth of 7 GB in two minutes), which it would catch at any threshold above the footprint's shortfall; it is a launch guard and not a statistic. The threshold becomes 4 GiB = 4,294,967,296 B (a machine that cannot offer that is the one that pages), the wait, the cap of 36 waits, the thread count (2), the pieces, seeds, bounds, controls and the sealed machine unchanged, and each piece's times105.txt line gains the user and sys seconds of its draw so a drift into paging is visible. Nothing has been drawn: samples105/ does not exist and no piece has launched. The stopped wait loop is not an edited running script: the lab ends the waiting run105.sh, edits GATE in it as a new commit, and starts it again; the statistic line's "9 GiB" is superseded by this note, as run 102's expects was.
2026-10-07, 09:25 — piece 0 is drawn; its user and sys seconds are in the .err file, not in times105.txt. run105.sh reads /usr/bin/time's first line with $2=="user" and $2=="sys"; on macOS that line is <real> real <user> user <sys> sys, so the wall time is read and the other two columns are written empty (user_s= sys_s=). The values are on disk in samples105/H9_p<i>.err, which the script keeps: piece 0 took 33,769.43 s wall, 65,864.33 s user and 1,261.39 s sys at two threads (sys 1.9% of user, 4 page faults, peak RSS 5,986,942,976 B), 0.1777 samples a second against the sizing's 0.160. The running script is not edited; the analysis reads user and sys from the .err files, and the next draw script reads fields 3 and 5. No piece's contents have been read. Found by the designer's console mockup (docs/design/2026-10-07-resonance-console.md §E.5), which printed the empty columns as a missing sensor. running: is set in the frontmatter today by the codifier; the lab's prompt did not ask for it at launch, which OPS's rule does.
2026-10-07, 10:25 — the reductio owed before the seal was run today, and the sharpness reader was not run at all. FLOW's step 3 names three readers before the commit (sharpness on the seal, the second reader on the frontmatter, the reductio on the lead) and OPS requires a reductio beside every lead about to be sealed. This seal had the second reader and the sighted pass only; the omission is the codifier's. The reductio was run on 2026-10-07 by an agent given the lead and the numbers it refers to, before any piece's contents were read by anyone. Its findings concern the lead alone and are filed under the lead, below, where a lab chat does not read. Nothing sealed changes: no seed, bound, control or clause. The lead stands as written and is scored as written.
2026-10-07, 15:13 — three corrections to the record, from an outside reader (the Episodes project, given this file without its lead). (1) 0.74 should read 0.73. The falsifier line and the Readers section say that under a pure power z_ln S "scatters with a standard deviation of 0.74"; the second reader wrote 0.00356/0.00485 = 0.73, and from the sealed figures it is 0.00355/0.004845 = 0.733. The probabilities beside it (0.40, 0.13 to 0.18, 0.40 to 0.47) were the reader's, computed at 0.73, and stand. A rounding slip in prose; the sealed field is not edited. (2) Who made the sighted pass. FLOW gives it to an agent with the disk, read-only; here the codifier made it, and the section's heading says so. It read control members only (the source, the graph's header, the prediction file), which is what the role allows, but it was not a second pair of eyes. (3) Samples at this size before the seal. The sizing pilot's 200 samples (sizing_h9/r200.txt, seed 15001) were on disk at the seal and at the sighted pass, unopened then and since; "no sample existed" would be wrong, "no sample was opened" is right. Also today: piece 0's sidecar and .err are committed (samples105/H9_p0.txt.json, H9_p0.err); FLOW has the lab commit a sidecar per draw, and no chat is attending this draw, so the codifier commits each as it lands. Neither file holds a statistic of the samples.
2026-10-10, 23:30 — the draw is finished; nothing has been read. (codifier) run105_m5.log ends ALL_FINISHED m5 2026-10-10T00:41:37. Eight pieces of 6,000 lines, seeds 16101–16108, each with its md5 in times105.txt and its sidecar; wall times 33,015 to 34,444 s a piece (about 9.3 hours, 0.18 a second against the sizing's 0.160), 74.5 hours of drawing for the set against the expected 83 to 98. No piece waited at the 4 GiB guard after the 2026-10-06 change; piece 7 launched with 8.78 GB available. No piece file has been opened and no moment computed; stage one has not run. running: is cleared today. The analysis goes to a fresh lab chat, stage one first.
2026-10-10, 23:50 — stage one is written; every control passes; no z exists. (codifier) A fresh Claude Code lab chat ran fit105.py stage1 in the lab environment (~/mapofmath/.venv: Python 3.14.7, numpy 2.5.3, arm64) and committed fit105.json with report105.py and report105_pred.json (8b75a5d, MANIFEST ff3b0f1). Controls (i) and (vi) rerun, (ii), (iii), (iv) (ratios 0.940, 0.976, 1.100; mean 1.005) and (v) (47,993 windows, none repeated) pass; withdrawn false; the x₀ check covered 48,200 states. The set's moments and bootstrap covariance are in the block as written and are not restated here. report105.py (new; fit105.py unchanged; reads no sample) adds the reported-not-scored half-ranges at +1, +6.25 and +12.25 and the delta-method 3 × 3 covariance; its +1 level equals profile_error to 10⁻⁹, and at the higher levels it widened the starts by √level and took the best extremum — the lab's judgment call within "extended to the higher levels", recorded here. The joint χ² waits for stage two. The lab read the run file to the line before "Not part of the seal" and no further. Its envelope: Claude Code's auto-memory index of eight procedural entries (commit paths, zsh globbing, cypari2 precision, seed checks, the panel dataset, a running script, schemas, commit -o), none about this run; Code has no memory switch (FLOW, 2026-10-10). Stage two waits for the owner's go.
confirmedScored on 2026-10-10, Phoenix time, from R27_tree_groups/carpet_perc/RESULTS105.md, fit105.json, report105_pred.json and report105_joint.json (stage one 8b75a5d, stage two a7403d8). A scoring reader, given the seal's scored quantity, clause and falsifier and the lab's numbers, without the lead, recomputed the three z's (agreeing to 6 × 10⁻⁶, 2.4 × 10⁻⁴ and 2 × 10⁻⁶; the mean's largest because the sealed error is printed to three figures), applied the rule and named the outcome; its two corrections are folded in below.
From: PG-03's line L4, sealed with its condition relaxed. What the run did to it: the free one-term form, fitted on five sizes, reached the sixth on all three moments at once.
Controls. All six pass (dated note of 2026-10-10, 23:50): (i) and (vi) rerun exactly; (ii) eight pieces, every md5 as logged, the 24-line redraw tie, the x₀ check on 48,200 states; (iii) inside its gross bounds; (iv) ratios 0.940, 0.976, 1.100, mean 1.005; (v) no run of 8 repeated in 47,993 windows.
The scored quantity. On 48,000 samples at 19,683: ln S = −6.6132883 ± 0.0036621, mean 0.6834130 ± 0.0000061, g₁ +0.404956 ± 0.016525. Against the sealed free prediction, z = +1.733 (ln S), +0.971 (mean), −0.999 (g₁); Q = 1.733, on ln S. The clause asked for Q < 2.5: confirmed.
What a confirm says, by the seal's own readings. The free one-term form fitted on run 100's seven files reaches the sixth size on three moments at once, within combined errors of 0.0049 (ln S), 1.39 × 10⁻⁵ (the mean) and 0.018 (g₁). The seal said 0.013 for g₁; the set's bootstrap error on g₁ (0.0165) is larger than the seal's estimate, so the test on g₁ was about 40% looser than stated (the scoring reader's correction). The seal also says a confirm does not exclude a pure power law, and as a scored statement that stands: no clause of this run was written on the pure power.
Reported, not scored. - The pure power law's ln S (−6.6348 ± 0.0026, a reading of ten stored points that are not run 100's files): z = +4.37 on the sealed denominator, +3.86 with its own error folded in. The seal expected the pure power about 2.7 combined errors below the free prediction; the set came in above the free prediction, so the pure power sits 3.9 to 4.4 below the set. L4's sealing condition (the pure power at least 3 combined errors outside) is met by this reference after the fact. That is a reading of a reported number and settles nothing; whether to seal on it is the programme's question (PG-03, status 2026-10-10). - The tied form (ω = 1/ν, already falsified by run 100): z = +3.85, −7.11, +2.46. The mean separates it from the free form, as the seal said it would by construction. - The joint χ² of the three differences against the delta-method prediction covariance plus the bootstrap covariance: 6.384 on 3 (survival 0.094), under the reading line of 7.8. The diagonal sum of z² is 4.95; the difference is the cross terms (the prediction's mean–g₁ correlation is −0.65). - The prediction's half-ranges at +1 are symmetric to 1%; at +6.25 they run 2.45 to 2.55 and at +12.25 3.39 to 3.61 times the sealed error, straddling 2.5 and 3.5: the one-error profile scales as a parabola would, within 4%. The higher levels used the lab's widened starts (note of 23:50). - Eight-file fits (run 100's seven and this set): free χ² 18.82 on 15, tied 186.89 on 16, T = 168.1; without 81, free 1.44 on 9, tied 9.34 on 10, T = 7.90. Free 1/ν 0.5248 and ω 0.3134 with 81; 0.5181 and 0.3585 without. Run 102's set is not in these and is still drawing.
generated 2026-10-25the lab index