Faster verification: concurrent checks, make verify-parallel, faster paired-cube frames, no joint-dual re-pins

[eumemic]

Change and mathematical scope

No mathematical change. Kappa, constraints and certificate values are unchanged. Two joint-dual certificates change only in the source-manifest digests they bind.

1. Stop pinning Makefile, README.md and NOTICE in the joint-dual freeze. research/joint-dual/SOURCE.json pinned these repository-wide files, so any PR that edits them fails verify (*, joint) with AssertionError: Makefile (or README.md) until it re-pins and regenerates joint-dual-kappa.json and joint-dual-validation.json. This was the failure in most recent failed PR runs, including Raise conditional kappa to 4.611281e-4 with tightened adapter toll #148. 59 of the 100 open PRs carry that re-pin, so they all conflict with each other on those three files, and every merge to main repeats it. The three files are not inputs to the joint-dual computation. This removes them from the pin script and from check_sources, re-pins, and regenerates the two certificates.
2. Run independent checks concurrently (scripts/run_parallel.py, standard library only):
   • verify-research: each of the 28 historical audits writes only its own certificate. I confirmed this by recording every file each command opens. They now run concurrently, slowest first.
   • verify-tests: still one interpreter per test module, now several modules at a time. The modules write only temporary files.
   • JOBS limits the number of processes. The default is one per CPU and per 3 GiB of memory, since the largest audits use 3.1 GB. JOBS=1 restores sequential order.
3. make verify-parallel: runs every make verify group concurrently, each in a fresh one-commit git snapshot of the working tree (tracked files plus untracked, non-ignored files). It fails if a group changes a committed file. This is the same isolation and reproducibility check CI makes. Logs go to build/verify-parallel/. make verify itself is unchanged.
4. formal-historical-verify: the Python circuit check (about 95 s in CI) runs alongside the Lean build.
5. CI: a new push to a pull request cancels the run for its previous commit. Push runs are never cancelled.
6. Paired-cube frame algebra (scripts/paired_cube/frames.py, the Paired cubes and shared completed cores for conditional kappa = 4.609169e-4 #144 code every current contributor builds on): make paired-cube-verify drops from 27.7 s to 14.3 s, and paired_cube_producer.py from 24.6 s to 11.2 s. The regenerated graph, frames, selection and report are byte-identical. The network certificate changes only in the pinned sha256 of frames.py. The changes:
   • basis() reduces a new row only by the pivots set in it.
   • contained() tests the top bit of each row directly, which is equivalent to min(x, x^y), and first rejects when A's support leaves B's.
   • perp() is memoized: 130k calls have 43.5k distinct arguments.

Validation

CI timings below are from the main run 37886960787 (Python 3.13). The other timings are from a 96-core c7a machine with Python 3.12.

	before	after
verify-research, 4 cores	401 s (543 s in CI)	106 s
verify-tests, 4 cores	269 s (365 s in CI)	73 s
all 14 groups, one machine	41 min (make verify)	4.2 min (make verify-parallel)

• make verify-parallel passes all 14 groups and changes no committed file (four runs, the last on this exact three-commit tree). Peak memory with all groups at once is about 12.5 GB.
• With the default JOBS and 4 pinned cores, verify-research and verify-tests pass and leave the tree clean.
• pin_joint_dual_sources.py followed by verify_joint_dual.py reproduces kappa = 4764513337/10^14, all 47 strict inequalities and all seven margins. All 48 remaining pins match.
• The CI critical path was verify-research (9.3 min). After this change, the longest jobs should be formal (historical), joint, producers and clones, at about 5–6.5 min. This PR's own CI run will show the actual times.

These are measured slow spots that this PR does not change:

• The same input-free data_corners.cpp check, with an identical data-corners.json output, runs in five producers: copied-fixed, pair-assembly, skip-strips, skip-suffix and split-skip. Each run takes about 2 min single-threaded, which adds about 10 min to a full verification and about 30 CI job-minutes to each push. Those producers are hash-pinned, so removing the duplicates means re-pinning their certificates.
• Each push starts 45 jobs (14 groups × 3 Python versions, plus 3 formal jobs), about 170 job-minutes. Two overlapping runs peaked at exactly 60 concurrent jobs, which appears to be the account's concurrency limit, so later jobs waited in the queue. Testing only 3.11 and 3.14 would remove a third of the verify jobs.
• Profiled hot spots: joint_dual_reclaim_compiler.acquire (243 of 277 s, mostly 570k sorted calls inside a loop), quadratic_affine.inner (168 s), partial_swap/positive.run (214 s) and ternary_side.build (131 s).

🤖 Generated with Claude Code

[Mister-Meeseeks]

Thank you @eumemic. This contribution is now recorded on main in the scoped reconciliation review and contributor credits.

Contribution: Isolated parallel verification runner and frame-equivalence work.

Review and limits: Adapted runner integrated actively, with positive-job validation and correct tracked/ignored-file snapshots; six new adversarial tests. Historical optimizer retained separately with existing 12,000-case equivalence evidence; no blanket runtime benchmark claimed.

The complete original source, proof/research notes, notices and relevant replay/CI evidence are retained through the pinned source archive. The review distinguishes fresh runs, exact-head historical CI and prior integration evidence. Closing this historical PR as reconciled; its obsolete headline does not replace the current selected bound, and draft/retracted claims retain their explicit qualifications.

Reviewed head: f571bcbd6e06618aeae0b8279da48060032dc74b. Publication: b84ba67156a01f9c2cb34fe1e3cb1dcdeab00d9c.