From 086722ff6feb3a0e368f83c77ac698c3611c360b Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Tue, 10 Nov 2026 21:26:46 +0000 Subject: [PATCH 1/2] feat(research): record a 21-shear one-scale helper-462 word The pinned helper-462 matcher has a zero-swap word with one scale of -16 and 21 rational shears, below the 26 recorded in open PR #7054. One exact word per scale row is recorded as well. The lengths are upper bounds from a heuristic search, not minima. No new kappa. --- .../helper462-one-scale-21-shear/README.md | 151 +++ .../ROW_WORDS.json | 1135 +++++++++++++++++ .../helper462-one-scale-21-shear/SOURCES.json | 24 + .../helper462-one-scale-21-shear/TASK.json | 103 ++ .../helper462-one-scale-21-shear/VERIFY.json | 20 + .../helper462-one-scale-21-shear/WORD.json | 147 +++ .../helper462-one-scale-21-shear/search.py | 154 +++ .../helper462-one-scale-21-shear/verify.py | 176 +++ 8 files changed, 1910 insertions(+) create mode 100644 research/helper462-one-scale-21-shear/README.md create mode 100644 research/helper462-one-scale-21-shear/ROW_WORDS.json create mode 100644 research/helper462-one-scale-21-shear/SOURCES.json create mode 100644 research/helper462-one-scale-21-shear/TASK.json create mode 100644 research/helper462-one-scale-21-shear/VERIFY.json create mode 100644 research/helper462-one-scale-21-shear/WORD.json create mode 100644 research/helper462-one-scale-21-shear/search.py create mode 100644 research/helper462-one-scale-21-shear/verify.py diff --git a/research/helper462-one-scale-21-shear/README.md b/research/helper462-one-scale-21-shear/README.md new file mode 100644 index 0000000000..38f9e3b4f6 --- /dev/null +++ b/research/helper462-one-scale-21-shear/README.md @@ -0,0 +1,151 @@ +# helper462-one-scale-21-shear + +**Constructive witness. No new κ and no selected-frontier change.** + +## Result + +For the pinned helper-462 matcher `S` +(`research/bit-completed-backend-api/science/RESULT.json#matcher`, an 8 by 8 +integer matrix of determinant `-16`), the alphabet of axis swaps, +single-coordinate rational scales and rational shears contains a zero-swap +word with exactly one scale and **21 shears**. The scale is the last letter, +on row 0, with coefficient `-16`. The shear denominators are `1, 2, 4, 8, 16`. + +The shortest one-scale zero-swap word recorded before this package has 26 +shears (unpaidmoon, open PR #7054), on the same matrix with the same scale. +The lower bound is 9 shears (unpaidmoon, open PR #7055). The open interval for +the one-scale shear length therefore moves from 9 through 26 to **9 through 21**. + +Twenty-one is the length of this witness. It is not claimed to be minimal. + +### The word + +Letters apply first to last as row operations on the identity. +`t += a*s` means row `t` gains `a` times row `s`. This is the content of +[WORD.json](WORD.json). + +| # | letter | # | letter | # | letter | +|---:|---|---:|---|---:|---| +| 1 | `7 += -1*2` | 8 | `0 += 3/4*1` | 15 | `5 += 1/2*1` | +| 2 | `1 += 1*3` | 9 | `1 += 4*0` | 16 | `4 += 1*7` | +| 3 | `5 += 1*3` | 10 | `0 += -3/16*1` | 17 | `4 += 16*0` | +| 4 | `3 += -2*1` | 11 | `2 += -8*0` | 18 | `6 += -1*3` | +| 5 | `5 += 2*0` | 12 | `0 += 1/8*2` | 19 | `3 += 1*6` | +| 6 | `0 += -1/2*5` | 13 | `0 += -1/16*4` | 20 | `6 += -1*3` | +| 7 | `4 += 2*2` | 14 | `1 += 2*3` | 21 | `1 += 1*2` | + +Letter 22 is the scale: row 0 times `-16`. + +### One word per scale row + +A zero-swap word with one scale `c` on row `r` has determinant `c`, so `c = -16` +and the shears multiply to `D_r^{-1} S`. Conjugating by the scale moves it to +either end without changing the shear count, so only the row `r` matters. +[ROW_WORDS.json](ROW_WORDS.json) records one exact word for each row: + +| scale row | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | +|---|---:|---:|---:|---:|---:|---:|---:|---:| +| shears | 21 | 21 | 24 | 21 | 21 | 21 | 21 | 23 | + +Each count is an upper bound for that row. The larger counts on rows 2 and 7 +are a search outcome. They are not a proof that those rows need more shears. + +## Claim type and limits + +- **Finite certificate.** Each frozen word multiplies exactly to `S` over the + rationals. That is the whole proof of the upper bounds. +- **Not a minimum.** The words came from a beam search, which is a heuristic + and not a census of rational words. Lengths 9 through 20 stay open. +- **Lower bound cited, not replayed.** The floor of 9 is the statement of open + PR #7055. This package does not recheck it. +- No supplier admission, no P2 ordinary bill, no tariff, and no + integer-coefficient claim. With integer shears no one-scale zero-swap word + exists (merged PR #6954); this word uses the denominator 16. + +## Evidence + +`verify.py` uses the Python 3.12 standard library and exact fractions. It checks: + +1. the pinned matcher is 8 by 8 with determinant `-16`; +2. the 21 shears followed by the scale reproduce `S`, by row operations on the + identity and by an independent product of elementary matrices; +3. the shear part has determinant 1, and no two adjacent shears share a + position, so no pair merges into one letter; +4. the same checks for the eight words of `ROW_WORDS.json`, whose row-0 entry + equals `WORD.json`; +5. 406 failure controls: for the primary word and each row word, deleting any + single letter misses `S`, and adding 1 to any single coefficient misses `S`. + +Failures use an explicit exit, so the controls stay active under `-O`. + +## Reproduce + +From the repository root, with CPython 3.12: + +```sh +python3.12 -B research/helper462-one-scale-21-shear/verify.py +python3.12 -O -B research/helper462-one-scale-21-shear/verify.py +python3.12 -B scripts/research_package.py --package research/helper462-one-scale-21-shear +python3.12 -B scripts/check_research_commit.py --package research/helper462-one-scale-21-shear --check-source-history +``` + +Expected first line: `PASS_HELPER462_ONE_SCALE_21_SHEAR`. The verifier runs in +well under a second. + +### Search provenance (not a registered check) + +`search.py` is the beam search that proposed the words. It reduces +`D_r^{-1} S` to the identity by row and column shears whose coefficient clears +one entry or sets one diagonal entry to 1, and keeps the matrices with the +fewest entries differing from the identity. It writes its output to a +directory outside the checkout: + +```sh +python3.12 -B research/helper462-one-scale-21-shear/search.py "$OUT" 4000 1 0 "" 24 +python3.12 -B research/helper462-one-scale-21-shear/search.py "$OUT" 300 1 0 "" 30 2,7 +``` + +The first command took about 11 seconds on ten cores and returns the recorded +21-shear words for rows 0, 1, 3, 4, 5 and 6; it returns nothing for rows 2 +and 7 within depth 24. The second returns the recorded 24-shear word for row 2. +The row-7 word came from +`search.py "$OUT" 1500 2 1.5 "1,-1,2,-2,0.5,-0.5" 23`, seed 1, a run of about +three minutes that was not repeated. The frozen words do not depend on the +search: the exact products are the certificate. + +## Open next questions + +Structured copies are in [TASK.json](TASK.json). + +1. **What is the minimal one-scale shear length?** The interval is now 9 + through 21. First step: run `search.py` with a wider beam and depth cap 20 + on rows 0, 1, 3, 4, 5 and 6, and separately try to raise the rank-drop floor + of PR #7055 from 9 to 10. A search that returns nothing is not a lower bound. +2. **Do scale rows 2 and 7 admit 21 shears?** The recorded words have 24 and + 23. First step: a wider or noisier beam on those rows, or an invariant of + `D_r^{-1} S` that separates them from the other six rows. +3. **Does the 21-shear word help on the P2 ordinary bill?** Letter counts do + not determine the signed moment, and this word has denominators up to 16. + First step: evaluate it under the tariff model of merged + `research/helper462-p2-ordinary-bill`. + +## Credit + +This package was produced by Nick Petalas. New work is Apache-2.0. + +Predecessors, none of which is replayed here: + +- The matcher and its five-swap elimination are from + `research/bit-completed-backend-api` (Chris R / Clear1nsight, PR #4957), + using the helper-462 witness of ai-nanachi #4760/#4814. +- unpaidmoon, merged PR #6954: a one-scale zero-swap word (53 shears), + the determinant identity that forces the scale `-16`, and the integer-shear + obstruction. +- unpaidmoon, open PR #7030 (head `98238eeed3faca9f0a5f1d4060db5d5da524a192`): + a 29-shear one-scale word and the rank lower bound 8. +- unpaidmoon, open PR #7054 (head `ae1cf2af174cd4f8c89089a27fc58e470b5452bd`): + the 26-shear one-scale word this package shortens. Its word format and + application order are reused in `WORD.json`. +- unpaidmoon, open PR #7055 (head `0a6361ec1b63621ca5f985218892e0cdc79502ae`): + the lower bound of 9 shears, which poses the open interval answered in part + here. diff --git a/research/helper462-one-scale-21-shear/ROW_WORDS.json b/research/helper462-one-scale-21-shear/ROW_WORDS.json new file mode 100644 index 0000000000..e67fe09c8d --- /dev/null +++ b/research/helper462-one-scale-21-shear/ROW_WORDS.json @@ -0,0 +1,1135 @@ +{ + "schema_version": 1, + "claim_type": "constructive-witnesses", + "note": "One zero-swap one-scale word per scale row, same application order as WORD.json. Lengths are upper bounds from a heuristic search, not minima.", + "shear_counts": [ + 21, + 21, + 24, + 21, + 21, + 21, + 21, + 23 + ], + "words": [ + { + "scale_row": 0, + "letters": [ + { + "op": "add", + "target": 7, + "source": 2, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 5, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 3, + "source": 1, + "coefficient": "-2" + }, + { + "op": "add", + "target": 5, + "source": 0, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 5, + "coefficient": "-1/2" + }, + { + "op": "add", + "target": 4, + "source": 2, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "3/4" + }, + { + "op": "add", + "target": 1, + "source": 0, + "coefficient": "4" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "-3/16" + }, + { + "op": "add", + "target": 2, + "source": 0, + "coefficient": "-8" + }, + { + "op": "add", + "target": 0, + "source": 2, + "coefficient": "1/8" + }, + { + "op": "add", + "target": 0, + "source": 4, + "coefficient": "-1/16" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "2" + }, + { + "op": "add", + "target": 5, + "source": 1, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 4, + "source": 7, + "coefficient": "1" + }, + { + "op": "add", + "target": 4, + "source": 0, + "coefficient": "16" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 3, + "source": 6, + "coefficient": "1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 2, + "coefficient": "1" + }, + { + "op": "scale", + "target": 0, + "coefficient": "-16" + } + ] + }, + { + "scale_row": 1, + "letters": [ + { + "op": "add", + "target": 7, + "source": 2, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 5, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 3, + "source": 1, + "coefficient": "-2" + }, + { + "op": "add", + "target": 5, + "source": 0, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 5, + "coefficient": "-1/2" + }, + { + "op": "add", + "target": 4, + "source": 2, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "5" + }, + { + "op": "add", + "target": 1, + "source": 0, + "coefficient": "-1/4" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "20" + }, + { + "op": "add", + "target": 2, + "source": 0, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 0, + "source": 2, + "coefficient": "-2" + }, + { + "op": "add", + "target": 0, + "source": 4, + "coefficient": "1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "-1/8" + }, + { + "op": "add", + "target": 5, + "source": 1, + "coefficient": "-8" + }, + { + "op": "add", + "target": 4, + "source": 7, + "coefficient": "1" + }, + { + "op": "add", + "target": 4, + "source": 0, + "coefficient": "-1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 3, + "source": 6, + "coefficient": "1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 2, + "coefficient": "-1/16" + }, + { + "op": "scale", + "target": 1, + "coefficient": "-16" + } + ] + }, + { + "scale_row": 2, + "letters": [ + { + "op": "add", + "target": 7, + "source": 2, + "coefficient": "-1" + }, + { + "op": "add", + "target": 0, + "source": 3, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 3, + "source": 2, + "coefficient": "17" + }, + { + "op": "add", + "target": 4, + "source": 2, + "coefficient": "2" + }, + { + "op": "add", + "target": 2, + "source": 3, + "coefficient": "-1/16" + }, + { + "op": "add", + "target": 5, + "source": 0, + "coefficient": "2" + }, + { + "op": "add", + "target": 6, + "source": 1, + "coefficient": "2" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 0, + "source": 3, + "coefficient": "-1/8" + }, + { + "op": "add", + "target": 3, + "source": 6, + "coefficient": "1" + }, + { + "op": "add", + "target": 3, + "source": 1, + "coefficient": "-2" + }, + { + "op": "add", + "target": 1, + "source": 0, + "coefficient": "4" + }, + { + "op": "add", + "target": 1, + "source": 5, + "coefficient": "-2" + }, + { + "op": "add", + "target": 0, + "source": 2, + "coefficient": "-2" + }, + { + "op": "add", + "target": 0, + "source": 4, + "coefficient": "1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 6, + "coefficient": "-1/2" + }, + { + "op": "add", + "target": 5, + "source": 1, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 0, + "source": 5, + "coefficient": "-1/2" + }, + { + "op": "add", + "target": 4, + "source": 7, + "coefficient": "1" + }, + { + "op": "add", + "target": 4, + "source": 0, + "coefficient": "-1" + }, + { + "op": "add", + "target": 2, + "source": 1, + "coefficient": "1/32" + }, + { + "op": "add", + "target": 1, + "source": 2, + "coefficient": "-16" + }, + { + "op": "scale", + "target": 2, + "coefficient": "-16" + } + ] + }, + { + "scale_row": 3, + "letters": [ + { + "op": "add", + "target": 7, + "source": 2, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "-15/2" + }, + { + "op": "add", + "target": 5, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 3, + "source": 1, + "coefficient": "1/8" + }, + { + "op": "add", + "target": 5, + "source": 0, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 5, + "coefficient": "-1/2" + }, + { + "op": "add", + "target": 4, + "source": 2, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "-5/16" + }, + { + "op": "add", + "target": 1, + "source": 0, + "coefficient": "4" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "-5/4" + }, + { + "op": "add", + "target": 2, + "source": 0, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 0, + "source": 2, + "coefficient": "-2" + }, + { + "op": "add", + "target": 0, + "source": 4, + "coefficient": "1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "2" + }, + { + "op": "add", + "target": 5, + "source": 1, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 4, + "source": 7, + "coefficient": "1" + }, + { + "op": "add", + "target": 4, + "source": 0, + "coefficient": "-1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "16" + }, + { + "op": "add", + "target": 3, + "source": 6, + "coefficient": "-1/16" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "16" + }, + { + "op": "add", + "target": 1, + "source": 2, + "coefficient": "1" + }, + { + "op": "scale", + "target": 3, + "coefficient": "-16" + } + ] + }, + { + "scale_row": 4, + "letters": [ + { + "op": "add", + "target": 7, + "source": 2, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 5, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 3, + "source": 1, + "coefficient": "-2" + }, + { + "op": "add", + "target": 5, + "source": 0, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 5, + "coefficient": "-1/2" + }, + { + "op": "add", + "target": 4, + "source": 2, + "coefficient": "-1/8" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "3/4" + }, + { + "op": "add", + "target": 1, + "source": 0, + "coefficient": "4" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "-3/16" + }, + { + "op": "add", + "target": 2, + "source": 0, + "coefficient": "-8" + }, + { + "op": "add", + "target": 0, + "source": 2, + "coefficient": "1/8" + }, + { + "op": "add", + "target": 0, + "source": 4, + "coefficient": "1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "2" + }, + { + "op": "add", + "target": 5, + "source": 1, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 4, + "source": 7, + "coefficient": "-1/16" + }, + { + "op": "add", + "target": 4, + "source": 0, + "coefficient": "-1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 3, + "source": 6, + "coefficient": "1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 2, + "coefficient": "1" + }, + { + "op": "scale", + "target": 4, + "coefficient": "-16" + } + ] + }, + { + "scale_row": 5, + "letters": [ + { + "op": "add", + "target": 7, + "source": 2, + "coefficient": "-1" + }, + { + "op": "add", + "target": 0, + "source": 3, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 3, + "source": 1, + "coefficient": "-2" + }, + { + "op": "add", + "target": 5, + "source": 1, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 4, + "source": 2, + "coefficient": "2" + }, + { + "op": "add", + "target": 2, + "source": 5, + "coefficient": "4" + }, + { + "op": "add", + "target": 1, + "source": 5, + "coefficient": "-2" + }, + { + "op": "add", + "target": 0, + "source": 5, + "coefficient": "8" + }, + { + "op": "add", + "target": 5, + "source": 0, + "coefficient": "-1/8" + }, + { + "op": "add", + "target": 0, + "source": 2, + "coefficient": "-2" + }, + { + "op": "add", + "target": 0, + "source": 4, + "coefficient": "1" + }, + { + "op": "add", + "target": 2, + "source": 1, + "coefficient": "3/2" + }, + { + "op": "add", + "target": 2, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 0, + "source": 5, + "coefficient": "8" + }, + { + "op": "add", + "target": 4, + "source": 7, + "coefficient": "1" + }, + { + "op": "add", + "target": 4, + "source": 0, + "coefficient": "-1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 3, + "source": 6, + "coefficient": "1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 2, + "coefficient": "1" + }, + { + "op": "scale", + "target": 5, + "coefficient": "-16" + } + ] + }, + { + "scale_row": 6, + "letters": [ + { + "op": "add", + "target": 7, + "source": 2, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "-15/2" + }, + { + "op": "add", + "target": 5, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 3, + "source": 1, + "coefficient": "1/8" + }, + { + "op": "add", + "target": 5, + "source": 0, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 5, + "coefficient": "-1/2" + }, + { + "op": "add", + "target": 4, + "source": 2, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "-5/16" + }, + { + "op": "add", + "target": 1, + "source": 0, + "coefficient": "4" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "-5/4" + }, + { + "op": "add", + "target": 2, + "source": 0, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 0, + "source": 2, + "coefficient": "-2" + }, + { + "op": "add", + "target": 0, + "source": 4, + "coefficient": "1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "2" + }, + { + "op": "add", + "target": 5, + "source": 1, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 4, + "source": 7, + "coefficient": "1" + }, + { + "op": "add", + "target": 4, + "source": 0, + "coefficient": "-1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 3, + "source": 6, + "coefficient": "1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 2, + "coefficient": "1" + }, + { + "op": "scale", + "target": 6, + "coefficient": "-16" + } + ] + }, + { + "scale_row": 7, + "letters": [ + { + "op": "add", + "target": 0, + "source": 5, + "coefficient": "-1/2" + }, + { + "op": "add", + "target": 5, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 3, + "source": 1, + "coefficient": "-2" + }, + { + "op": "add", + "target": 2, + "source": 0, + "coefficient": "-2" + }, + { + "op": "add", + "target": 5, + "source": 0, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "3/2" + }, + { + "op": "add", + "target": 1, + "source": 0, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "-3/8" + }, + { + "op": "add", + "target": 0, + "source": 2, + "coefficient": "1/8" + }, + { + "op": "add", + "target": 1, + "source": 5, + "coefficient": "-1" + }, + { + "op": "add", + "target": 2, + "source": 5, + "coefficient": "1" + }, + { + "op": "add", + "target": 4, + "source": 0, + "coefficient": "-1" + }, + { + "op": "add", + "target": 0, + "source": 4, + "coefficient": "1" + }, + { + "op": "add", + "target": 4, + "source": 0, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "2" + }, + { + "op": "add", + "target": 7, + "source": 4, + "coefficient": "-9" + }, + { + "op": "add", + "target": 1, + "source": 4, + "coefficient": "-8" + }, + { + "op": "add", + "target": 4, + "source": 7, + "coefficient": "1" + }, + { + "op": "add", + "target": 7, + "source": 4, + "coefficient": "-17/16" + }, + { + "op": "add", + "target": 3, + "source": 6, + "coefficient": "1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 3, + "source": 6, + "coefficient": "1" + }, + { + "op": "scale", + "target": 7, + "coefficient": "-16" + } + ] + } + ] +} diff --git a/research/helper462-one-scale-21-shear/SOURCES.json b/research/helper462-one-scale-21-shear/SOURCES.json new file mode 100644 index 0000000000..5f7bfe6f8f --- /dev/null +++ b/research/helper462-one-scale-21-shear/SOURCES.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8", + "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec", + "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81" + }, + { + "path": "research/bit-completed-backend-api/science/RESULT.json", + "usage": "input", + "git_blob": "55dca30281e3375d63a128c3de041e46c8a3c5ba", + "sha256": "965b650c0e49572e028f89a60943c64ad8dff9032fc93272b86cd1f9715a77b7" + } + ] +} diff --git a/research/helper462-one-scale-21-shear/TASK.json b/research/helper462-one-scale-21-shear/TASK.json new file mode 100644 index 0000000000..ddaaaea0a0 --- /dev/null +++ b/research/helper462-one-scale-21-shear/TASK.json @@ -0,0 +1,103 @@ +{ + "schema_version": 1, + "task_id": "supplier-boundary-audit", + "priority_revision": 8, + "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57", + "original_card": { + "id": "supplier-boundary-audit", + "question": "Does one changed supplier have complete source-bound native, caller, ordinary and outer admission coverage?", + "starting_points": [ + "docs/research/current-priorities.md", + "docs/research/research-family-status.md", + "certificates/selected-result.json", + "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md" + ], + "methods": [ + "Construct and independently check one source-bound instance of the stated first experiment.", + "Seek an exact counterexample or target-specific complete-budget obstruction to that same proposed change." + ], + "acceptance_gate": "Pin the current sources and one obligation; the historical owner audit is an example, not evidence of a current bug.", + "first_step": { + "command": [ + "python3", + "-B", + "scripts/research_selected_baseline.py" + ], + "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY", + "inspect": "Read revision 8, the selected review and live exact-source handoffs. Then follow this card's bounded first_experiment.", + "scope": "Source-bound orientation only, not a supplier replay or theorem proof." + }, + "first_experiment": "Choose one latest uncovered candidate and build a delta coverage map against the selected review. For P104, #5717 changes owned-lifetime assumptions and #5719 covers exact #5713 causal premises; neither automatically transfers to #5718. For BIT, #5679/#5708 need component admission and compatible outer use. Check controls and exact source identity before reuse; stop with one resolved gap or explicit remaining obligation. A heavy full replay requires a separate serial resource budget.", + "bottleneck_link": "Judge the actual current supplier contract and complete signed target/paid bill; frozen-profile ceilings require an applicability proof.", + "allowed_variations": [ + "One exact source head, helper/cut region or quantified proposition and changed hypothesis; check live handoffs first. Different seeds are not different scopes." + ], + "scope_change_triggers": [ + "Changing source head, helper/cut domain, operation alphabet or caller boundary without recording the new scope.", + "Treating an archived proposal or local numerical pass as complete supplier admission." + ], + "overlap_terms": [ + "supplier admission", + "5717", + "5719", + "5708", + "owned lifetime" + ], + "existing_checks": [ + { + "scope": "PR #4088: author-checked local words, native receipts, owner/phase fill and exact moment.", + "evidence": "research/staged544-mixed-fourth-entry/README.md", + "remaining": "Rebind and validate ordinary/outer admission with all four providers; full mixed release not established.", + "status": "author-checked", + "source_commit": "72d7efc181edb21806a878f174847c96dd410ab0", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "PR #3801: successor scatter-boundary decision package.", + "evidence": "research/scatter-boundary-decision/README.md", + "remaining": "Consult its exact acceptance scope before any new exporter audit; not proof of a selected failure.", + "status": "author-checked", + "source_commit": "911f8800ba7a4b03603ef62c5ffc6240e53cb5fd", + "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129" + }, + { + "scope": "Selected PR5599: complete helper-subspace construction and independent caller replay; five framework assumptions remain.", + "evidence": "docs/research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md", + "remaining": "The next experiment must identify uncovered source-specific work. Successor archive intake does not transfer this admission.", + "status": "reviewed", + "source_commit": "09dd0965711ca7eeb169057a420abab1c9052137", + "selected_record_sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5" + } + ] + }, + "scope_status": "refined", + "actual_scope": "For the pinned helper-462 matcher, the rational elementary alphabet of shears, single-coordinate scales and axis swaps contains a zero-swap word with exactly one scale and 21 shears. The scale is the last letter, on row 0, with coefficient -16. One further exact word is recorded for each scale row, with 21, 21, 24, 21, 21, 21, 21 and 23 shears on rows 0 through 7. These are upper bounds from a heuristic search, not minima. No supplier admission, tariff comparison, or new kappa.", + "scope_change_reason": "The card asks for supplier admission coverage. This package answers one narrower open question posed by unpaidmoon's open PRs #7030, #7054 and #7055: whether a one-scale zero-swap word for this matcher exists with fewer than 26 shears. It audits no supplier and prices no tariff.", + "bottleneck_link": "Side result on a route ledger. The letter count of the helper-462 matcher is one charged part of the missing physical generator named in the predecessor packages. A shorter word lowers the best known shear count at one scale from 26 to 21 and narrows the open interval to 9 through 20. Letter counts do not determine the ordinary bill, so this is not a supplier admission.", + "budget_minutes": 60, + "stop_rule": "Stop at the first exact one-scale zero-swap word with fewer than 26 shears, its per-row companions and the failure controls. Do not raise the lower bound, price P2 tariffs, or run an exhaustive census.", + "outcome": "completed", + "evidence": "Exact rational product of the frozen 0-swap, 1-scale, 21-shear word equals the pinned matcher, by row operations and by an independent product of elementary matrices. The same holds for one word per scale row with shear counts (21, 21, 24, 21, 21, 21, 21, 23). All 406 single-letter deletions and coefficient mutations miss the matcher. The lower bound of 9 shears is cited from open PR #7055 and was not replayed.", + "author": "Nick Petalas", + "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.", + "open_questions": [ + { + "question": "What is the minimal number of shears in a one-scale zero-swap word for the helper-462 matcher? The known interval is now 9 through 21.", + "why_it_matters": "The word here came from a beam search that only tries coefficients clearing one entry or setting one diagonal entry to 1. A gap of twelve remains between the cited floor and this witness, so neither bound is known to be near the truth.", + "first_step": "Run research/helper462-one-scale-21-shear/search.py with a wider beam and a depth cap of 20 on scale rows 0, 1, 3, 4, 5 and 6, and separately try to raise the rank-drop floor of PR #7055 from 9 to 10.", + "blocked_by": "The search is heuristic. A run that returns nothing is a search failure, not a lower bound, and no exhaustive census of rational words is known." + }, + { + "question": "Do scale rows 2 and 7 admit a one-scale zero-swap word with 21 shears?", + "why_it_matters": "The recorded words have 24 shears on row 2 and 23 on row 7, against 21 on the other six rows. If the gap is real, the choice of scale row is a charged decision for any later generator.", + "first_step": "Run search.py on rows 2 and 7 with a beam of at least 4000 and a nonzero tie-breaking noise, or look for an invariant of D_r^{-1} S that separates rows 2 and 7 from the rest.", + "blocked_by": "At beam 4000 without noise the search returns nothing within depth 24 on these two rows. That is a search failure, not an exclusion." + }, + { + "question": "With the inherited P2 tariffs, does the 21-shear word beat the published five-swap pair or the seven-scale route on the completed ordinary bill?", + "why_it_matters": "Letter counts do not determine the signed moment. The 21-shear word uses coefficients with denominators up to 16, and the ordinary bill may charge those differently from unit shears.", + "first_step": "Evaluate this word under the tariff model of merged research/helper462-p2-ordinary-bill, which prices the seven-scale 27-shear route.", + "blocked_by": "That comparison needs the primitive tariffs pinned by the P2 package. This package records no bill." + } + ] +} diff --git a/research/helper462-one-scale-21-shear/VERIFY.json b/research/helper462-one-scale-21-shear/VERIFY.json new file mode 100644 index 0000000000..657c663d88 --- /dev/null +++ b/research/helper462-one-scale-21-shear/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/bit-completed-backend-api/science/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 60, + "checks": "Pinned matcher has determinant -16; the frozen 0-swap 1-scale 21-shear word equals it by exact row operations and by an independent elementary-matrix product; the shear part has determinant 1 and no adjacent mergeable pair; one exact word per scale row with shear counts (21, 21, 24, 21, 21, 21, 21, 23); 406 dropped-letter and mutated-coefficient failure controls." + } + ] +} diff --git a/research/helper462-one-scale-21-shear/WORD.json b/research/helper462-one-scale-21-shear/WORD.json new file mode 100644 index 0000000000..cb3fc49d0f --- /dev/null +++ b/research/helper462-one-scale-21-shear/WORD.json @@ -0,0 +1,147 @@ +{ + "schema_version": 1, + "claim_type": "constructive-witness", + "matcher": "research/bit-completed-backend-api/science/RESULT.json#matcher", + "scale_row": 0, + "scale_coefficient": "-16", + "application_order": "Apply letters from first to last as row operations on I. The 21 shears come first and the unique scale is last.", + "letter_counts": { + "swap": 0, + "scale": 1, + "add": 21 + }, + "not_a_minimum": true, + "letters": [ + { + "op": "add", + "target": 7, + "source": 2, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 5, + "source": 3, + "coefficient": "1" + }, + { + "op": "add", + "target": 3, + "source": 1, + "coefficient": "-2" + }, + { + "op": "add", + "target": 5, + "source": 0, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 5, + "coefficient": "-1/2" + }, + { + "op": "add", + "target": 4, + "source": 2, + "coefficient": "2" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "3/4" + }, + { + "op": "add", + "target": 1, + "source": 0, + "coefficient": "4" + }, + { + "op": "add", + "target": 0, + "source": 1, + "coefficient": "-3/16" + }, + { + "op": "add", + "target": 2, + "source": 0, + "coefficient": "-8" + }, + { + "op": "add", + "target": 0, + "source": 2, + "coefficient": "1/8" + }, + { + "op": "add", + "target": 0, + "source": 4, + "coefficient": "-1/16" + }, + { + "op": "add", + "target": 1, + "source": 3, + "coefficient": "2" + }, + { + "op": "add", + "target": 5, + "source": 1, + "coefficient": "1/2" + }, + { + "op": "add", + "target": 4, + "source": 7, + "coefficient": "1" + }, + { + "op": "add", + "target": 4, + "source": 0, + "coefficient": "16" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 3, + "source": 6, + "coefficient": "1" + }, + { + "op": "add", + "target": 6, + "source": 3, + "coefficient": "-1" + }, + { + "op": "add", + "target": 1, + "source": 2, + "coefficient": "1" + }, + { + "op": "scale", + "target": 0, + "coefficient": "-16" + } + ] +} diff --git a/research/helper462-one-scale-21-shear/search.py b/research/helper462-one-scale-21-shear/search.py new file mode 100644 index 0000000000..19a2f53f95 --- /dev/null +++ b/research/helper462-one-scale-21-shear/search.py @@ -0,0 +1,154 @@ +#!/usr/bin/env python3 +"""Heuristic beam search that proposed the words in this package. + +Provenance only: this is not a registered check and not a census. It reduces +D_r^{-1} S to the identity by row and column shears whose coefficient clears +one entry or sets one diagonal entry to 1, keeps the `beam` matrices closest +to the identity at each depth, and rebuilds a row-operation word. Arithmetic +is binary floating point restricted to a dyadic grid, so every accepted step +is exact; each returned word is rechecked with exact fractions. A run that +returns nothing proves nothing. + +Usage: search.py OUTDIR BEAM SEEDS NOISE [EXTRA_COEFFICIENTS [MAXDEPTH [ROWS]]] +""" +import json +import random +import sys +from fractions import Fraction +from multiprocessing import Pool +from pathlib import Path + +RESULT = Path(__file__).resolve().parents[2] / "research/bit-completed-backend-api/science/RESULT.json" +S = [[int(entry) for entry in row] for row in json.loads(RESULT.read_text())["matcher"]] +N = 8 +GRID = 4096.0 +BOUND = 1024.0 + + +def transpose(m): + return tuple(zip(*m)) + + +def nnz(m): + return sum(1 for i in range(N) for j in range(N) if m[i][j] != (1.0 if i == j else 0.0)) + + +def row_score(row, t): + return sum(1 for j in range(N) if row[j] != (1.0 if j == t else 0.0)) + + +def children(m, score, extra): + """Yield (child, child_score, (t, s, a)) for row operations row_t += a*row_s.""" + for t in range(N): + rt = m[t] + base = score - row_score(rt, t) + for s in range(N): + if s == t: + continue + rs = m[s] + coefs = set(extra) + for c in range(N): + y = rs[c] + if y == 0.0: + continue + v = rt[c] + if v != 0.0: + coefs.add(-v / y) + if c == t and v != 1.0: + coefs.add((1.0 - v) / y) + for a in coefs: + if a == 0.0 or abs(a) > BOUND or (a * GRID) != int(a * GRID): + continue + new = tuple(rt[c] + a * rs[c] for c in range(N)) + ok = True + for x in new: + if abs(x) > BOUND or (x * GRID) != int(x * GRID): + ok = False + break + if not ok: + continue + yield m[:t] + (new,) + m[t + 1:], base + row_score(new, t), (t, s, a) + + +def search(args): + r, beam, seed, noise, extra, maxdepth = args + rng = random.Random(seed) + start = tuple(tuple(float(Fraction(x, -16 if i == r else 1)) for x in row) for i, row in enumerate(S)) + ident = tuple(tuple(1.0 if i == j else 0.0 for j in range(N)) for i in range(N)) + layers = [{start: None}] + frontier = [(nnz(start), start)] + seen = {start} + for depth in range(1, maxdepth + 1): + cand = {} + for score, m in frontier: + for child, cs, mv in children(m, score, extra): + if child not in seen and child not in cand: + cand[child] = (cs, m, ("R",) + mv) + mt = transpose(m) + for child, cs, mv in children(mt, score, extra): + ch = transpose(child) + if ch not in seen and ch not in cand: + cand[ch] = (cs, m, ("C",) + mv) + if not cand: + return r, seed, None + if ident in cand: + layers.append({ident: cand[ident][1:]}) + path = [] + cur = ident + for layer in reversed(layers[1:]): + parent, mv = layer[cur] + path.append(mv) + cur = parent + path.reverse() + return r, seed, path + items = sorted(cand.items(), key=lambda kv: kv[1][0] + (rng.random() * noise if noise else 0.0))[:beam] + layers.append({k: v[1:] for k, v in items}) + frontier = [(v[0], k) for k, v in items] + seen.update(k for k, _ in items) + return r, seed, None + + +def to_word(path): + """Row-op letters, first to last on I, whose product is D_r^{-1} S.""" + rights = [mv for mv in path if mv[0] == "C"] + lefts = [mv for mv in path if mv[0] == "R"] + word = [] + for _, t, s, a in rights: # col_t += a col_s == M (I + a E_{s,t}) + word.append((s, t, -Fraction(a))) + for _, t, s, a in reversed(lefts): + word.append((t, s, -Fraction(a))) + return word + + +def check(word, r): + m = [[Fraction(int(i == j)) for j in range(N)] for i in range(N)] + for t, s, a in word: + assert t != s and a != 0 + m[t] = [m[t][c] + a * m[s][c] for c in range(N)] + m[r] = [x * -16 for x in m[r]] + return m == [[Fraction(x) for x in row] for row in S] + + +if __name__ == "__main__": + outdir = Path(sys.argv[1]) + beam = int(sys.argv[2]) + seeds = int(sys.argv[3]) + noise = float(sys.argv[4]) + extra = tuple(float(x) for x in sys.argv[5].split(",")) if len(sys.argv) > 5 and sys.argv[5] else () + maxdepth = int(sys.argv[6]) if len(sys.argv) > 6 else 30 + rows = [int(x) for x in sys.argv[7].split(",")] if len(sys.argv) > 7 else list(range(N)) + jobs = [(r, beam, seed, noise, extra, maxdepth) for seed in range(seeds) for r in rows] + best = {} + with Pool() as pool: + for r, seed, path in pool.imap_unordered(search, jobs): + if path is None: + print("row", r, "seed", seed, "none", flush=True) + continue + word = to_word(path) + ok = check(word, r) + print("row", r, "seed", seed, "len", len(word), "exact", ok, flush=True) + if ok and (r not in best or len(word) < len(best[r])): + best[r] = word + target = outdir / ("best_row%d_len%d.json" % (r, len(word))) + target.write_text(json.dumps([[t, s, str(a)] for t, s, a in word]) + "\n") + print({r: len(w) for r, w in sorted(best.items())}) diff --git a/research/helper462-one-scale-21-shear/verify.py b/research/helper462-one-scale-21-shear/verify.py new file mode 100644 index 0000000000..687d9aceba --- /dev/null +++ b/research/helper462-one-scale-21-shear/verify.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 +"""A 21-shear one-scale zero-swap word for the pinned helper-462 matcher. + +The certificate is the exact rational product of the frozen words. Twenty-one +is an upper bound from a heuristic search, not a minimum. No new kappa. +""" +from fractions import Fraction +import json +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +PACKAGE = Path(__file__).resolve().parent +RESULT = ROOT / "research/bit-completed-backend-api/science/RESULT.json" +N = 8 +SCALE = Fraction(-16) +PRIMARY_SHEARS = 21 +ROW_SHEARS = (21, 21, 24, 21, 21, 21, 21, 23) +TOKEN = "PASS_HELPER462_ONE_SCALE_21_SHEAR" + + +def need(condition, message): + """Fail closed. A plain assert would vanish under python -O.""" + if not condition: + raise SystemExit("FAIL: " + message) + + +def identity(): + return [[Fraction(int(i == j)) for j in range(N)] for i in range(N)] + + +def matmul(left, right): + return [[sum(left[i][k] * right[k][j] for k in range(N)) for j in range(N)] + for i in range(N)] + + +def determinant(matrix): + work = [row[:] for row in matrix] + value = Fraction(1) + for column in range(N): + pivot = next((row for row in range(column, N) if work[row][column] != 0), None) + if pivot is None: + return Fraction(0) + if pivot != column: + work[column], work[pivot] = work[pivot], work[column] + value = -value + value *= work[column][column] + for row in range(column + 1, N): + factor = work[row][column] / work[column][column] + for index in range(column, N): + work[row][index] -= factor * work[column][index] + return value + + +def parse_letter(raw): + """Return ("add", target, source, coefficient) or ("scale", target, coefficient).""" + need(isinstance(raw, dict), "a letter must be an object") + kind = raw.get("op") + target = raw.get("target") + need(isinstance(target, int) and not isinstance(target, bool) and 0 <= target < N, + "a letter target must be a row index") + need(isinstance(raw.get("coefficient"), str), "a coefficient must be a string") + coefficient = Fraction(raw["coefficient"]) + if kind == "add": + source = raw.get("source") + need(isinstance(source, int) and not isinstance(source, bool) and 0 <= source < N, + "a shear source must be a row index") + need(source != target, "a shear must be off-diagonal") + need(coefficient != 0, "a shear coefficient must be nonzero") + need(set(raw) == {"op", "target", "source", "coefficient"}, "unexpected shear key") + return ("add", target, source, coefficient) + need(kind == "scale", "the alphabet here is shears and scales; swaps are excluded") + need(coefficient not in (0, 1), "a scale must be a non-identity coefficient") + need(set(raw) == {"op", "target", "coefficient"}, "unexpected scale key") + return ("scale", target, coefficient) + + +def apply_rows(letters): + """Apply the letters first to last as row operations on the identity.""" + matrix = identity() + for letter in letters: + if letter[0] == "add": + _, target, source, coefficient = letter + matrix[target] = [matrix[target][c] + coefficient * matrix[source][c] + for c in range(N)] + else: + _, target, coefficient = letter + matrix[target] = [coefficient * entry for entry in matrix[target]] + return matrix + + +def elementary(letter): + matrix = identity() + if letter[0] == "add": + matrix[letter[1]][letter[2]] = letter[3] + else: + matrix[letter[1]][letter[1]] = letter[2] + return matrix + + +def multiply_out(letters): + """Independent route: the product E_last ... E_first of elementary matrices.""" + matrix = identity() + for letter in letters: + matrix = matmul(elementary(letter), matrix) + return matrix + + +def check_word(raw_letters, matcher, scale_row, shear_count): + """One-scale zero-swap word: shear_count shears, then the scale -16 on scale_row.""" + letters = [parse_letter(raw) for raw in raw_letters] + need(len(letters) == shear_count + 1, "wrong letter count for scale row %d" % scale_row) + shears, scale = letters[:-1], letters[-1] + need(all(letter[0] == "add" for letter in shears), "the scale must be the last letter") + need(scale == ("scale", scale_row, SCALE), "the unique scale must be -16 on its row") + need(apply_rows(letters) == matcher, "row operations miss the matcher") + need(multiply_out(letters) == matcher, "elementary-matrix product misses the matcher") + need(determinant(apply_rows(shears)) == 1, "the shear part must have determinant 1") + for first, second in zip(shears, shears[1:]): + need(first[1:3] != second[1:3], "adjacent shears on one position would merge") + return letters + + +def failure_controls(letters, matcher): + """Every single-letter deletion and every mutated coefficient must miss.""" + count = 0 + for index, letter in enumerate(letters): + dropped = letters[:index] + letters[index + 1:] + need(apply_rows(dropped) != matcher, "dropping letter %d still matches" % index) + mutated = letters[:] + mutated[index] = letter[:-1] + (letter[-1] + 1,) + need(apply_rows(mutated) != matcher, "mutating letter %d still matches" % index) + count += 2 + return count + + +def main(): + matcher_raw = json.loads(RESULT.read_text())["matcher"] + need(len(matcher_raw) == N and all(len(row) == N for row in matcher_raw), + "the pinned matcher must be 8 by 8") + matcher = [[Fraction(entry) for entry in row] for row in matcher_raw] + need(determinant(matcher) == SCALE, "the matcher determinant must be -16") + + word = json.loads((PACKAGE / "WORD.json").read_text()) + need(word["letter_counts"] == {"swap": 0, "scale": 1, "add": PRIMARY_SHEARS}, + "WORD.json letter counts") + need(word["scale_row"] == 0 and Fraction(word["scale_coefficient"]) == SCALE, + "WORD.json scale header") + primary = check_word(word["letters"], matcher, 0, PRIMARY_SHEARS) + controls = failure_controls(primary, matcher) + denominators = sorted({letter[3].denominator for letter in primary[:-1]}) + need(denominators == [1, 2, 4, 8, 16], "primary shear denominators") + need(PRIMARY_SHEARS < 26, "the word must be shorter than the 26 shears of PR #7054") + + rows = json.loads((PACKAGE / "ROW_WORDS.json").read_text()) + need(tuple(rows["shear_counts"]) == ROW_SHEARS, "ROW_WORDS.json shear counts") + need(len(rows["words"]) == N, "ROW_WORDS.json must hold one word per scale row") + for scale_row, entry in enumerate(rows["words"]): + need(entry["scale_row"] == scale_row, "ROW_WORDS.json row order") + letters = check_word(entry["letters"], matcher, scale_row, ROW_SHEARS[scale_row]) + controls += failure_controls(letters, matcher) + need(rows["words"][0]["letters"] == word["letters"], "row 0 must equal WORD.json") + + print(TOKEN) + print(json.dumps({ + "matcher_determinant": str(SCALE), + "primary_word": {"swaps": 0, "scales": 1, "shears": PRIMARY_SHEARS, + "scale_row": 0, "shear_denominators": denominators}, + "shears_by_scale_row": list(ROW_SHEARS), + "failure_controls": controls, + "minimum_claimed": False, + "new_kappa": False, + }, sort_keys=True)) + + +if __name__ == "__main__": + main() From 41788bb8a414746f1622df6e3fa7153c99564274 Mon Sep 17 00:00:00 2001 From: Nick Petalas Date: Tue, 17 Nov 2026 22:21:24 +0000 Subject: [PATCH 2/2] fix(ci): sync CI verification doc and historical replay-gap verifier --- docs/ci-verification.md | 19 +++++- .../historical-selected-replay-gap/README.md | 6 +- .../SOURCES.json | 60 +++++++++--------- .../VERIFY.json | 31 +-------- .../historical-selected-replay-gap/verify.py | 63 ++++++++++++++----- 5 files changed, 100 insertions(+), 79 deletions(-) diff --git a/docs/ci-verification.md b/docs/ci-verification.md index 63ba3e9aa8..52b62d0481 100644 --- a/docs/ci-verification.md +++ b/docs/ci-verification.md @@ -1,8 +1,25 @@ # CI verification -## Current selected-family replay: #6030 +## Current selected-family replay: #7000 with #7001 The [selected record](../certificates/selected-result.json) binds conditional +κ = 0.00363005817 to the [application review](research/pr-intake-evidence/pr7000-application/PROOF-REVIEW.md), +[validation receipts](research/pr-intake-evidence/pr7000-application/VALIDATION.json), +and [explicit source closure](../certificates/frontier7000-source.json). +`make frontier7000-verify` follows that exact-source selected replay. The review +reuses eleven authenticated preceding executions and records seven fresh serial +application, scalar and complete native-catalogue executions. The earlier +monolithic timeout is retained separately and is not completed coverage. +Consult the receipts for exact commands, source heads and limits. + +The five inherited framework assumptions remain. No complete uniform word, +literal multiplier execution, independent human proof or formal-kernel proof +is asserted. Routine research submissions do not need to rerun this +selected-family replay. The sections below preserve historical checkpoints. + +## Historical selected-family replay: #6030 + +The [historical checkpoint](../certificates/checkpoints/frontier6030.json) binds conditional κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md), [validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json), and [explicit source closure](../certificates/frontier6030-source.json). diff --git a/research/historical-selected-replay-gap/README.md b/research/historical-selected-replay-gap/README.md index 55d8cc3b49..36d9a873ca 100644 --- a/research/historical-selected-replay-gap/README.md +++ b/research/historical-selected-replay-gap/README.md @@ -69,7 +69,11 @@ python3 -B scripts/research_package.py --package research/historical-selected-re The direct command prints `PASS_HISTORICAL_SELECTED_REPLAY_GAP`. A registered replay prints `PASS_REGISTERED_RESEARCH_PACKAGE`. Both require Git history -containing the two inspected commits. +containing the two inspected commits and the source and manifest objects at +`2485805a6d47f36ea83ddde6327d453ac82d44dc`. The verifier uses a temporary +sparse checkout of that commit, checks the declared source digests there, and +uses its planner and manifest inventory. The recorded rejections and selection +therefore remain reproducible after later changes to the live Makefile or CI guide. ## Open next questions diff --git a/research/historical-selected-replay-gap/SOURCES.json b/research/historical-selected-replay-gap/SOURCES.json index c1010eec95..62bb8b3950 100644 --- a/research/historical-selected-replay-gap/SOURCES.json +++ b/research/historical-selected-replay-gap/SOURCES.json @@ -4,13 +4,13 @@ "files": [ { "path": "Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "0d683a06b9e7ee162496108ce9a7c5d2ee94fccf", "sha256": "4f2d4f2dcd15139ec82658a975f85ed300897385f85799218539f4c8d60567da" }, { "path": "certificates/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "eccafa830c16170c36faf93045ddf1f638f7bcd4", "sha256": "4c0b9d37e1034b2076e30a70f8e514416298c462d9ee98bc87fe6556b14df786" }, @@ -22,7 +22,7 @@ }, { "path": "docs/ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "63ba3e9aa8bdc5e942b56e34244b92b16f854085", "sha256": "c7d3027e9ad8bcbff68f07aa9576b30fb2f3c76c44d876d40c7fdbf4a3e2228a" }, @@ -34,163 +34,163 @@ }, { "path": "research/clifford-state-performance/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "6f98a0061a5104dfab82c9e806f819b41811f684", "sha256": "396d0f08df24952248140d5c65c51b8c902ef1c580892ff7ea182890530f67ee" }, { "path": "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "5e0f92af463ec12c5e1dcc3effd44081a88af647", "sha256": "07a9daeaf2bda308a92e9a4684f13d5fc766c7772d74801fceb7f4599fdab226" }, { "path": "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "9e13266bf85e627f1b7dc225e9530ea69fd2c7f0", "sha256": "421e1211fb1897c45621dc6801c276e53f2e6f335583c9c9049e535f87c0a3b1" }, { "path": "research/community-batch932-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "cc4d03eb59b9ab3f952735f7e88ff18c2d15d7af", "sha256": "184629cac91a5cfaca50330a88596008b824221433867dcf8117539c913c284a" }, { "path": "research/community-batch970-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8b9f4111badf7de5d97684799560b55110e9da79", "sha256": "23188ed920e38a54006cb883e181585620821c63bf7e8b5e05d32719417cc37e" }, { "path": "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "a5300d4e7a5381a3f443fc54c768ca6f0f236d68", "sha256": "3c820fb30e1b4d9bcfc6a7ab524375e5b2abd66b940af2c509146104f0bcd79c" }, { "path": "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "usage": "input", + "usage": "provenance", "git_blob": "d7ff6d777b01d69b6ce84caf25d3b7e4a4d2f211", "sha256": "6b185a9902652f893f3ebd8ada92d2f11b6de6533a9a4d11718a8a4496101128" }, { "path": "research/community-hyperplane599-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "546f37d326d10a99910ae8f908e71ef768524d98", "sha256": "65099d764bfcc39bda5e4d9966783611b094c3522dbdd1435cd498d657a8ef8e" }, { "path": "research/community-k492-audit/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "e538481e4cb16ed936d3195f2dfb5b5a9ca0a76b", "sha256": "2c0f4fa5bc150d05658af2e7c54c4d2c337dd52b7efd3d69530ae73bcbdf452a" }, { "path": "research/community-reconciliation92-audit/MANIFEST.json", - "usage": "input", + "usage": "provenance", "git_blob": "2a2e93685173d5f13cbb5abe740f5d90352e0228", "sha256": "5f501f3c118131e7d069f30ad77186eb2ad6961f9680a0ef105f4514ed41808a" }, { "path": "research/partial-swap-digest/baseline.py", - "usage": "input", + "usage": "provenance", "git_blob": "a2f0190704db83bd8ef48e46e723c49b925804fe", "sha256": "81e9af92cdf38243a540cdcff2062778e449467848d444da37a9553c12ca4c34" }, { "path": "research/r420-two-sided-basis/SOURCES.json", - "usage": "input", + "usage": "provenance", "git_blob": "5d718e11e62f4bcadecf1e02d6b61f87dbe190b0", "sha256": "d9810b0d139c5a1211fd2c1f0d142187cc1fca30026e1e7bc4f9ecfacf1596d1" }, { "path": "research/skip-clones/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "8d1bb3b9c8189e35e5d8bfdfa632d7473e8be0d5", "sha256": "0b68e63e35a97ce6b0cdb6e291b88ebaa8f2dd4afb70b2498f10ee89428258dc" }, { "path": "research/split-skip/SOURCE.json", - "usage": "input", + "usage": "provenance", "git_blob": "2ab610b6ea2edd2865fda793ef2168b0c76afb4f", "sha256": "7c2b4646a3ecfef6f881da5c43e4bd0fa9a4d1b00548b8ab458d897e16735134" }, { "path": "scripts/historical-ci-inputs/Makefile", - "usage": "input", + "usage": "provenance", "git_blob": "aff68409021c9d401a6f8013b9dfd7dbcc30f2a8", "sha256": "ea8830dd79da493e2d75baf753d733ff7efbcf2b4794afe41fae0ac8f3055646" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "65db599ab0b1dea0312c4ca048e0bd0f44c3736f", "sha256": "96ea543e6c707424afe247e77bd86c82152f90fc76a0773c4232145da5cdf8d1" }, { "path": "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "34820a8f24678f918f4d0e7a35380d8013fc3495", "sha256": "628391b6abfbc8674ceec1751867a4392f2cc0b5b66886243e139af86cf355ac" }, { "path": "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "c755b76e0d44ba4917aa94440ebe54daefce5b2a", "sha256": "d7fd929726b326aeeaf0a3996475adec88eee9aac09ae0bebeeaa0bc1fc8f199" }, { "path": "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "usage": "input", + "usage": "provenance", "git_blob": "7f3c012504187917a728b9fe87043f0fc8cd006a", "sha256": "a854022e0e1d5d4db4d60e586be3ea56005013ef14a1fc06d02bc06e8529c4b0" }, { "path": "scripts/historical-ci-inputs/partial-swap-context.json", - "usage": "input", + "usage": "provenance", "git_blob": "ad65114886bf34a4fd27e79f3be502389e689faa", "sha256": "833a9642f33aeab2ffea17ec9c6b82e0a953f90192b2c82e10bef21538dccba9" }, { "path": "scripts/historical-ci-inputs/partial-swap-network.json", - "usage": "input", + "usage": "provenance", "git_blob": "52075f2463f60af5e16571347f24274fce73a1ea", "sha256": "f3c4be597b2f2136da4ae2cc80c7454f63c90aa01f84e5b8131cee4dd55de815" }, { "path": "scripts/partial_swap/shared.py", - "usage": "input", + "usage": "provenance", "git_blob": "44a0e454c70f9c4b98e258b8443612e6a119904b", "sha256": "5a0646a50b9f3e8ea55168620a78e8853b0ab810517cefc8cfb8696aedee278a" }, { "path": "scripts/replay_historical_check.py", - "usage": "input", + "usage": "provenance", "git_blob": "1e92fff2782970ef71378f594f2350d245a4db26", "sha256": "5467619c78183d3adc82b0cb55af28e5c1a01fca2b0588677816244b53e2bafd" }, { "path": "scripts/research_package.py", - "usage": "input", + "usage": "provenance", "git_blob": "091b4c8f58bac9a9580d76025b887dc5c873d05f", "sha256": "e1256016e7f51827d04fa2179255989f639ae1d97afaa9c16265f85a0c6abd70" }, { "path": "scripts/run_isolated_tests.py", - "usage": "input", + "usage": "provenance", "git_blob": "a96ab35b315ce492e7fbbfd6c5ae211aa066b541", "sha256": "49eb56dd0fc0d8d8ffdb209970a7adf2176223580646f575d5c22e59543b381c" }, { "path": "scripts/verify_selected_result.py", - "usage": "input", + "usage": "provenance", "git_blob": "6882a4700e410dec569b51ae2eaf1a19cc019195", "sha256": "d6b305eac5b9bdb8172c469ad30a1655a60fa0aceac8b1bf610e1b73f51babd8" }, { "path": "tests/test_isolated_test_runner.py", - "usage": "input", + "usage": "provenance", "git_blob": "343b24abf6719b81805eba5a84c74e57634c8288", "sha256": "3a5470d0b139828b90e19bf9583ddeafcd69f8e34f2824664eb3a2958a52e34d" } diff --git a/research/historical-selected-replay-gap/VERIFY.json b/research/historical-selected-replay-gap/VERIFY.json index 98553e72ed..ab7efa3471 100644 --- a/research/historical-selected-replay-gap/VERIFY.json +++ b/research/historical-selected-replay-gap/VERIFY.json @@ -4,36 +4,7 @@ "python": "3.12", "requirements": [], "inputs": [ - "Makefile", - "certificates/partial-swap-network.json", - "docs/ci-verification.md", - "research/clifford-state-performance/SOURCE.json", - "research/community-batch1047-audit/CONTENT-COVERAGE.json", - "research/community-batch1099-audit/CONTENT-COVERAGE.json", - "research/community-batch932-audit/CONTENT-COVERAGE.json", - "research/community-batch970-audit/CONTENT-COVERAGE.json", - "research/community-frontier741-audit/CONTENT-COVERAGE.json", - "research/community-frontier890-audit/CONTENT-COVERAGE.json", - "research/community-hyperplane599-audit/SOURCE.json", - "research/community-k492-audit/SOURCE.json", - "research/community-reconciliation92-audit/MANIFEST.json", - "research/partial-swap-digest/baseline.py", - "research/r420-two-sided-basis/SOURCES.json", - "research/skip-clones/SOURCE.json", - "research/split-skip/SOURCE.json", - "scripts/historical-ci-inputs/Makefile", - "scripts/historical-ci-inputs/ledger-batch932-run_isolated_tests.py", - "scripts/historical-ci-inputs/ledger-batch932-test_isolated_test_runner.py", - "scripts/historical-ci-inputs/ledger-batch970-verify_selected_result.py", - "scripts/historical-ci-inputs/ledger-frontier741-ci-verification.md", - "scripts/historical-ci-inputs/partial-swap-context.json", - "scripts/historical-ci-inputs/partial-swap-network.json", - "scripts/partial_swap/shared.py", - "scripts/replay_historical_check.py", - "scripts/research_package.py", - "scripts/run_isolated_tests.py", - "scripts/verify_selected_result.py", - "tests/test_isolated_test_runner.py" + "scripts/research_package.py" ], "commands": [ { diff --git a/research/historical-selected-replay-gap/verify.py b/research/historical-selected-replay-gap/verify.py index 83b995941a..9d266c5a4e 100644 --- a/research/historical-selected-replay-gap/verify.py +++ b/research/historical-selected-replay-gap/verify.py @@ -6,8 +6,10 @@ """ import hashlib import importlib.util +import json import subprocess import sys +import tempfile from pathlib import Path ROOT = Path(__file__).resolve().parents[2] @@ -61,31 +63,47 @@ def require(ok, message): raise SystemExit(message) -def load_checker(): - path = ROOT / "scripts/replay_historical_check.py" - spec = importlib.util.spec_from_file_location("historical_selected_replay_gap_checker", path) +def load_module(path): + spec = importlib.util.spec_from_file_location(path.stem, path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module +def checkout_snapshot(snapshot, sources, runner, env): + paths = [runner.canonical_relative_path(row["path"]) for row in sources["files"]] + git = ["git", "-c", "maintenance.auto=false", "-c", "gc.auto=0", + "-c", "core.autocrlf=false"] + subprocess.run([*git, "clone", "--quiet", "--shared", "--no-tags", "--no-checkout", + "--", str(ROOT), str(snapshot)], cwd=ROOT, env=env, check=True) + subprocess.run([*git, "update-ref", "--no-deref", "HEAD", INSPECTED], + cwd=snapshot, env=env, check=True) + # The pinned planner reads omitted manifests from the sparse HEAD/index. + patterns = "".join(f"/{path.as_posix()}\n" for path in paths) + subprocess.run([*git, "sparse-checkout", "set", "--no-cone", "--stdin"], + cwd=snapshot, env=env, input=patterns.encode("utf-8"), check=True) + subprocess.run([*git, "read-tree", "-mu", "HEAD"], cwd=snapshot, env=env, check=True) + for path, row in zip(paths, sources["files"], strict=True): + require(hashlib.sha256((snapshot / path).read_bytes()).hexdigest() == row["sha256"], + "historical checkout source digest changed: " + path.as_posix()) + + def entries(checker): for name, config in checker.CONFIG.items(): for entry in [config, *config.get("additional_inputs", [])]: yield name, entry -def reject(checker, entry): +def reject(root, checker, entry): try: - checker.authenticated_input(ROOT, entry) + checker.authenticated_input(root, entry) except ValueError as exc: return str(exc) raise SystemExit("historical input was admitted: " + entry["path"]) -def main(): - require(not sys.flags.optimize, "assertions must stay enabled") - checker = load_checker() +def check_snapshot(root, env): + checker = load_module(root / "scripts/replay_historical_check.py") selected = [entry for name, entry in entries(checker) if name == "tooling-ledger" and entry["path"] == SELECTED_PATH] require(len(selected) == 1, "selected-result checker overlay is not unique") @@ -94,7 +112,7 @@ def main(): require(entry["accepted_live_sha256"] == [SELECTED_ACCEPTED], "accepted selected-checker successors changed") frozen = (checker.INPUTS / entry["input"]).read_bytes() - live = (ROOT / SELECTED_PATH).read_bytes() + live = (root / SELECTED_PATH).read_bytes() require(hashlib.sha256(frozen).hexdigest() == SELECTED_PIN, "frozen selected checker bytes changed") require(hashlib.sha256(live).hexdigest() == SELECTED_LIVE, "live selected checker digest changed") require(SELECTED_LIVE not in (SELECTED_PIN, SELECTED_ACCEPTED), "live checker was already admitted") @@ -102,7 +120,7 @@ def main(): # live successor, not a broken comparison. require(SELECTED_PIN in (SELECTED_PIN, *entry["accepted_live_sha256"]), "pin membership control failed") - require(reject(checker, entry) == REJECTIONS[SELECTED_PATH][1], + require(reject(root, checker, entry) == REJECTIONS[SELECTED_PATH][1], "selected checker rejection text changed") counts = {path: 0 for path in REJECTIONS} @@ -110,7 +128,7 @@ def main(): for _name, item in entries(checker): if item["path"] not in REJECTIONS: continue - message = reject(checker, item) + message = reject(root, checker, item) counts[item["path"]] += 1 messages.setdefault(item["path"], message) for path, (count, message) in REJECTIONS.items(): @@ -118,20 +136,31 @@ def main(): require(messages[path] == message, "rejection text changed for " + path) require(sum(counts.values()) == 19, "rejection total changed") ci = [item for _name, item in entries(checker) if item["path"] == CI_PATH] - require(len(ci) == 1 and hashlib.sha256((ROOT / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, + require(len(ci) == 1 and hashlib.sha256((root / CI_PATH).read_bytes()).hexdigest() == CI_LIVE, "selected CI note digest changed") diff = subprocess.check_output( - ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=ROOT, text=True) + ["git", "diff", "--name-only", PARENT, INSPECTED], cwd=root, env=env, text=True) changed = sorted(name for name in diff.splitlines() if name) require(changed == CHANGED, "inspected commit diff changed") - sys.path.insert(0, str(ROOT / "scripts")) - from research_package import plan_details - details = plan_details(ROOT, set(changed)) + planner = load_module(root / "scripts/research_package.py") + details = planner.plan_details(root, set(changed)) require([row["package"] for row in details] == PLAN_PACKAGES, "helper plan selection changed") matched = {name for row in details for names in row["causes"].values() for name in names} require(sorted(set(changed) - matched) == UNMATCHED, "unmatched plan paths changed") - require(plan_details(ROOT, set()) == [], "empty change set selected a package") + require(planner.plan_details(root, set()) == [], "empty change set selected a package") + + +def main(): + require(not sys.flags.optimize, "assertions must stay enabled") + sources = json.loads(Path(__file__).with_name("SOURCES.json").read_bytes()) + require(sources["base_commit"] == INSPECTED, "historical checkout base changed") + runner = load_module(ROOT / "scripts/research_package.py") + env = runner.git_source_env() + with tempfile.TemporaryDirectory(prefix="historical-selected-replay-") as temporary: + snapshot = Path(temporary) / "snapshot" + checkout_snapshot(snapshot, sources, runner, env) + check_snapshot(snapshot, env) print("PASS_HISTORICAL_SELECTED_REPLAY_GAP") print("selected_checker_live=" + SELECTED_LIVE) print("rejections=19 distinct_paths=7 plan_packages=9")