From b9383c268b33961194b821a6fe393c87936e88fa Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 04:22:38 -0500 Subject: [PATCH 1/2] Research compensated P104 null-pair shear --- .../CERTIFICATE.json | 1302 +++++++++++++++++ .../CLAIM.md | 5 + .../HANDOFF.md | 10 + .../README.md | 53 + .../SOURCES.json | 42 + .../TASK.json | 66 + .../VERIFY.json | 24 + .../verify.py | 402 +++++ 8 files changed, 1904 insertions(+) create mode 100644 research/p104-nullpair-compensated-shear-seed318bd5/CERTIFICATE.json create mode 100644 research/p104-nullpair-compensated-shear-seed318bd5/CLAIM.md create mode 100644 research/p104-nullpair-compensated-shear-seed318bd5/HANDOFF.md create mode 100644 research/p104-nullpair-compensated-shear-seed318bd5/README.md create mode 100644 research/p104-nullpair-compensated-shear-seed318bd5/SOURCES.json create mode 100644 research/p104-nullpair-compensated-shear-seed318bd5/TASK.json create mode 100644 research/p104-nullpair-compensated-shear-seed318bd5/VERIFY.json create mode 100644 research/p104-nullpair-compensated-shear-seed318bd5/verify.py diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/CERTIFICATE.json b/research/p104-nullpair-compensated-shear-seed318bd5/CERTIFICATE.json new file mode 100644 index 0000000000..860f053725 --- /dev/null +++ b/research/p104-nullpair-compensated-shear-seed318bd5/CERTIFICATE.json @@ -0,0 +1,1302 @@ +{ + "algebra": { + "identity": "(a+z)b^T + z(w-b)^T + (iz)(iw)^T = ab^T", + "input_decoder_entries_checked": 10816, + "input_identity_errors": 0, + "transformed_identity_entries_checked": 10816, + "transformed_identity_errors": 0, + "wrong_sign_control_errors": 3692 + }, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "cost": { + "baseline_copied_rank": 56, + "baseline_term_ranks": [ + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7 + ], + "best_case_centre_plus_one_moment_upper": "115807307776767559794342214683484298741241502119077637494952475050028951347019/115792089237316195423570985008687907853269984665640564039457584007913129639936", + "block_rank_histogram": { + "21": 64, + "22": 384, + "23": 14888, + "24": 178968, + "25": 155520, + "26": 1489536 + }, + "five_percent_target_a": "35491136290869/20000000000000000", + "minimum_block_examples": [ + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "-1" + ], + [ + "0", + "-1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "1" + ], + [ + "0", + "1" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + }, + { + "pivot": 2, + "term_ranks": [ + 7, + 7, + 7 + ], + "w": [ + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ], + "z": [ + [ + "0", + "0" + ], + [ + "1", + "0" + ], + [ + "0", + "0" + ], + [ + "-1", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ], + [ + "0", + "0" + ] + ] + } + ], + "minimum_replacement_block_rank": 21, + "minimum_total_copied_rank": 70, + "p104_base_ceiling_bracket": [ + "1781965480167/1000000000000000", + "222745685021/125000000000000" + ], + "profile_classes": 6, + "profile_model": "P104 ports=8, centre=56; replace one rank-7 child by the three exact pairing ranks; add six rank-one preparation/use/cleanup charges", + "profiles_clearing_5_percent_screen": 1839360, + "profiles_with_strict_copy_saving_that_clear_screen": false, + "qualifying_candidate_count_capped_at_16": 0, + "unpriced_physical_obligations": [ + "phase-frame legality", + "whole-call hosting", + "precision", + "native dirty-state boundary" + ] + }, + "domain": { + "coordinate_axes": 8, + "distinct_ordered_z_w": 229920, + "live_lines": 104, + "nonzero_coefficients": [ + "1", + "-1", + "i", + "-i" + ], + "pivots": 8, + "stopping_rule": "exhaust the stated Gaussian-unit two-coordinate family over all eight pivot terms", + "support_per_vector_at_most": 2, + "total_pivot_pairs": 1839360 + }, + "mechanism": "append one exact complex null pair (z,w),(iz,iw) and apply a compensated one-pivot 3-column shear", + "notes": [ + "Every changed term's copied-information charge is its exact F2 rank of the live-line label-pairing matrix.", + "The six rank-one charges cover two sparse-vector preparations, two shear forms, and clearing both scratch vectors.", + "The P104 screen retains the existing eight ports and centre=56; any extra centre unit fails the target control.", + "No selected supplier, kappa, or frontier change is claimed." + ], + "seed": "318bd5e5f93c401334e29c6764720302", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "source_sha256": { + "P104 decoder": "8e0178db02c14e1b29058cdbdbd50aac22f2b55a1ba21dc82f417610c9932526", + "ceiling engine": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc", + "ceiling result": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d", + "frame-pair predecessor": "bdf7ee497dc04dfc634ee5b7848f6a2b39b0169668fb1a60a9715111dbd15395" + }, + "status": "completed_scoped_negative", + "task_id": "complex-new-helper-inventory", + "track": "complex-mechanisms" +} diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/CLAIM.md b/research/p104-nullpair-compensated-shear-seed318bd5/CLAIM.md new file mode 100644 index 0000000000..d43b3138f9 --- /dev/null +++ b/research/p104-nullpair-compensated-shear-seed318bd5/CLAIM.md @@ -0,0 +1,5 @@ +# Research claim + +Remote claim: [Discussion #1762](https://github.com/CrocSwap/integer-mult-bounds/discussions/1762), created 2026-10-14. The accepted assignment is seed `318bd5e5f93c401334e29c6764720302`, track `complex-mechanisms`, task `complex-new-helper-inventory`, priority revision 3, base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`, selector scope key `5868e5281a1e63d41a22`, selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. + +The claim tests a one-pivot compensated shear after appending one complex isotropic cancelling pair to PR717's P104 eight-term decoder. The domain is all eight pivots and all distinct ordered Gaussian-unit vectors supported on at most two standard coordinates. The result, exact cost boundary, reproduction command and remaining physical obligations are recorded in [README.md](README.md) and [CERTIFICATE.json](CERTIFICATE.json). diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/HANDOFF.md b/research/p104-nullpair-compensated-shear-seed318bd5/HANDOFF.md new file mode 100644 index 0000000000..07e4157a50 --- /dev/null +++ b/research/p104-nullpair-compensated-shear-seed318bd5/HANDOFF.md @@ -0,0 +1,10 @@ +# Cycle 7 handoff + +- **Assignment:** seed `318bd5e5f93c401334e29c6764720302`; `complex-mechanisms / complex-new-helper-inventory`; priority revision 3; scope key `5868e5281a1e63d41a22`. +- **Pins:** base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- **Finding:** the one-pivot compensated isotropic null-pair shear is exact, but across all 1,839,360 candidates in the stated Gaussian-unit two-coordinate family it costs at least 21 support-pair rank in place of 7. The best ten-term inventory therefore costs at least 70 versus 56 before any extra physical overhead. This is a scoped negative result, not a theorem for wider supports or arbitrary ten-term decoders. +- **Verification:** `python3.12 -I -B research/p104-nullpair-compensated-shear-seed318bd5/verify.py`; expected marker is in [README.md](README.md). The checker verifies the 104-by-104 base and transformed identities, the support-rank census, the six-rank-one cost screen and a wrong-sign control. +- **Publication:** the claim is [Discussion #1762](https://github.com/CrocSwap/integer-mult-bounds/discussions/1762). No PR has been opened yet. Before any PR, refresh current PR and Discussion overlap and report only this bounded result. +- **Remaining obligations:** physical phase-frame legality, whole-call hosting, precision and native dirty-state realization were not built because the copy-rank cost already rises by 14. No supplier or κ change is claimed. + +Prepared by OpenAI Codex with substantial AI assistance; no independent human review is claimed. diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/README.md b/research/p104-nullpair-compensated-shear-seed318bd5/README.md new file mode 100644 index 0000000000..5d744a5125 --- /dev/null +++ b/research/p104-nullpair-compensated-shear-seed318bd5/README.md @@ -0,0 +1,53 @@ +# A sparse isotropic null-pair shear raises the P104 copy rank + +This is a bounded negative result for one new ten-term complex-decoder mechanism. Starting from PR717's exact eight-term P104 decoder, append a cancelling pair `(z,w),(iz,iw)` and mix it with one pivot term `(a,b)`. The exact shear + +```text +(a,b), (z,w), (iz,iw) + -> (a+z,b), (z,w-b), (iz,iw) +``` + +preserves the decoder because `(iz)(iw)^T = -zw^T`. The changed term inventory does not reduce its copied-information charge: across all eight pivots and the complete two-coordinate Gaussian-unit alphabet, the three replacement terms have total F2 support-pair rank at least 21, while the original term costs 7. The smallest resulting ten-term inventory costs at least 70, compared with 56 for the original eight terms. The mechanism therefore stops at the exact copy screen, before a physical compiler or new κ is justified. + +The finite domain contains every nonzero vector in `Z[i]^8` supported on one or two standard coordinates with each nonzero coordinate in `{1,-1,i,-i}`: 480 vectors. Every ordered distinct pair `(z,w)` and each of the eight PR717 pivot terms is tested, for `480·479·8 = 1,839,360` candidates. The replacement charge is + +```text +rank_F2(S(a+z), S(b)) + rank_F2(S(z), S(w-b)) + rank_F2(S(z), S(w)), +``` + +where `S(v)` is the set of 104 live E8 lines having nonzero pairing with `v`, and the rank uses the inherited label matrix `(+1) mod 2`. The exact block-rank histogram is `21:64, 22:384, 23:14888, 24:178968, 25:155520, 26:1489536`. + +## Budget and limits + +The favorable P104 screen retains its eight ports and centre charge 56. Its exact complex-side ceiling bracket is `[1781965480167/10^15, 222745685021/125000000000000]`, with upper endpoint `0.001781965480168`. This is 5.438% above the selected fixed-word ceiling `0.001690054109089`; the five-percent threshold is `0.00177455681454345`. That headroom comes from the pre-existing P104 port/centre profile, not from the null-pair shear. For each proposed block, the per-call profile replaces one rank-7 child by the three exact support-pair ranks and charges six rank-1 tasks for preparing `z,w`, forming the two shear forms and clearing the scratch values. The exact moment screen alone still clears the inherited five-percent threshold, but the copied-rank bill is strictly worse: every block adds at least 14 copied-rank units before frame, hosting, precision or native dirty-boundary costs. One extra centre unit also fails the five-percent screen even under the hypothetical `(1,1,1)` replacement. Thus the null-pair family adds cost to an already favorable relaxation and supplies no new cost reduction. + +The evidence is limited to the stated two-coordinate, Gaussian-unit, one-pivot family on PR717's P104 factorization. It is not a lower bound for wider supports, other coefficients, multiple interacting pivots, arbitrary ten-term decoders, or other root systems. The exact 104-by-104 input identity and one transformed 104-by-104 identity are checked. A wrong-sign shear is a negative control. The selected record and its source files are unchanged. No physical supplier, selected κ, or multiplication theorem is claimed. + +## Reproduce + +From the repository root, Python 3.12 and the standard library are sufficient: + +```sh +python3.12 -I -B research/p104-nullpair-compensated-shear-seed318bd5/verify.py +python3 scripts/research_package.py --package research/p104-nullpair-compensated-shear-seed318bd5 --check-only +``` + +Expected marker: + +```text +PASS_P104_NULLPAIR_COMPENSATED_SHEAR domain=1839360 min_block_rank=21 saving_pass=False identity_errors=0 no_new_kappa +``` + +The certificate records exact source hashes, the rank histogram, the selected representative, the target screen and failure controls. The first command regenerates the deterministic result in memory and checks it against `CERTIFICATE.json`. + +## Overlap and provenance + +The selector accepted seed `318bd5e5f93c401334e29c6764720302` on `complex-mechanisms`, card `complex-new-helper-inventory`, priority revision 3, base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 is `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. The original claim is [Discussion #1762](https://github.com/CrocSwap/integer-mult-bounds/discussions/1762). + +PR717 supplies the P104 input factorization. Discussion #1622 / PR1633 classifies the algebraic residual-rank budget for all term counts but leaves support/copy-cost construction open. Open PR1726 screens one and two elementary term-basis shears in the original eight-term decoder; this package instead adds a cancelling complex pair and changes the term count to ten. Discussion #1674 changes nested endpoints of the selected k8 word with its scalar gates fixed, a different interface. + +Prepared by OpenAI Codex with substantial AI assistance. No independent human review is claimed. Apache-2.0. + +## Open next questions + +Could a compensated null-pair shear with three-coordinate supports or non-unit Gaussian coefficients produce a lower copied-rank block? This would test whether the cost obstruction comes from the narrow support alphabet or from the isotropic cancellation mechanism itself. First derive a stronger support-rank inequality or choose one finite three-coordinate alphabet, price its exact profile and physical generation costs, and claim that scope before searching. The current package stops at support two and proves nothing about those larger domains. diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/SOURCES.json b/research/p104-nullpair-compensated-shear-seed318bd5/SOURCES.json new file mode 100644 index 0000000000..5785784a36 --- /dev/null +++ b/research/p104-nullpair-compensated-shear-seed318bd5/SOURCES.json @@ -0,0 +1,42 @@ +{ + "schema_version": 1, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "research/complex-frame-pair-decoders/inputs/pr717/P104_HIT_flip_3a.txt", + "usage": "input", + "git_blob": "458ddb13dcf73ed031ffb96d9df149c994c7e4ee", + "sha256": "8e0178db02c14e1b29058cdbdbd50aac22f2b55a1ba21dc82f417610c9932526" + }, + { + "path": "research/complex-local-word-ceiling/ceiling.py", + "usage": "input", + "git_blob": "6c0f54527d879396f689523bfde19928a9b6157c", + "sha256": "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc" + }, + { + "path": "research/complex-local-word-ceiling/RESULT.json", + "usage": "input", + "git_blob": "77f55043a679dd722330f1e2499863e36376d9f9", + "sha256": "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d" + }, + { + "path": "research/complex-frame-pair-decoders/verify.py", + "usage": "provenance", + "git_blob": "57dd8993e8ac016e8a92a9a885392b58014137bb", + "sha256": "bdf7ee497dc04dfc634ee5b7848f6a2b39b0169668fb1a60a9715111dbd15395" + } + ] +} diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/TASK.json b/research/p104-nullpair-compensated-shear-seed318bd5/TASK.json new file mode 100644 index 0000000000..0187669c58 --- /dev/null +++ b/research/p104-nullpair-compensated-shear-seed318bd5/TASK.json @@ -0,0 +1,66 @@ +{ + "schema_version": 1, + "task_id": "complex-new-helper-inventory", + "priority_revision": 3, + "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea", + "assignment_seed": "318bd5e5f93c401334e29c6764720302", + "track": "complex-mechanisms", + "selector_scope_key": "5868e5281a1e63d41a22", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "original_card": { + "id": "complex-new-helper-inventory", + "question": "Can a new local cost interface change the deficit-to-recursive-cost ratio beyond current packing?", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/heterogeneous-owner-assembly/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Propose a changed helper inventory and derive an optimistic exact moment.", + "Design a small completed instance and independently verify its endpoint and rank bill." + ], + "acceptance_gate": "A new physically realizable contract outside the frozen catalogue whose per-call profile, screened with ceiling.ceiling(), beats the selected word's packing ceiling; a lower cap does not establish identical circuitry or order attainable optima, and is insufficient to pass the stronger-budget target under this model.", + "first_step": { + "command": [ + "python3", + "-B", + "research/complex-local-word-ceiling/verify.py" + ], + "expected": "PASS_COMPLEX_LOCAL_WORD_CEILING", + "inspect": "Read the selected word's per-call local profile, its packing ceiling and the lever table; run levers.py for the ideal budget of the lever you target.", + "scope": "Positive control and planning budget only; this is not a new construction or full cold replay." + }, + "first_experiment": "Before any synthesis, write the candidate per-call local profile (and centre charge / unpaid coordinates if changed) and screen it with ceiling.ceiling(); reject it if even the ideal ceiling does not beat the selected word's by your stated margin.", + "bottleneck_link": "Packing of the selected word is capped at +0.87% (ceiling model); only a lower local excess spend or a changed coverage law raises the cap.", + "allowed_variations": [ + "Narrow to one changed boundary or helper type with explicit counts.", + "If the coverage law, template or guard changes, derive an applicable fully charged replacement bound instead of applying the incumbent ceiling outside its scope." + ], + "scope_change_triggers": [ + "Mixing only providers already inside the pinned catalogue." + ], + "overlap_terms": [ + "helper inventory", + "heterogeneous-owner", + "mutable leaver" + ] + }, + "scope_status": "changed", + "actual_scope": "For one PR717 P104 decoder pivot, append a Gaussian-integer isotropic null pair and apply one compensated 3-column shear; exhaust every distinct ordered z,w supported on at most two standard coordinates with Gaussian-unit entries, then price exact support-pair ranks and the per-call moment profile.", + "scope_change_reason": "The broad card asks for a changed helper inventory. This experiment changes the exact decoder term count from eight to ten by adding a cancelling complex null pair, rather than reassigning the original eight term bases or moving nested endpoints in the selected word. The support domain is bounded and independently exact. Its optimistic profile clears the local 5% screen only if the existing centre charge stays fixed; the copied-rank census decides whether any candidate merits physical compilation.", + "bottleneck_link": "The P104 eight-term copy bill is 56. A lower-cost ten-term factorization could change the local recursive profile, but this compensated family has minimum block bill 21 replacing one rank-7 term, so its total copied rank is at least 70 before physical overhead.", + "budget_minutes": 60, + "stop_rule": "Enumerate all 480 Gaussian-unit vectors with support at most two of the eight standard coordinates, all ordered distinct z,w pairs, and all eight decoder pivots. Stop at this domain; do not infer bounds for wider supports, other coefficients, multiple pivots, or arbitrary ten-term decoders.", + "outcome": "negative-result", + "evidence": "CERTIFICATE.json: 1,839,360 pivot/pair candidates; exact block-rank minimum 21 versus baseline 7; total copied-rank minimum 70 versus baseline 56; exact 104-by-104 input and transformed identities; wrong-sign control fails; the per-call screen includes six rank-one setup/cleanup charges. The candidate profile still clears the inherited P104 five-percent relaxation, but the unmodified P104 decoder already clears it and every compensated block strictly increases copied rank.", + "author": "OpenAI Codex", + "ai_assistance": "Substantial: OpenAI Codex derived the null-pair shear, implemented the exact E8 support/rank census, constructed the budget screen and wrote the package. No independent human review is claimed.", + "open_questions": [ + { + "question": "Can three-coordinate supports or non-unit Gaussian coefficients make this compensated null-pair shear reduce the copied-rank bill?", + "why_it_matters": "Only a lower-cost block could alter the complex helper inventory enough to justify physical compilation.", + "first_step": "Derive a support-rank lower bound or define one bounded three-coordinate coefficient alphabet, calculate its complete charged ceiling first, then claim and enumerate that scope.", + "blocked_by": "This package exhausts only the two-coordinate Gaussian-unit domain and provides no general support inequality." + } + ] +} diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/VERIFY.json b/research/p104-nullpair-compensated-shear-seed318bd5/VERIFY.json new file mode 100644 index 0000000000..571413a69a --- /dev/null +++ b/research/p104-nullpair-compensated-shear-seed318bd5/VERIFY.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/complex-frame-pair-decoders/inputs/pr717/P104_HIT_flip_3a.txt", + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-local-word-ceiling/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 300, + "checks": "Recomputes the 1,839,360 exact P104 null-pair candidates, their support-pair rank histogram and six-child local screen; verifies both 104x104 identities and a wrong-sign failure control; checks the output against CERTIFICATE.json." + } + ] +} diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/verify.py b/research/p104-nullpair-compensated-shear-seed318bd5/verify.py new file mode 100644 index 0000000000..9198c66eb3 --- /dev/null +++ b/research/p104-nullpair-compensated-shear-seed318bd5/verify.py @@ -0,0 +1,402 @@ +#!/usr/bin/env python3 +"""Exact finite screen for a compensated isotropic null-pair shear on PR717 P104.""" +from __future__ import annotations + +import hashlib +import itertools +import json +import sys +from collections import Counter +from fractions import Fraction as Q +from functools import lru_cache +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +TASK_SEED = "318bd5e5f93c401334e29c6764720302" +BASE = "0b1cccf86e2f5132ed286a26ef0a681a495740ea" +SELECTED = "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" +INPUT = ROOT / "research/complex-frame-pair-decoders/inputs/pr717/P104_HIT_flip_3a.txt" + + +def require(ok: bool, message: str) -> None: + if not ok: + raise AssertionError(message) + + +def sha(path: Path) -> str: + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def e8_roots(): + roots = [] + for i, j in itertools.combinations(range(8), 2): + for si in (1, -1): + for sj in (1, -1): + v = [0] * 8 + v[i], v[j] = 2 * si, 2 * sj + roots.append(tuple(v)) + for s in itertools.product((1, -1), repeat=8): + if s.count(-1) % 2 == 0: + roots.append(tuple(s)) + return roots + + +def ip(x, y): + d = sum(a * b for a, b in zip(x, y)) + require(d % 4 == 0, "nonintegral E8 inner product") + return d // 4 + + +def rank_q(rows): + rows = [[Q(x) for x in row] for row in rows] + rank = 0 + for col in range(len(rows[0]) if rows else 0): + pivot = next((i for i in range(rank, len(rows)) if rows[i][col]), None) + if pivot is None: + continue + rows[rank], rows[pivot] = rows[pivot], rows[rank] + p = rows[rank][col] + rows[rank] = [x / p for x in rows[rank]] + for i in range(len(rows)): + if i != rank and rows[i][col]: + q = rows[i][col] + rows[i] = [x - q * z for x, z in zip(rows[i], rows[rank])] + rank += 1 + return rank + + +def solve_square(a, y): + n = len(a) + m = [[Q(x) for x in row] + [Q(v)] for row, v in zip(a, y)] + for col in range(n): + pivot = next(i for i in range(col, n) if m[i][col]) + m[col], m[pivot] = m[pivot], m[col] + q = m[col][col] + m[col] = [x / q for x in m[col]] + for i in range(n): + if i != col and m[i][col]: + q = m[i][col] + m[i] = [x - q * z for x, z in zip(m[i], m[col])] + return tuple(m[i][-1] for i in range(n)) + + +def load_hit(path): + d, t = [], [] + for line in path.read_text().splitlines(): + s = line.strip() + if s.startswith("d:"): + d.append([int(x) for x in s[2:].split()]) + elif s.startswith("t:"): + t.append([int(x) for x in s[2:].split()]) + return [list(x) for x in zip(*d)], [list(x) for x in zip(*t)] + + +def gauss_add(x, y): + return tuple((a[0] + b[0], a[1] + b[1]) for a, b in zip(x, y)) + + +def gauss_sub(x, y): + return tuple((a[0] - b[0], a[1] - b[1]) for a, b in zip(x, y)) + + +def gauss_i(x): + return tuple((-a[1], a[0]) for a in x) + + +def gauss_dot(root, x): + re = sum(Q(a, 4) * v[0] for a, v in zip(root, x)) + im = sum(Q(a, 4) * v[1] for a, v in zip(root, x)) + return re, im + + +def recover(live, col, line_table): + selected = [] + for idx in range(len(live)): + cand = selected + [idx] + if rank_q([line_table[live[j]] for j in cand]) == len(cand): + selected.append(idx) + if len(selected) == 8: + break + require(len(selected) == 8, "P104 live labels do not span the 8-space") + mat = [[Q(x, 4) for x in line_table[live[j]]] for j in selected] + v = solve_square(mat, [col[j] for j in selected]) + require(all(sum(Q(x, 4) * y for x, y in zip(line_table[idx], v)) == col[p] + for p, idx in enumerate(live)), "decoder column is not a linear form on E8") + return tuple((x, Q(0)) for x in v) + + +def e8_data(): + line_table, seen = [], set() + for r in e8_roots(): + neg = tuple(-x for x in r) + key = r if r > neg else neg + if key not in seen: + seen.add(key) + line_table.append(r) + index = {v: i for i, v in enumerate(line_table)} + f0 = [] + for a in range(4): + for s in (1, -1): + v = [0] * 8 + v[2 * a], v[2 * a + 1] = 2, 2 * s + f0.append(index[tuple(v)]) + p112 = [i for i in range(120) if i not in f0] + puncture = [p112[q] for q in (9, 15, 24, 46, 52, 66, 94, 104)] + live = [i for i in range(120) if i not in f0 and i not in puncture] + require(len(line_table) == 120 and len(live) == 104, "E8 / P104 census") + iptab = [[ip(line_table[i], line_table[j]) for j in range(120)] for i in range(120)] + nrow = [sum(((iptab[i][j] + 1) & 1) << j for j in range(120)) for i in range(120)] + return line_table, f0, puncture, live, iptab, nrow + + +def candidates(): + units = ((1, 0), (-1, 0), (0, 1), (0, -1)) + zero = (0, 0) + out = set() + for k in (1, 2): + for pos in itertools.combinations(range(8), k): + for coeff in itertools.product(units, repeat=k): + v = [zero] * 8 + for j, c in zip(pos, coeff): + v[j] = c + out.add(tuple((Q(a), Q(b)) for a, b in v)) + return tuple(sorted(out)) + + +def matrix_errors(terms, live, line_table, iptab): + errors = 0 + for i in live: + for j in live: + re, im = Q(0), Q(0) + for x, y in terms: + gx, gy = gauss_dot(line_table[i], x), gauss_dot(line_table[j], y) + re += gx[0] * gy[0] - gx[1] * gy[1] + im += gx[0] * gy[1] + gx[1] * gy[0] + errors += (re, im) != (2 * iptab[i][j], 0) + return errors + + +def run(): + selected_path = ROOT / "certificates/selected-result.json" + selected = json.loads(selected_path.read_text()) + require(sha(selected_path) == SELECTED, "selected record pin changed") + pins = { + "P104 decoder": (INPUT, "8e0178db02c14e1b29058cdbdbd50aac22f2b55a1ba21dc82f417610c9932526"), + "ceiling engine": (ROOT / "research/complex-local-word-ceiling/ceiling.py", + "86a1432870b3b21d8454106ec9162fddc0471472d9214c590a1420f2426cedfc"), + "ceiling result": (ROOT / "research/complex-local-word-ceiling/RESULT.json", + "d91d6c46509875abf1f61de67c2609656d3dc685451299f83caa6f922493692d"), + "frame-pair predecessor": (ROOT / "research/complex-frame-pair-decoders/verify.py", + "bdf7ee497dc04dfc634ee5b7848f6a2b39b0169668fb1a60a9715111dbd15395"), + } + for name, (path, expected) in pins.items(): + require(sha(path) == expected, f"{name} SHA-256 changed: {sha(path)}") + + line_table, _, _, live, iptab, nrow = e8_data() + dcols, tcols = load_hit(INPUT) + require(len(dcols) == len(tcols) == 104 and len(dcols[0]) == 8, "P104 decoder dimensions") + old_errors = 0 + for i in range(104): + for j in range(104): + old_errors += sum(dcols[i][k] * tcols[j][k] for k in range(8)) != 2 * iptab[live[i]][live[j]] + require(old_errors == 0, "PR717 source decoder does not satisfy the P104 identity") + old_terms = [] + for k in range(8): + a = recover(live, [dcols[p][k] for p in range(104)], line_table) + b = recover(live, [tcols[p][k] for p in range(104)], line_table) + old_terms.append((a, b)) + + @lru_cache(None) + def support(v): + mask = 0 + for idx in live: + if gauss_dot(line_table[idx], v) != (0, 0): + mask |= 1 << idx + return mask + + def rank_rows(rows): + basis, rank = {}, 0 + for v in rows: + while v: + bit = v.bit_length() - 1 + if bit in basis: + v ^= basis[bit] + else: + basis[bit] = v + rank += 1 + break + return rank + + @lru_cache(None) + def pair_rank(rowmask, colmask): + rows = [idx for idx in live if (rowmask >> idx) & 1] + return rank_rows([nrow[idx] & colmask for idx in rows]) + + old_costs = [pair_rank(support(a), support(b)) for a, b in old_terms] + require(old_costs == [7] * 8, f"PR717 P104 floor input changed: {old_costs}") + + # Exact P104 optimistic profile: eight port cuts and eight rank-8 to rank-7 units. + local = {1: 2356, 2: 418, 3: 432, 4: 134, 5: 74, 7: 8} + sys.path.insert(0, str(ROOT / "research/complex-local-word-ceiling")) + import ceiling # pylint: disable=import-outside-toplevel + # Reuse the exact transcendental enclosures for repeated candidate histograms. + original_child_cost = ceiling.child_cost + child_cost_cache = {} + def cached_child_cost(r, m, a): + key = (r, m, a) + if key not in child_cost_cache: + child_cost_cache[key] = original_child_cost(r, m, a) + return child_cost_cache[key] + ceiling.child_cost = cached_child_cost + result = json.loads((ROOT / "research/complex-local-word-ceiling/RESULT.json").read_text()) + target = Q(result["ceiling"]["a_ceiling"]) * Q(105, 100) + p104_lo, p104_hi = ceiling.ceiling(local, 73, 832, 9, 56) + require(p104_lo == Q(1781965480167, 10**15) and p104_hi == Q(222745685021, 125000000000000), + "P104 baseline ceiling does not match the pinned exact model") + require(p104_hi > target, "the existing P104 eight-term profile fails the 5% planning gate") + + @lru_cache(None) + def screen(triple): + hist = local.copy() + hist[7] -= 1 + for r in triple: + if r: + hist[r] = hist.get(r, 0) + 1 + hist[1] += 6 # prepare z,w; form the shear; clear z,w + lo, hi = ceiling.relax(hist, 73, 832, 9, 56, target) + return str(lo), str(hi), hi < 1 + + family = candidates() + require(len(family) == 480, "two-coordinate Gaussian-unit alphabet size") + domain = len(family) * (len(family) - 1) * 8 + triple_hist, pass_hist, block_hist = Counter(), Counter(), Counter() + min_block, min_examples, qualifying = 999, [], [] + for pivot, (a, b) in enumerate(old_terms): + sb = support(b) + for z in family: + sz = support(z) + c1 = pair_rank(support(gauss_add(a, z)), sb) + for w in family: + if z == w: + continue + c2 = pair_rank(sz, support(gauss_sub(w, b))) + c3 = pair_rank(sz, support(w)) + triple = tuple(sorted((c1, c2, c3))) + triple_hist[triple] += 1 + passed = screen(triple)[2] + if passed: + pass_hist[triple] += 1 + block = c1 + c2 + c3 + block_hist[block] += 1 + record = (pivot, z, w, (c1, c2, c3)) + if block < min_block: + min_block, min_examples = block, [record] + elif block == min_block and len(min_examples) < 16: + min_examples.append(record) + if block < 7 and passed and len(qualifying) < 16: + qualifying.append(record) + + require(sum(triple_hist.values()) == domain, "search domain count") + chosen = qualifying[0] if qualifying else min_examples[0] + pivot, z, w, chosen_ranks = chosen + a, b = old_terms[pivot] + terms = list(old_terms) + terms.pop(pivot) + terms.extend(((gauss_add(a, z), b), (z, gauss_sub(w, b)), (gauss_i(z), gauss_i(w)))) + errors = matrix_errors(terms, live, line_table, iptab) + require(errors == 0, "compensated 10-term decoder failed the 104x104 identity") + + # Negative control: use the wrong sign in the inverse target shear. + unit_vectors = [v for v in family if sum(x != (0, 0) for x in v) == 1] + zc, wc = unit_vectors[0], unit_vectors[-1] + ac, bc = old_terms[0] + bad = list(old_terms) + bad.pop(0) + bad.extend(((gauss_add(ac, zc), bc), (zc, gauss_add(wc, bc)), (gauss_i(zc), gauss_i(wc)))) + bad_errors = matrix_errors(bad, live, line_table, iptab) + require(bad_errors > 0, "wrong-sign control unexpectedly exact") + + # Centre +1 control with the best possible replacement ranks (1,1,1). + hist57 = local.copy() + hist57[7] -= 1 + hist57[1] += 9 # three rank-one children plus six setup children + _, hi57 = ceiling.relax(hist57, 73, 832, 9, 57, target) + require(hi57 > 1, "centre+1 negative control unexpectedly clears the target") + + block_best_pass = any(sum(t) < 7 and screen(t)[2] for t in triple_hist) + out = { + "status": "completed_scoped_construction" if qualifying else "completed_scoped_negative", + "seed": TASK_SEED, + "track": "complex-mechanisms", + "task_id": "complex-new-helper-inventory", + "base_commit": BASE, + "selected_record_sha256": SELECTED, + "source_sha256": {name: expected for name, (_, expected) in pins.items()}, + "mechanism": "append one exact complex null pair (z,w),(iz,iw) and apply a compensated one-pivot 3-column shear", + "domain": { + "live_lines": 104, + "pivots": 8, + "coordinate_axes": 8, + "nonzero_coefficients": ["1", "-1", "i", "-i"], + "support_per_vector_at_most": 2, + "distinct_ordered_z_w": len(family) * (len(family) - 1), + "total_pivot_pairs": domain, + "stopping_rule": "exhaust the stated Gaussian-unit two-coordinate family over all eight pivot terms", + }, + "algebra": { + "identity": "(a+z)b^T + z(w-b)^T + (iz)(iw)^T = ab^T", + "input_decoder_entries_checked": 104 * 104, + "input_identity_errors": old_errors, + "transformed_identity_entries_checked": 104 * 104, + "transformed_identity_errors": errors, + "wrong_sign_control_errors": bad_errors, + }, + "cost": { + "baseline_term_ranks": old_costs, + "baseline_copied_rank": sum(old_costs), + "p104_base_ceiling_bracket": [str(p104_lo), str(p104_hi)], + "five_percent_target_a": str(target), + "minimum_replacement_block_rank": min_block, + "minimum_total_copied_rank": 49 + min_block, + "block_rank_histogram": {str(k): v for k, v in sorted(block_hist.items())}, + "profile_classes": len(triple_hist), + "profiles_clearing_5_percent_screen": sum(pass_hist.values()), + "profiles_with_strict_copy_saving_that_clear_screen": block_best_pass, + "qualifying_candidate_count_capped_at_16": len(qualifying), + "minimum_block_examples": [{"pivot": k, "z": [[str(a), str(b)] for a, b in zz], + "w": [[str(a), str(b)] for a, b in ww], "term_ranks": list(rs)} + for k, zz, ww, rs in min_examples], + "profile_model": "P104 ports=8, centre=56; replace one rank-7 child by the three exact pairing ranks; add six rank-one preparation/use/cleanup charges", + "five_percent_target_a": str(target), + "best_case_centre_plus_one_moment_upper": str(hi57), + "unpriced_physical_obligations": ["phase-frame legality", "whole-call hosting", "precision", "native dirty-state boundary"], + }, + "notes": [ + "Every changed term's copied-information charge is its exact F2 rank of the live-line label-pairing matrix.", + "The six rank-one charges cover two sparse-vector preparations, two shear forms, and clearing both scratch vectors.", + "The P104 screen retains the existing eight ports and centre=56; any extra centre unit fails the target control.", + "No selected supplier, kappa, or frontier change is claimed.", + ], + } + return out + + +def main(): + out = run() + cert = HERE / "CERTIFICATE.json" + if "--write" in sys.argv: + cert.write_text(json.dumps(out, indent=2, sort_keys=True) + "\n") + else: + require(cert.exists(), "missing CERTIFICATE.json; run verify.py --write") + require(json.loads(cert.read_text()) == out, "CERTIFICATE.json is stale") + print("PASS_P104_NULLPAIR_COMPENSATED_SHEAR", + "domain=" + str(out["domain"]["total_pivot_pairs"]), + "min_block_rank=" + str(out["cost"]["minimum_replacement_block_rank"]), + "saving_pass=" + str(out["cost"]["profiles_with_strict_copy_saving_that_clear_screen"]), + "identity_errors=" + str(out["algebra"]["transformed_identity_errors"]), + "no_new_kappa") + + +if __name__ == "__main__": + main() From 646eb3db23f564d3b9aefc6ded877d1a17646fc4 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 04:25:46 -0500 Subject: [PATCH 2/2] Record P104 null-pair research submission --- research/p104-nullpair-compensated-shear-seed318bd5/CLAIM.md | 2 ++ research/p104-nullpair-compensated-shear-seed318bd5/HANDOFF.md | 2 +- research/p104-nullpair-compensated-shear-seed318bd5/README.md | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/CLAIM.md b/research/p104-nullpair-compensated-shear-seed318bd5/CLAIM.md index d43b3138f9..ca20ea6601 100644 --- a/research/p104-nullpair-compensated-shear-seed318bd5/CLAIM.md +++ b/research/p104-nullpair-compensated-shear-seed318bd5/CLAIM.md @@ -3,3 +3,5 @@ Remote claim: [Discussion #1762](https://github.com/CrocSwap/integer-mult-bounds/discussions/1762), created 2026-10-14. The accepted assignment is seed `318bd5e5f93c401334e29c6764720302`, track `complex-mechanisms`, task `complex-new-helper-inventory`, priority revision 3, base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`, selector scope key `5868e5281a1e63d41a22`, selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. The claim tests a one-pivot compensated shear after appending one complex isotropic cancelling pair to PR717's P104 eight-term decoder. The domain is all eight pivots and all distinct ordered Gaussian-unit vectors supported on at most two standard coordinates. The result, exact cost boundary, reproduction command and remaining physical obligations are recorded in [README.md](README.md) and [CERTIFICATE.json](CERTIFICATE.json). + +**FINDING / DONE:** submitted as [PR #1772](https://github.com/CrocSwap/integer-mult-bounds/pull/1772). The minimum changed block costs 21 copied-rank units versus 7 originally; no supplier or κ gain is claimed. The claim is released; wider supports, non-unit coefficients and multiple pivots remain open. diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/HANDOFF.md b/research/p104-nullpair-compensated-shear-seed318bd5/HANDOFF.md index 07e4157a50..6f8b67ff31 100644 --- a/research/p104-nullpair-compensated-shear-seed318bd5/HANDOFF.md +++ b/research/p104-nullpair-compensated-shear-seed318bd5/HANDOFF.md @@ -4,7 +4,7 @@ - **Pins:** base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. - **Finding:** the one-pivot compensated isotropic null-pair shear is exact, but across all 1,839,360 candidates in the stated Gaussian-unit two-coordinate family it costs at least 21 support-pair rank in place of 7. The best ten-term inventory therefore costs at least 70 versus 56 before any extra physical overhead. This is a scoped negative result, not a theorem for wider supports or arbitrary ten-term decoders. - **Verification:** `python3.12 -I -B research/p104-nullpair-compensated-shear-seed318bd5/verify.py`; expected marker is in [README.md](README.md). The checker verifies the 104-by-104 base and transformed identities, the support-rank census, the six-rank-one cost screen and a wrong-sign control. -- **Publication:** the claim is [Discussion #1762](https://github.com/CrocSwap/integer-mult-bounds/discussions/1762). No PR has been opened yet. Before any PR, refresh current PR and Discussion overlap and report only this bounded result. +- **Publication:** submitted in [PR #1772](https://github.com/CrocSwap/integer-mult-bounds/pull/1772); the original [Discussion #1762](https://github.com/CrocSwap/integer-mult-bounds/discussions/1762) now contains the finding and releases the claim. Hosted checks/review remain pending; no hosted pass is claimed. - **Remaining obligations:** physical phase-frame legality, whole-call hosting, precision and native dirty-state realization were not built because the copy-rank cost already rises by 14. No supplier or κ change is claimed. Prepared by OpenAI Codex with substantial AI assistance; no independent human review is claimed. diff --git a/research/p104-nullpair-compensated-shear-seed318bd5/README.md b/research/p104-nullpair-compensated-shear-seed318bd5/README.md index 5d744a5125..e2584c8259 100644 --- a/research/p104-nullpair-compensated-shear-seed318bd5/README.md +++ b/research/p104-nullpair-compensated-shear-seed318bd5/README.md @@ -42,7 +42,7 @@ The certificate records exact source hashes, the rank histogram, the selected re ## Overlap and provenance -The selector accepted seed `318bd5e5f93c401334e29c6764720302` on `complex-mechanisms`, card `complex-new-helper-inventory`, priority revision 3, base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 is `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. The original claim is [Discussion #1762](https://github.com/CrocSwap/integer-mult-bounds/discussions/1762). +The selector accepted seed `318bd5e5f93c401334e29c6764720302` on `complex-mechanisms`, card `complex-new-helper-inventory`, priority revision 3, base `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256 is `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. The original claim and finding are in [Discussion #1762](https://github.com/CrocSwap/integer-mult-bounds/discussions/1762); the package is submitted as [PR #1772](https://github.com/CrocSwap/integer-mult-bounds/pull/1772). PR717 supplies the P104 input factorization. Discussion #1622 / PR1633 classifies the algebraic residual-rank budget for all term counts but leaves support/copy-cost construction open. Open PR1726 screens one and two elementary term-basis shears in the original eight-term decoder; this package instead adds a cancelling complex pair and changes the term count to ten. Discussion #1674 changes nested endpoints of the selected k8 word with its scalar gates fixed, a different interface.