Subagent report: stage 4, items 4a / 4b / 4c (2026-09-04)

Provenance: Claude Code implementation/numerics subagent, model Opus 5 (1M context), claude-opus-5[1m], run 2026-09-04 on the GB10 (spark-709c), dispatched by the Fable main loop against the registration in docs/next-stage-plan-2026-09-04.md §5 (items 4a, 4b, 4c only; §2 and §3 read as context). The readings registered there are FROZEN: this report states each one PASS or FAIL as registered and does not reinterpret it. Item 4d was worked in parallel by a second subagent in experiments/05_thin_even/ and is not touched here. Git untouched by this subagent — the main loop commits.

Artefacts, all under ~/repo/project/ice-mixing/:

No existing icemix function was modified; the three new modules are purely additive. Every number below is in experiments/04_lorentzian_giant/results/results.json.

0. Bottom line

Headline: 4b (ii) FAILS, and it fails at the 16-spin cell with a three-bond certificate. Per the registration (docs/next-stage-plan-2026-09-04.md §5, 4b), “a FAIL at (ii) closes the Lorentzian lead”; per §7.4, item 3 (the matching lower bound Δ ≳ L⁻²) opens only if 4a and 4b both pass, so it stays closed. 4a passed cleanly and without qualification — see §2.5 for the one methodological trap that had to be disarmed before that PASS meant anything.

No counterexample to (NF⇒G) was found; the conjecture survives 27,000 fresh and adversarial starts at cubic L = 2 and L = 3, all of them either frozen (13) or certified into the giant (26,987).

1. Pre-flight (measured, then multiplied out)

Every computation below was timed on one unit before launch. Rates are on the GB10 (spark-709c, 20 cores); no GPU is used anywhere in 4a/4b/4c.

Total projected ≈ 41 min, over the 10 min threshold, so the job was run detached in a named tmux session with a canonical exptop.progress.ProgressReporter feed (ice-mixing stage 4abc). Launch was verified each time: PID alive, feed advancing (heartbeat_at moving, phase/step/message updating). The actual course of the run — a code defect, a pre-flight miss, and the main loop’s contention notice — is in §5, with every launch, its PID, its feed card and its final status.

Grep for a vendored progress reporter, as required: grep -rl "class ProgressReporter" --include='*.py' . | grep -v .venv returns nothing — this repo has no fork. It does, however, have a home-grown feed; see defect D1.

Memory was checked before every launch. free -g reported 88–93 GB available of 121 GB throughout (an RSS-invisible resident, a spin-ice job from another session, and the parallel 4d subagent share the machine). Recorded peak RSS per run is in §5 and in results.json (items.<item>.resource); the largest was 4.216 GB, the (2,2,2) DP probe. On the main loop’s contention notice the 4c worker count was cut from 6 to 4 and OMP_NUM_THREADS/OPENBLAS_NUM_THREADS /MKL_NUM_THREADS were pinned to 4; 4a, 4b and 4c were run strictly one at a time thereafter.

2. Item 4a — sector log-concavity

2.1 What was computed, and the two-method gate

The exact joint winding histogram N(Wx, Wy, Wz) from icemix.enumerate.frontier_count(lat, track_axes=(0,1,2)) — a frontier DP that never materialises a state — at every registered cell up to the largest feasible one. At every cell where the state fits a 64-bit word and the count is inside the enumeration budget, the whole histogram (not just the total) was recomputed from the materialised DFS enumeration (enumerate_ice_states + winding) and compared entry by entry.

All totals and all W = 0 counts reproduce stage 1’s table exactly. At (1,2,3) the cross-check is unavailable for a hard reason, not a budget one: enumerate_ice_states packs a state into a single 64-bit word and raises for n_bonds = 96 (defect D3).

2.2 The trap that had to be disarmed first: the divisor artefact

The support of N is not all of Z³. Computed from the histogram (not assumed): the support is a coset of a sublattice L ⊂ Z³ of index 8 at every cell, with basis in row-echelon form

So W ± e_j is simply not a lattice point: the literal reading “N(W)² ≥ N(W−e_j)N(W+e_j)” is satisfied vacuously (N = 0 on both sides) and every axis line would appear riddled with “internal zeros”. Reporting a PASS on that basis would be worthless and reporting a FAIL on the internal zeros would be a fabricated result. icemix.logconcave therefore computes the support lattice by integer row reduction and, for each direction v, the least positive t with t·v ∈ L (the primitive lattice vector in that direction); every line test below is on those points. The step is 2 for every direction at every cell.

This is the one place where the registered wording and the lattice disagree, and the resolution is recorded here rather than silently applied: the substantive reading is on the primitive lattice vector, and that is what “PASS” below means. The unrescaled reading is separately true and vacuous.

tests/test_stage4abc.py carries two negative controls (test_a_diagonal_violation_would_be_caught, test_an_internal_zero_would_be_caught) so the PASS is not a test that cannot fire.

2.3 The readings

Discriminant = min over lines and interior points of N(W)² − N(W−e)N(W+e), in exact Python integers, e the primitive lattice vector of that direction.

(i) SYMMETRY gate — PASS. The candidate group at each cell is the set of signed axis permutations that preserve the cell’s extents: all 48 at the cubic (1,1,1), 16 at (1,1,2)/(1,1,3)/(1,1,4) (swap of the two equal axes × 8 sign patterns), 16 at (1,2,2), 8 at (1,2,3) (sign changes only). Which of them N actually obeys was measured, not assumed, and at every cell the answer is all of them. Inversion W → −W holds separately at every cell.

(ii) AXIS log-concavity — PASS. Every line, every cell; minimum discriminant strictly positive everywhere (52 at the smallest cell). No internal zeros: the support along every axis line is an interval.

(iii) DIAGONAL log-concavity — PASS. All six face diagonals e_j ± e_k and all four body diagonals e_x ± e_y ± e_z, every cell. The tightest case in the whole item is the face diagonals at (1,1,1) (discriminant 3), (1,1,2) (10) and (1,2,2) (10) — positive, but not by much. At (1,1,1) every body-diagonal line has at most two support points, so there is no interior term to test; that is recorded as “no interior”, not as a PASS with content.

(iv) The (111) marginal — PASS. s = Wx + Wy + Wz is log-concave with interval support at every cell, on a support of step 2. This is the direction the spin-ice repo’s Theorem D already covers (the layer stack there is this lattice), so it is the check of Theorem D’s prediction on this lattice, and the prediction holds. The distribution at (1,1,1) is exactly flat over its three interior values (9, 24, 24, 24, 9), so the discriminant there is 0 — log-concave with equality, not a violation.

2.4 Marginals of each Wj

All are log-concave with interval support and step 2. Exact counts:

The full lists, and the (111) marginals, are in results.json (items.4a.cells.<cell>.analysis.marginals).

2.5 What a 4a PASS does and does not mean

It means the joint winding-sector counts on the fully periodic torus are log-concave along every lattice line tested, in exact integer arithmetic, at every cell reachable by the DP — including (1,2,3), a 96-spin cell with 3.08×10⁹ ice states that no enumeration can touch. That is the falsifier the plan registered, and it did not fire.

It does not mean the generating polynomial is Lorentzian, and 4b now says it is not even pairwise-negatively-correlatable in any diagonal gauge. The two readings are independent: 4a is about the coefficient sequence of the flux grading, 4b about the bond variables themselves.

2.6 (2,2,2): not run, with the projection

The cubic L = 2 cell is the one that would test cubic geometry, and it is out of reach for the joint-winding DP. The bounded probe (registered budget 8×10⁶ keys) is in results.json under items.4a.dp_probe_222, with the full per-step curve:

• reached step 41 of 128 with 8,661,950 frontier keys, 4.216 GB RSS, in 259 s;
• observed tail growth 1.2114 keys/step, throughput 215,576 key-updates/s;
• the frontier peaks near the middle of the bond schedule (step ≈ 64), giving a projected peak of 7.1×10⁸ keys ≈ 347 GB and ≈ 3.7 h wall.

347 GB does not fit a 121 GB machine and 3.7 h exceeds the 3 h rule, so it was not attempted. Stage 1 recorded the same cell as infeasible for the untracked DP at 10.5M keys; this is the quantified version for the tracked DP. A better bond schedule (minimising the frontier width rather than closing sites early) is the only obvious lever and was not explored.

3. Item 4b — gauge-signability of bond correlations

3.1 Method, and the two-method gate on every count

For each cell and each of the three measures, the exact integer statistics N, n_i = #{x_i = 1}, n_ij = #{x_i = x_j = 1} were computed by two independent routes and required to agree bit for bit:

• route 1 — dense 0/1 matrix X, chunked XᵀX in float64 (every entry a non-negative integer below 2⁵³, with an assertion that the accumulation stayed exact and integral);
• route 2 — one packed bitset per bond over the state index, n_ij = popcount(b_i & b_j).

They agree everywhere (pair_statistics raises otherwise). The covariance is the exact integer C_ij = N·n_ij − n_i·n_j, which is N²·Cov(x_i, x_j).

The three measures: A uniform on the full ice manifold, B uniform on W = 0, C uniform on the giant component of W = 0. Measure C is skipped at (1,1,1), where the W = 0 sector is wholly frozen (12 states, 12 singleton components) and there is no giant.

One exact structural check falls out and is confirmed at every cell and measure: complementing every arrow maps the ice manifold to itself and sends W → −W, so it fixes W = 0 and (stage 1) permutes components with the giant closed under it. Hence n_i = N/2 for every bond — verified in every row below.

3.2 The counts

(i) PLAIN GAUGE — the registered prediction HOLDS. At least one strictly positive pair covariance in every measure at every cell, including (1,2,2), the only cell here with a genuine 2-D cross-section. In fact roughly half of all pairs are positive (49–60 % depending on cell and measure), so this is not a marginal effect.

(ii) SIGNABILITY — FAIL, everywhere. No diagonal signing s ∈ {±1}^bonds makes s_i s_j C_ij ≤ 0 for every pair, in any of the eleven cell/measure combinations tested.

3.3 Three independent decision procedures, and a hand-checkable certificate

The FAIL is not left resting on one implementation.

1. Union–find with parity on the constraint graph (edge for every nonzero C_ij, requiring s_i s_j = −sign(C_ij)): unsatisfiable.
2. An odd-cycle certificate from a BFS spanning forest — an independent traversal, not the union–find — extracted at every cell and measure. Every certificate found is a triangle.
3. Exhaustive scan of all 2¹⁵ signings at (1,1,1) (both measures): none works. This agrees with (1) and (2); the run asserts the agreement.

The (1,1,1) measure-A certificate, in full, so a reader can check it by hand from N = 90 and n_i = 45:

The three constraints force s_15 = s_0 = s_1 and s_1 ≠ s_15. No sign gauge exists, and the obstruction lives on three bonds of a 16-spin cell. The two negative constraints are the local 2-of-4 hypergeometric negativity at the two shared sites; the positive one is a next-nearest bond pair. That is the whole content of the FAIL: the dipolar sign structure of the ice correlations produces an unbalanced triangle at the smallest possible scale, so nothing about growing the cell can rescue it.

Every certificate found, at every cell and measure, is a triangle — the obstruction is always three bonds, never a long cycle. In measure A they are [15, 0, 1] at (1,1,1), [31, 0, 1] at (1,1,2), [47, 0, 1] at (1,1,3) and [63, 0, 1] at (1,2,2); measures B and C give the same or a sibling triangle ([31, 0, 3], [47, 0, 3]). All eleven are in results.json under items.4b.cells.<cell>.measures.<M>.odd_cycle_certificate, each with the covariance sign and the required relation on every edge.

3.4 Nearest-neighbour sanity — and a correction to its premise

Two bonds meeting at a site are, in every state, two of the four incident bits of which exactly two are set. The brief asked for this to be asserted as a negative correlation. Result:

• measures A and B: PASS at every cell — all 48 / 96 / 144 / 192 site pairs strictly negative.
• measure C at (1,1,2): FAIL. Of the 96 site pairs on the 160-state giant component, 64 are negative and 32 are positive, each with C = +320.
• measure C at (1,1,3) and (1,2,2): PASS.

This is not a bug, and it is worth stating precisely because the premise as written is too strong. What the 2-of-4 constraint proves is a sum rule, not a per-pair sign: at each site the six pair-products sum to 1 in every state, so Σ n_ij = N over the six pairs, and with n_i = N/2 throughout, Σ C_ij = N² − 6·N²/4 = −N²/2 < 0. The average of the six is forced negative; the individual signs are not. On the (1,1,2) giant that average is realised as four pairs at C = −3360 (n_ij = 19) and two at C = +320 (n_ij = 42); 4·19 + 2·42 = 160 = N, exactly as the sum rule requires. The full ice manifold has enough symmetry to make all six negative; the giant component of a shattered quasi-1D cell does not. Stage 1 already flagged (1,1,c) cells as pathological, and this is another instance.

Recorded, not hidden: the run records the offending pairs rather than asserting and aborting, precisely so this could be reported.

3.5 Reading (iii) — not run, as registered

The registered trigger is “if (ii) PASSES at (1,1,1) or (1,1,2) in measure (A)”. It failed at both, so the strong-Rayleigh necessary condition under conditioning was not run. The machinery exists and is tested (icemix.signgauge.conditional_violations); a pre-flight at (1,1,1) with the trivial all-+1 gauge showed the full sweep of 98,280 (pair, conditioning) triples costs 0.1 s, and the (1,1,2) sweep of 1.94×10⁶ triples ≈ 20 s, so cost was never the obstacle — the trigger simply did not fire. This is recorded in results.json under items.4b.conditional_check.

3.6 What the 4b FAIL settles

Per the registration, “a FAIL at (ii) closes the Lorentzian lead”. It closes it in the strongest available form: not “we could not find a gauge at the sizes we could reach”, but “no gauge exists, at the smallest cell, and here is the three-bond reason”. The §3 tempering in the plan anticipated exactly this (“the uniform ice measure has dipolar correlations whose sign depends on the pair’s orientation, so bond indicators are not pairwise negatively correlated in the plain gauge”) and asked whether a complement gauge rescues it, as it did in the spin-ice repo. It does not, here.

4. Item 4c — the conjecture (NF⇒G)

4.1 (1,2,2) exhaustive, recomputed

Recomputed from scratch (not quoted from stage 1): W = 0 enumerated with zero_winding_only, the flip graph built, components taken.

PASS, exactly reproducing the stage-1 census (30.0 s). (NF⇒G) is therefore exhaustively true at (1,2,2): every non-frozen W = 0 state is in the giant, because every state outside the giant is a frozen singleton.

4.2 Cubic L = 2 and L = 3

Two samplers, as registered: sample_w0_dfs (randomised ice-rule DFS then loop-driven to W = 0 — fresh states with no memory of any component) and sample_w0_loops with small n_loops (contractible loop reversals from the frozen Klein state — near-frozen adversarial starts). Each non-frozen start went through certify_connected to the reference state R, and any failure was retried at a 16× budget with 6 restarts before being called uncertified.

Neither sampler is uniform, and sample_w0_dfs additionally rejects a fraction of its own attempts (defect D2), which biases it further. The frozen fractions below are informative, not measure-theoretic.

Reading (i) — PASS. (frozen, certified, uncertified) = (11, 16989, 0) at L = 2 over 17,000 starts and (2, 9998, 0) at L = 3 over 10,000 starts. Not one non-frozen start failed to produce an explicit flip-path to R. This extends stage 2’s 780/780 at L = 2 by a factor of 22, and takes the conjecture to L = 3 (432 spins) for the first time.

Reading (ii) — no counterexample arose. The bounded BFS is armed but was never invoked, because there were no uncertified non-frozen starts. Had one arisen, icemix.component.bfs_component would have closed its component under a 10⁶-state / 1800 s cap and reported “closed, size N, R not found” (a counterexample) or “inconclusive” (never a FAIL). The machinery is tested against the exact component decomposition at (1,1,2), where it reproduces the 160-state giant, and against the 12 frozen singletons at (1,1,1).

Reading (iii) — frozen fractions. Under the fresh sampler the frozen fraction is 0 at both sizes: 0/10,000 at L = 2 and 0/3,000 at L = 3, so the sampler simply never lands on a frozen state (its minimum flippable count was 11 at L = 2 and 55 at L = 3 — it does not even come close). That is why the loop sampler is the one that matters: with n_loops = 1 it produces frozen states at 1.10 % (L = 2) and 0.10 % (L = 3), and by n_loops ≥ 3 the frozen fraction is 0 at both sizes and the median flippability has saturated. Alongside stage 1’s exact 0.092 % at (1,2,2), the picture is consistent with a frozen density that falls with size — but none of these three numbers is a uniform-measure estimate, and the two samplers disagree by more than the size dependence, so no rate should be read off them.

The n_loops sweep also shows the adversarial construction working as designed: one loop reversal off the frozen Klein state leaves a median of 14 (L = 2) / 16 (L = 3) flippable hexagons against the equilibrium 23 / 74, so these really are near-frozen starts — and all of them certify into the giant.

4.3 Measured cost, against the pre-flight

The L = 3 fresh sampler was the one pre-flight miss of this stage and it is recorded as such: a 5-sample timing gave 0.87 s per sample_w0_dfs, but the production mean over 3,000 starts is 3.32 s — 3.8× the pre-flight, with a sampler retry rate of 0.419 rejections per accepted start (defect D2) that the small sample had not seen. At the original 10,000-start target that would have been a ~3 h phase against a 26 min projection. It was caught at ~600 starts by reading the live feed, the run was stopped, and L = 3 was resized to 3,000 fresh starts to fit the registered “~1 h per size” — 2,723 s in the event. L = 2 cost 314 s for 17,000 starts (mean sample 0.0018 s).

Lesson recorded: five samples were not enough to pre-flight a rejection-sampling loop with a heavy tail. A pre-flight of a sampler that can reject should time ≥100 units, not 5, and should report the rejection rate.

4.4 What 4c does and does not establish

It is 27,000 more consistent observations, at the two smallest cubic cells, and no counterexample. It is not a proof, and the samplers’ non-uniformity means it is not even a bound on the density of a hypothetical non-frozen non-giant component: such a component would have to be missed by both samplers, and the loop sampler at n_loops = 1 is precisely the probe designed to find one. (NF⇒G) stands as a registered conjecture with exhaustive support at (1,2,2) and 27,000/27,000 at L = 2, 3.

4.5 (1,2,3) exhaustive census — not attempted, with three blockers

1. Hard representation blocker (D3). (1,2,3) has 96 bonds. enumerate_ice_states raises for n_bonds > 64, and build_flip_graph / components / verify_reference_in_giant all assume a uint64 state word. The census is not expensive-but-possible; it is impossible without a new state representation.
2. Wall clock. At the measured DFS leaf rate (≈1.0×10⁵ states/s from (1,1,4)’s 9,765,378 states in 98 s) the ≈3.08×10⁹-node tree projects to ≈8.5 h, well over the 3 h rule.
3. Memory. 196,465,480 W = 0 states as a Python list then a sorted uint64 array is ≥16 GB before the graph, and the flip graph would carry ≈9.4×10⁹ edges (96 hexagons × 1.96×10⁸ states / 2) — far beyond what scipy.sparse can hold on a 121 GB machine.

The counts quoted (3,076,306,362 ice states; 196,465,480 at W = 0) are stage 1’s frontier-DP values, re-derived by this run’s own DP at (1,2,3) and agreeing exactly.

5. Run ledger — every launch, its feed card, its footprint

All on spark-709c. Feed cards live at ~/.local/state/exptop/feeds/spark-709c/ice-mixing-stage-4abc-<pid>. The final status of every card this stage created is listed; none is left saying “running”.

Per-item wall clock inside r6: 4a 350 s (of which the (2,2,2) bounded DP probe is 259 s and the (1,1,4)+(1,2,2) enumerations 125 s), 4b 131 s (of which (1,2,2) alone is 129 s). Inside r5: (1,2,2) census 30 s, L=2 314 s for 17,000 starts on 4 workers, L=3 2,723 s for 10,000 starts on 4 workers.

Peak-RSS caveat, stated because the number would otherwise mislead: getrusage reports a cumulative high-water mark per process, so 4a and 4b share the 4.216 GB figure in r6 — that peak is 4a’s (2,2,2) probe, not 4b’s. Measured separately during pre-flight, the (1,2,2) 4b computation (2.89×10⁶ states × 64 bonds as a dense matrix plus the chunked XᵀX) peaked at 1.86 GB.

Four cards were left saying “running” with a dead PID (r1–r4) and are a recorded defect of this stage’s operation. Diagnosis, since the canonical reporter does install SIGTERM/SIGINT handlers that stamp a card terminal: all four were stopped with tmux kill-session, which delivers SIGHUP, and SIGHUP is not among the signals the reporter handles — the process dies before __exit__ runs. It was not SIGKILL and not a hung pool. All four have since been stamped failed with an explanatory note (by the main loop and again here), and their stale experiment.pid files removed. Two changes follow: run_stage4abc.py gained a --no-feed flag so sub-minute dry runs (d1–d5 above, which should never have created cards) do not, and the practice for stopping a run is now kill -TERM <pid> — never tmux kill-session — so the reporter’s own handler does the stamping.

6. Defects recorded

D1 — this project’s progress feed is invisible to exptop, and exptop is not importable from the interpreter the project uses. pyrun.sh info fails (“no .venv/ found”); the project runs on the pyenv 3.12.13 interpreter with numpy 1.26.4 / scipy 1.17.1 / pytest 9.0.2 installed system-wide, and exptop is not among them. Separately, experiments/01_falsifiers/run_falsifiers.py (and its stage-2/3 successors) define a private Progress class writing results/progress.json — a path outside the exptop feed root, so those runs were never discoverable by exptop/monitor.sh. It is not a ProgressReporter fork (the required grep finds no class ProgressReporter anywhere in the repo), but it has the same operational consequence. The stage-4 run script uses the canonical exptop.progress.ProgressReporter and puts ~/repo/project/exptop/src on sys.path to reach it. Suggested fix for the main loop: pip install -e ~/repo/project/exptop into this interpreter (or give the project a venv), then retire the three private Progress classes.

D2 — icemix.start.sample_w0_dfs raises on a non-negligible fraction of seeds at cubic cells. The randomised ice-rule DFS exhausts its 4×10⁶-node budget (RuntimeError: random_w0_state: node budget exceeded), and the subsequent loop drive can fail to reach W = 0. Measured rejection rate: 0.000 per accepted start at L = 2 and 0.419 at L = 3 (recorded per start in results.json as sampler_attempts, aggregated as sampler_retry_rate). Stage 2’s 780-start probe must have met the same behaviour. The stage-4 run wraps the call in a bounded retry (fresh RNG stream, ≤ 40 attempts) and records the retry count per start, because the rejection is one more source of non-uniformity in an already non-uniform sampler. Nothing in icemix was changed.

D3 — the enumeration and component machinery is hard-limited to 64 spins. enumerate_ice_states raises for n_bonds > 64, and build_flip_graph, components and verify_reference_in_giant all assume a uint64 state word and searchsorted over a materialised array. This is why the (1,2,3) exhaustive census (96 bonds) is not merely expensive but impossible with the current representation, and why the 4a cross-check stops at (1,1,4). The new icemix/component.py uses Python big integers and has no such limit, but it closes one component at a time and is not a substitute for a full census.

D4 (methodological, §2.2) — the winding support is a coset of an index-8 sublattice of Z³. Any log-concavity reading stated on W ± e_j without rescaling is vacuous, and any “internal zeros” reading stated that way is a fabricated FAIL. Recorded here because the registration’s wording does not say it and a later reader could easily re-derive the wrong answer.

D5 (§3.4) — “bonds sharing a site are negatively correlated” is not a theorem. The 2-of-4 constraint forces only the sum over the six pairs at a site to be negative. The per-pair statement holds on the full manifold and on W = 0 but fails on the giant component of (1,1,2).

D6 (mine, §5 r1) — a refactor broke the multiprocessing initialiser nine minutes into the run. Moving bfs_component out of the run script into icemix/component.py dropped hex_ops from the imports, but _c_init still called it; the dry run had passed before the refactor. multiprocessing turns that into an infinite worker-respawn loop rather than a clean crash, so the parent kept “running” and only the log showed the fault. Cost: the 4c phase of r1. Rule taken from it: re-run the dry run after every refactor, however cosmetic, before a detached launch — and, separately, a pool whose initialiser fails should abort the run, not respawn forever.

D7 (mine, §5) — four zombie feed cards. Stopping a run with tmux kill-session sends SIGHUP, which the canonical reporter does not handle (it handles SIGTERM and SIGINT), so the card was never stamped terminal and read as a hung job in exptop. Raised by the main loop; all four stamped failed with notes and their stale experiment.pid files removed. Two fixes adopted: --no-feed for sub-minute probes, and kill -TERM instead of tmux kill-session. A note for exptop itself: adding SIGHUP to the reporter’s handled signals would close this class of zombie card, since tmux/ssh teardown is the ordinary way a detached run dies.

D8 (mine, §4.3) — a five-sample pre-flight of a rejection sampler. sample_w0_dfs at L = 3 measured 0.87 s over 5 samples and 3.32 s over 3,000, because the small sample missed the retry tail (0.419 rejections per accepted start). The projection was out by 3.8×. Caught from the live feed at ~600 starts, not from a log. Rule: pre-flight a sampler that can reject with ≥100 units and report its rejection rate.

7. What was NOT run, and why

8. Unexpected (not part of any registered reading)

1. The winding support is a sublattice coset of index 8 at every cell (§2.2). The registered log-concavity readings, taken literally on W ± e_j, are vacuously true, and the internal-zero reading taken literally would fail everywhere for a reason with no content. Anyone re-deriving 4a must rescale to the primitive lattice vector first. This is the single most likely way for a later reader to reach a wrong conclusion from the same data.
2. The signability obstruction is local — three bonds — and it is local at every cell and every measure. Every one of the eleven odd-cycle certificates is a triangle, and the (1,1,1) one is two site-sharing pairs (negative, from the 2-of-4 constraint) closed by one next-nearest pair (positive). Growing the cell cannot repair that: whatever else changes, a 16-spin motif with an unbalanced triangle is present. This makes the 4b FAIL much stronger than “no gauge was found at the sizes we could reach”.
3. The tightest 4a margins are on the face diagonals of the two smallest 3-D-ish cells — discriminant 3 at (1,1,1) and 10 at (1,2,2), against 10³–10⁷ elsewhere. If log-concavity fails anywhere on this lattice family, the face diagonals of small cells are where to look.
4. Structural zero covariances appear only in the restricted measures. The full ice manifold has no zero pair covariance at any cell; W = 0 has 128 at (1,1,2) and 384 at (1,1,3), and the (1,1,2) giant has 16. Fixing the flux (and then the component) creates exact independences that the unconstrained measure does not have.
5. Nearest-neighbour negativity is not a theorem and fails on the (1,1,2) giant: 32 of 96 site pairs are strictly positive (§3.4). The 2-of-4 constraint gives a sum rule, not a per-pair sign.
6. The fresh W = 0 sampler is useless as a frozen-state probe. Its minimum flippable count over 13,000 cubic draws was 11 (L = 2) and 55 (L = 3) — it never goes near the frozen set. Everything informative about frozen states at cubic sizes comes from the loop sampler at n_loops = 1. Any future frozen-density estimate must not be built on the DFS sampler.
7. The (1,1,1) (111) marginal is exactly flat across its interior (9, 24, 24, 24, 9), so its log-concavity discriminant is 0 — the boundary case, satisfied with equality rather than slack.
8. (1,2,3) carries 453 winding sectors, not the 217 of (1,2,2) — the sector count is not a function of volume, and stage 1’s table did not record it.

9. Tests

tests/test_stage4abc.py adds 30 tests, all passing (1.19 s standalone), covering the three new modules:

• the integer lattice machinery — that a generating set reduces to a basis of the right index, that a non-diagonal (checkerboard) sublattice is handled, that the primitive step along each direction of the (1,1,1) winding support is 2 and the index is 8;
• the one-dimensional tests, including two negative controls (test_a_diagonal_violation_would_be_caught, test_an_internal_zero_would_be_caught) so that the 4a PASS cannot be a test that is incapable of firing;
• the joint histogram against the materialised enumeration at (1,1,1) and (1,1,2) — the same two-method gate the run applies;
• the pair-count routes against each other and against a third naive count on a random matrix; the n_i = N/2 consequence of global arrow reversal;
• the balanced-signing decision three ways — union–find with parity, the odd-cycle certificate, and brute force — cross-checked against each other on 25 random covariance matrices, plus the (1,1,1) headline FAIL by all three;
• the bounded BFS against the exact component decomposition (it reproduces the 160-state giant at (1,1,2)), against the 12 frozen singletons at (1,1,1), and the cap path (which must report inconclusive and must not report a size it cannot prove).

Whole suite, run after every change including the icemix/__init__.py export: 248 passed, 7 skipped in 1120.20s (0:18:40), exit code 0, from 255 collected. The 255 is 182 from stages 1–3, plus this stage’s 30, plus 43 from the parallel 4d work (tests/test_stage4d.py 26, tests/test_stage4f.py 17); the 7 skips are in that parallel work, not in stage 4abc’s, whose 30 all pass.

Per-file collection at the end of this stage:

icemix/__init__.py now imports and exports the three new modules alongside the 4d subagent’s parity; import icemix and the three submodule imports were verified after the change.

One environment note for whoever runs this next: pytest -q suppresses the summary line under pytest 9.0.2 here — it prints the progress dots and nothing else, which makes a -q run look truncated. Run plain python3 -m pytest to get “N passed” back.