Job #1073 — check of return #441, package 51579f19…: PASS, byte-exact
Reconstructed the immutable package from its manifest in a clean directory and executed its checker once against its own target, with five corrupted-target controls. No discovery, no repair, no rerun in search of a pass.
What was assigned
Fingerprint 51579f19b0023484a27d73297ddc8b77b21466b1c74a217550b3b89b90237a41. Claim: a new exact
count/T cover for the frozen 48-slot residual of N51, anchor 101 phase 17 — 18 full nonnegative phase
rows, each with budget 6000, all slot coverages ≥ 6008; the prior gate is feasible; no exact optimum or
integer cover claimed. Command python3 check1012.py gate1012.json; comparison rule exit 0 and
byte-exact stdout including the newline, exact integers, stderr timings excluded, five damaged copies
each exit 1 with the target preserved. Manifest: checker check1012.py 63272f3f…; dependencies
coherence974-input.json b173e69b…, job984-gate-residual.json 8c68352f…, n52-cnt.json
3f1a311f…; target gate1012.json 6a3a0f03….
What I ran
- Fetched all five manifest files by SHA from
/files/<sha>intojob1074/clean/and verified every raw-byte hash; re-verified in place before the run and again after the controls: unchanged. - Read the checker in full. It re-hashes the three dependencies itself, rebuilds the 51-slot domain
Dand asserts the three pinned sources agree on it (D == base['slots'][:51] == job984['D51']), rebuilds the killed set at phase 17 by the modular rule(s+17) mod 101 ∈ {0, 99}and assertsK == [9677, 10889, 11699]against the pinned residual, formsR = D \ K(48 slots), then reads the target and recomputes every coverage numerator from scratch — for each residual slot, summing the per-prime phase weights over the phases that kill it ((s+b) mod q == 0or(s+b+2) mod q == 0) — and asserts the result equals the target'scoverage_numerators, thatmin ≥ T, thatmin − T == min_margin, that every prime's phase row has lengthqwith nonnegative integer entries summing to at mostT, and thatcolumnsequals the count of phase entries that kill at least one residual slot. - Ran the prescribed command unchanged under POSIX CPython (the checker imports
resource, so it cannot start on Windows): exit 0, 80 ms wall, 0.0159 s CPU, 17.2 MB RSS, and stdout of 370 bytes byte-identical to the expected string; a rerun produced identical bytes (deterministic, no RNG). - Five controls, each in its own copy with the checker and dependencies byte-identical and the clean target untouched.
What this establishes, and its limits
Established. The frozen phase-101/17 residual cover is exactly what the artifact says: the 51-slot
domain and its 3-slot kill set are consistent across the three pinned sources; every one of the 18 prime
phase rows is nonnegative, integer and within budget; and the recomputed coverage of all 48 residual
slots is min 6008, i.e. a margin of 8 above T = 6000 — a genuine feasibility certificate at this
scope, not a re-print of the artifact's own arithmetic.
Worth knowing, and I checked it rather than assuming. Every prime's budget is saturated:
sum(cnt[q]) == 6000 exactly for all 18 primes, so the cover has no slack on the budget side, and the
coverage numerators run 6008–6010 — the whole certificate lives in a margin of 8 parts in 6000 (0.13%).
Also: the pass, all_budgets_valid, minimum_margin and scope fields of the printed JSON are
literals in the print statement, not computed values; what makes them trustworthy is that each is tied
to a preceding assertion (sum(counts[q]) <= T; min(coverage) - T == x['min_margin'] == 8). Corrupting
any of the underlying quantities trips an assertion before the print is reached — see the controls.
Limits, stated rather than implied. (i) Scope is one frozen phase: the checker's own printed scope
string says "one frozen phase101/17; not full101-star or3-anchor status", and nothing here extends to
other phases, anchors, starts or primes. (ii) This certification is feasibility only: no optimality,
minimality or integer-cover claim is checked, and the artifact does not make one. (iii) The truth and
completeness of the underlying census (n52-cnt.json) is an input, not a conclusion: the checker
verifies the 51-prefix agreement between three pinned files, not that this prefix is the correct window
or that the census is complete. (iv) The report's delta17 free-anchor-101-star embedding is a
mathematical argument in the return, not something this execution runs; the package says so explicitly,
and this receipt neither supports nor touches it. (v) The checker shares the kill rule and the pinned
decomposition with the producer; it recomputes their arithmetic consequences, not the definitions.
Deviations, disclosed
The package declares POSIX CPython 3.12.13, observed macOS. My host is Windows, where the checker
cannot import resource; I ran the unchanged bytes on this machine's WSL Ubuntu Linux, CPython
3.14.4, resource available, one thread. OS and patch level differ from the declaration; interpreter
family, stdlib surface and the arithmetic are the same, and the checker imports only
hashlib, json, resource, sys, time, pathlib. The declared 15 s soft / 20 s hard CPU cap was never
approached (0.016 s).
Controls (all five detected; raw stderr uploaded per control)
| control | corruption of the target | exit | assertion it trips |
|---|---|---|---|
| c1_weight_bumped | cnt["103"][0] += 1 |
1 | line 37, sum(counts[q]) <= T (budget violated) |
| c2_coverage_claim | coverage_numerators[0] += 1 |
1 | line 46, recomputed coverage vs the target's claim |
| c3_min_margin | min_margin 8 → 9 |
1 | line 47, min(coverage) - T == x['min_margin'] == 8 |
| c4_T | T 6000 → 6001 |
1 | line 32, the T == 6000 pin |
| c5_missing_prime | prime 193's phase row removed | 1 | line 33, set(x['cnt']) == {str(q)} |
Both the certificate's own arithmetic (c1, c2, c3) and its structural completeness (c5) are caught, and the failures occur inside the recomputation loop, before any output is printed — so the checker demonstrably consumes the submitted target rather than echoing a stored answer. The clean copies were re-hashed after the controls and were unchanged.
Cost
Checker run 80 ms wall / 0.0159 s CPU (RSS 17.2 MB); five fetches and hashing are negligible; the five
controls each exit within about 20 ms. Inside the package cost (cpu_hours 0.0005, minutes 0.1) and
far inside the session's limits.
Sources
Project-served artifacts of return #441, fetched by SHA and hash-verified locally: check1012.py
63272f3fefb4d4848aac82863ec21de5b80d829d8fe98710f8e601bddbf17a6d (checker);
coherence974-input.json b173e69b99916a9562cfab59223359984c629f5845a68a265d4ef3dbc3f162c1,
job984-gate-residual.json 8c68352fa432d4160fa33109fe3cf28dff142e66a3e8fccab7c6536d90f3bc74,
n52-cnt.json 3f1a311fa084241a16a770e85b6349aa6c609e122e45ac347db7fb68e351af32 (dependencies);
gate1012.json 6a3a0f037b715277700d61a6e0417883ca9fae7cf47b3c02fe726275fe5e2065 (target, also the
expected output). Package fingerprint 51579f19b0023484a27d73297ddc8b77b21466b1c74a217550b3b89b90237a41.
Access: public on the platform. Local evidence in job1074/: clean/run_stdout.txt,
clean/run_stderr.txt, controls/*/ (five corrupted copies with out.txt/err.txt), run_wsl.sh,
run_controls_wsl.sh. Access: local-only working files, uploaded with this return. No external source
was consulted: this is an execution receipt, not a literature result.