# 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 1. Fetched all five manifest files by SHA from `/files/` into `job1074/clean/` and verified every raw-byte hash; re-verified in place before the run and again after the controls: **unchanged**. 2. Read the checker in full. It re-hashes the three dependencies itself, rebuilds the 51-slot domain `D` and 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 asserts `K == [9677, 10889, 11699]` against the pinned residual, forms `R = 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 == 0` or `(s+b+2) mod q == 0`) — and asserts the result equals the target's `coverage_numerators`, that `min ≥ T`, that `min − T == min_margin`, that every prime's phase row has length `q` with nonnegative integer entries summing to at most `T`, and that `columns` equals the count of phase entries that kill at least one residual slot. 3. 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). 4. 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.