diff --git a/research/p112-walsh-two-total-seed6ed83d/PR-BODY.md b/research/p112-walsh-two-total-seed6ed83d/PR-BODY.md new file mode 100644 index 0000000000..2c9c53058d --- /dev/null +++ b/research/p112-walsh-two-total-seed6ed83d/PR-BODY.md @@ -0,0 +1,20 @@ +## Result + +This is a **scoped finite negative result** for one asymmetric P112 mechanism. For the exact ten-term shear `D=[X,XU]`, `T=[X(I−VU^T),XV]`, enumerate all ordered pairs of distinct Walsh characters in `U` and `V`, with the identity basis and four elementary unimodular basis shears `U←UM`, `V←VM^{-T}`. The 15,680 parameter tuples preserve `UV^T` and the exact all-pairs identity. Every tuple has the same pairing-rank profile `{8: 8, 9: 2}`, center invoice 82. Replacing the incumbent center invoice 64 gives an exact packing-ceiling upper endpoint `417137082181/500000000000000` (about 0.000834274164362), below the incumbent ceiling and the 5% gate. + +No new supplier, κ, selected result, or universal rank-two floor is claimed. Source access, frames, adapters, restoration, hosting, precision and interface costs are waived in the optimistic ceiling. The result covers only the stated Walsh planes and five bases. + +## Reproduction + +```sh +python3 -I -O -B research/p112-walsh-two-total-seed6ed83d/verify.py +python3 scripts/research_package.py --package research/p112-walsh-two-total-seed6ed83d --check-only +``` + +Expected verifier marker: `PASS_P112_WALSH_TWO_TOTAL candidates 15680 profiles 1 best_profile {"8": 8, "9": 2} center 82 a_hi 417137082181/500000000000000 gate False`. The generic registered replay targets Python 3.12; local direct verification used CPython 3.14.7 because Python 3.12 is unavailable on this host. + +## Overlap and attribution + +PR #1197 (merged head `a0935afff6cc5540a582c5881bc8d5f98b587357`) leaves the coupled full-rank overlapping case open. Merged PR #1923 (head `0d33d6020aa50d383067510df78dcc0515bba4f4`) searches a fixed symmetric witness's Householder orbit; this package studies asymmetric Walsh-plane shears and nonorthogonal basis changes, with no claim that the candidate sets are disjoint. Open PR #2022 (head `92ee132d0baf07f7ddf0fbbcd12756be8429bbf7`) gives a broader floor and cost-40 witnesses for its fixed decoder; this package does not claim an optimum. The exact overlap scan at 17:53–17:55 UTC covered 364 open PRs and 680 Discussion records with complete pagination and no warnings; no matching Walsh-shear work appeared. + +Assignment seed `6ed83d31ab93b3878e4fc74abdee2988`, track `complex-mechanisms`, priority revision 3; research base `ec8707299e2f40918f5f96cdab99ee49cdbabcf0`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. Task and source pins are in the package. Prepared by Cinna with substantial OpenAI Codex assistance. Apache-2.0. No independent human review is claimed. diff --git a/research/p112-walsh-two-total-seed6ed83d/README.md b/research/p112-walsh-two-total-seed6ed83d/README.md new file mode 100644 index 0000000000..97193e7f6f --- /dev/null +++ b/research/p112-walsh-two-total-seed6ed83d/README.md @@ -0,0 +1,69 @@ +# P112 two-total Walsh shears have a uniform copy profile + +**Scoped finite negative result. No κ, supplier, or new frontier is claimed.** + +For the P112 coordinate matrix `X`, let `chi_a(b)=(-1)^` be the eight Walsh characters of `F_2^3`. Choose ordered pairs of distinct characters for columns of `U,V` (56 choices each). Also allow the identity basis and the four elementary unimodular shears + +```text +M = [[1, s], [0, 1]] or [[1, 0], [s, 1]], s in {-1,+1}, +U' = U M, V' = V M^(-T). +``` + +Each of the resulting **15,680 parameter tuples** gives the exact asymmetric ten-term identity + +```text +D = [X, XU'] +T = [X(I - V'U'^T), XV'] +DT^T = XX^T = 2G. +``` + +The shear changes the two rank-two factor bases while preserving `U'V'^T=UV^T`; the verifier recomputes every term's support cost after the change. Across all 15,680 tuples, the exact ten-term pairing-rank histogram is always + +```text +{8: 8, 9: 2}; total invoice 82. +``` + +Replacing the incumbent's eight rank-8 center terms (invoice 64) with this decoder, while leaving the other 5,522 local rank units unchanged, gives local profile `{1:2412, 2:418, 3:432, 4:142, 5:82, 8:8, 9:2}` and center charge 82. Under the selected width-73, 896-family, nine-stage coverage law and rank-51 idle cap, the exact packing ceiling is + +```text +834274164361/1000000000000000 <= a <= 417137082181/500000000000000 +``` + +The upper endpoint is about `0.000834274164362`, below the incumbent ceiling `0.001690054109089` and the 5% gate `0.001774556814543`. This is a scoped obstruction for the listed finite Walsh-character bases. Its favorable ceiling already waives added source access, frames, adaptation, restoration, hosting, precision and interface costs. The result does not bound arbitrary real rank-two lifts. + +## Evidence and reproduction + +`verify.py` reconstructs the pinned P112 geometry, checks `XX^T=2G`, and enumerates all 56-by-56 character-pair choices in five bases: identity plus the four matrices above. Every candidate's coefficient identity and invariant `UV^T` are checked exactly. The 10 support-pairing ranks are computed with a local binary-elimination implementation and cross-checked against the pinned geometry routine. Each distinct profile is priced with the pinned exact-rational `ceiling()` implementation. + +The certificate contains the per-basis census and a SHA-256 digest of the deterministic 15,680-row rank receipt. Positive controls check the symbolic identity and one full 112-by-112 matrix identity. Negative controls reject a wrong sign, a dropped rank-two term, and a repeated-character pair. `-O` is supported because all guards use explicit exceptions. + +From the repository root: + +```sh +python3 -I -B research/p112-walsh-two-total-seed6ed83d/verify.py --write +python3 -I -O -B research/p112-walsh-two-total-seed6ed83d/verify.py +python3 scripts/research_package.py --package research/p112-walsh-two-total-seed6ed83d --check-only +python3 scripts/research_package.py --package research/p112-walsh-two-total-seed6ed83d +``` + +The first command writes `RESULT.json`; the next two recompute and validate it. The registered generic replay targets Python 3.12. Direct local verification was run with CPython 3.14.7 because Python 3.12 is not installed on this host. + +## Overlap and contribution boundary + +- **PR #1197**, merged at head `a0935afff6cc5540a582c5881bc8d5f98b587357`, proves the two-extra-total floor for rank-one additions, off-column readers and disjoint supports. Its remaining coupled rank-two, overlapping-support case includes this parameter family. This package searches only its finite Walsh subfamily. +- **PR #1923**, merged at head `0d33d6020aa50d383067510df78dcc0515bba4f4`, searches 29,524 rational Householder gauges of one fixed symmetric ten-term witness and finds invoice 82 throughout. Here `D` and `T` use an asymmetric rank-two shear with independently chosen character planes, followed by four nonorthogonal basis changes. The parameterizations differ; this package does not claim that their candidate sets are disjoint. +- **PR #2022**, open at head `92ee132d0baf07f7ddf0fbbcd12756be8429bbf7`, gives a broader at-most-eleven-total cost floor and cost-40 witnesses for its fixed Eisenstein decoder. This package makes no competing optimum claim; its added evidence is the exact profile census for the stated asymmetric family. +- **PR #2021** concerns masked two-column completion rank, not this all-pairs ten-term factor invoice. +- Active adjacent claims checked in the final board scan: #2003 studies a paired-tetrad masked decoder, #1952 a cyclic masked rank-three child profile, and #1987 a Karatsuba block inside the selected local word. They change different exactness, factor-count, or source-interface assumptions. #1693 is completed by PR #1703 and concerns retiming the selected word. + +The final overlap refresh at 17:53:48–17:55:25 UTC had complete pagination, no warnings, 364 open PRs and 680 Discussion records. No competing Walsh-shear claim appeared. The live claim and its intermediate result are recorded in [Discussion #2028](https://github.com/CrocSwap/integer-mult-bounds/discussions/2028). The scoped claim is not a novelty certificate for other coefficient families. + +## Open next questions + +Does an arbitrary full-rank real or rational pair `U,V` with overlapping coefficient support produce a lower recursive profile than the finite Walsh-shear family? It matters because PR #1197 leaves precisely this coupled class open, and a profile with lower charged center invoice could change the complex-side packing ceiling. A first step is to derive support strata for `U,V` and search rational points in strata that permit cancellation; then price the complete profile and charge frame/restoration work. The blocker is that support changes on continuous algebraic loci, so the finite character scan does not bound the whole class. + +## Provenance and credit + +Assignment seed `6ed83d31ab93b3878e4fc74abdee2988`, track `complex-mechanisms`, task `complex-rank-shape-decoder`, priority revision 3. Exact base `ec8707299e2f40918f5f96cdab99ee49cdbabcf0`; selected-record SHA-256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. Source pins are in `SOURCES.json`. + +Credit DreamingOfClouds / PR717 and Mihir Srivastava / PR845 for the P112 geometry and pairing-cost model; Philipp / @mightyOil / PR1197 for the remaining coupled rank-two boundary; Hanson Sun / PR1633 and its PR1923 follow-up; and Charles Bethin / PR2022 for the broader fixed-decoder floor. Prepared by Cinna with substantial OpenAI Codex assistance in scope selection, derivation, implementation, exact verification and writing. No independent human review or proof-assistant validation is claimed. New work is Apache-2.0. diff --git a/research/p112-walsh-two-total-seed6ed83d/RESULT.json b/research/p112-walsh-two-total-seed6ed83d/RESULT.json new file mode 100644 index 0000000000..db52b26a93 --- /dev/null +++ b/research/p112-walsh-two-total-seed6ed83d/RESULT.json @@ -0,0 +1,397 @@ +{ + "base_commit": "ec8707299e2f40918f5f96cdab99ee49cdbabcf0", + "basis_census": { + "identity": { + "candidates": 3136, + "profiles": [ + { + "candidates": 3136, + "profile": { + "8": 8, + "9": 2 + } + } + ] + }, + "lower_minus": { + "candidates": 3136, + "profiles": [ + { + "candidates": 3136, + "profile": { + "8": 8, + "9": 2 + } + } + ] + }, + "lower_plus": { + "candidates": 3136, + "profiles": [ + { + "candidates": 3136, + "profile": { + "8": 8, + "9": 2 + } + } + ] + }, + "upper_minus": { + "candidates": 3136, + "profiles": [ + { + "candidates": 3136, + "profile": { + "8": 8, + "9": 2 + } + } + ] + }, + "upper_plus": { + "candidates": 3136, + "profiles": [ + { + "candidates": 3136, + "profile": { + "8": 8, + "9": 2 + } + } + ] + } + }, + "best_candidate_examples": { + "identity": { + "U": [ + 0, + 1 + ], + "V": [ + 0, + 1 + ], + "basis": "identity", + "ranks": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9 + ] + }, + "lower_minus": { + "U": [ + 0, + 1 + ], + "V": [ + 0, + 1 + ], + "basis": "lower_minus", + "ranks": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9 + ] + }, + "lower_plus": { + "U": [ + 0, + 1 + ], + "V": [ + 0, + 1 + ], + "basis": "lower_plus", + "ranks": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9 + ] + }, + "upper_minus": { + "U": [ + 0, + 1 + ], + "V": [ + 0, + 1 + ], + "basis": "upper_minus", + "ranks": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9 + ] + }, + "upper_plus": { + "U": [ + 0, + 1 + ], + "V": [ + 0, + 1 + ], + "basis": "upper_plus", + "ranks": [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 9, + 9 + ] + } + }, + "best_profile": { + "a_hi": "417137082181/500000000000000", + "a_lo": "834274164361/1000000000000000", + "candidates": 15680, + "center_charge": 82, + "local_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8, + "9": 2 + }, + "meets_5_percent_gate": false, + "profile": { + "8": 8, + "9": 2 + } + }, + "candidate_rows_sha256": "cd5cae75a68f196b1f85b8274091ae23cce92a30f84fcfb9d4694bb0b0149d28", + "conclusion": "no member of this finite Walsh-character shear domain clears the 5% packing-ceiling gate", + "controls": { + "all_term_ranks_cross_checked": true, + "duplicate_character_pair_excluded": true, + "omitted_direct_term_rejected": true, + "omitted_symbolic_term_rejected": true, + "positive_direct_112x112_identity": true, + "positive_symbolic_identity": true, + "wrong_sign_rejected": true + }, + "distinct_profiles": 1, + "incumbent": { + "a_ceiling_decimal": "0.00169005410908900006", + "a_ceiling_hi": "1690054109089/1000000000000000", + "center_charge": 64, + "five_percent_threshold": "35491136290869/20000000000000000", + "local_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8 + } + }, + "limits": [ + "The result covers only the 15,680 ordered Walsh-pair/basis tuples in the five listed bases.", + "The ceiling permits fractional idle packing and waives source, frame, restoration, hosting, precision, and interface costs.", + "No physical supplier, new selected result, or kappa is established." + ], + "model": { + "additional_unimodular_shear_candidate_count": 12544, + "all_ten_terms_nonzero": true, + "basis_change_matrices": [ + { + "M": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "M_inverse_transpose": [ + [ + 1, + 0 + ], + [ + 0, + 1 + ] + ], + "name": "identity" + }, + { + "M": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "M_inverse_transpose": [ + [ + 1, + 0 + ], + [ + -1, + 1 + ] + ], + "name": "upper_plus" + }, + { + "M": [ + [ + 1, + -1 + ], + [ + 0, + 1 + ] + ], + "M_inverse_transpose": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "name": "upper_minus" + }, + { + "M": [ + [ + 1, + 0 + ], + [ + 1, + 1 + ] + ], + "M_inverse_transpose": [ + [ + 1, + -1 + ], + [ + 0, + 1 + ] + ], + "name": "lower_plus" + }, + { + "M": [ + [ + 1, + 0 + ], + [ + -1, + 1 + ] + ], + "M_inverse_transpose": [ + [ + 1, + 1 + ], + [ + 0, + 1 + ] + ], + "name": "lower_minus" + } + ], + "basis_change_rule": "U_new=U M; V_new=V M^{-T}; U_new V_new^T=UV^T exactly", + "basis_changes": [ + "identity", + "upper_plus", + "upper_minus", + "lower_plus", + "lower_minus" + ], + "candidate_count": 15680, + "center_substitution": "replace the eight rank-8 center terms by this ten-term invoice", + "characters": "chi_a(b)=(-1)^ for a,b in F_2^3", + "coefficient_field": "integers", + "geometry": "P112, XX^T=2G, exact all-pairs identity", + "identity": "D=[X,XU], T=[X(I-VU^T),XV]", + "initial_basis_candidate_count": 3136, + "ordered_distinct_pairs_per_side": 56, + "support_cost": "binary rank of the restricted P112 label pairing" + }, + "profile_results": [ + { + "a_hi": "417137082181/500000000000000", + "a_lo": "834274164361/1000000000000000", + "candidates": 15680, + "center_charge": 82, + "local_profile": { + "1": 2412, + "2": 418, + "3": 432, + "4": 142, + "5": 82, + "8": 8, + "9": 2 + }, + "meets_5_percent_gate": false, + "profile": { + "8": 8, + "9": 2 + } + } + ], + "seed": "6ed83d31ab93b3878e4fc74abdee2988", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "status": "PASS_P112_WALSH_TWO_TOTAL", + "task": "complex-rank-shape-decoder" +} diff --git a/research/p112-walsh-two-total-seed6ed83d/SOURCES.json b/research/p112-walsh-two-total-seed6ed83d/SOURCES.json new file mode 100644 index 0000000000..b5c4b04bad --- /dev/null +++ b/research/p112-walsh-two-total-seed6ed83d/SOURCES.json @@ -0,0 +1,72 @@ +{ + "schema_version": 1, + "base_commit": "ec8707299e2f40918f5f96cdab99ee49cdbabcf0", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1", + "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075" + }, + { + "path": "research/p112-single-lift/geometry.py", + "usage": "input", + "git_blob": "34c1abf059d7be5fe5e5044cf01a09b843071c68", + "sha256": "3857c11ec731a602b8059d85d58fbb3b641bab687bb33016a0e54f7567752c8a" + }, + { + "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-local-word-ceiling/README.md", + "usage": "provenance", + "git_blob": "f5f742f8196da29d2c3f4dffb3c27685ca9401f6", + "sha256": "b60be039cb0e03e064a27407d0bce9e58908d793da5ee405c876de5aebfa5f81" + }, + { + "path": "research/p112-two-total-rank-one-seed21/README.md", + "usage": "provenance", + "git_blob": "1124da18d43835514f78279962c4e3616bff313d", + "sha256": "4aa694b5f7f6dc0b3452116939e896bc39df81904f82631b2fddb85f24eb3395" + }, + { + "path": "docs/research/complex-decoder-scope-map.md", + "usage": "provenance", + "git_blob": "8386023e9731bb3a6982b50eefbb4c57bee40daa", + "sha256": "207f3dce684346b55a93ed5c0d9667c2724edd049a04d1e8bbc6f2e9838af1ec" + } + ], + "predecessors": { + "717": { + "author": "DreamingOfClouds", + "head": "4150829a2cb66b823f4282da98985959ee448a90" + }, + "845": { + "author": "Mihir Srivastava", + "head": "125ce25bdae421627b56077adc14940c2d0aa52f" + }, + "1094": { + "author": "Rohan Arun", + "head": "0fc329d0bec93ca7cd288eaea1295172e8789810" + }, + "1197": { + "author": "Philipp (@mightyOil)", + "head": "a0935afff6cc5540a582c5881bc8d5f98b587357" + } + } +} diff --git a/research/p112-walsh-two-total-seed6ed83d/TASK.json b/research/p112-walsh-two-total-seed6ed83d/TASK.json new file mode 100644 index 0000000000..4c26a2976d --- /dev/null +++ b/research/p112-walsh-two-total-seed6ed83d/TASK.json @@ -0,0 +1,108 @@ +{ + "schema_version": 1, + "task_id": "complex-rank-shape-decoder", + "priority_revision": 3, + "base_commit": "ec8707299e2f40918f5f96cdab99ee49cdbabcf0", + "original_card": { + "id": "complex-rank-shape-decoder", + "question": "Can a decoder deliver the local paid mass in fewer, larger-rank children (block frame climbs instead of rank-1 to rank-3 steps)?", + "starting_points": [ + "research/complex-local-word-ceiling/README.md", + "research/complex-decoder-field-extension-seed44/README.md", + "research/complex-frame-pair-decoders/README.md" + ], + "methods": [ + "Find one exact small decoding identity whose frame path climbs in blocks, and price its complete per-call profile.", + "Bound the best effective child rank achievable for one fixed support alphabet, including copies, frames and restoration." + ], + "acceptance_gate": "A per-call local profile, with all copied information, frames and restoration counted, whose ceiling exceeds the selected word's by at least 5%; masked or overcomplete supports must change an assumption of the eight-term all-pairs bound.", + "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. Ideal budget: rank-16 delivery is 2.31x (levers.py).", + "bottleneck_link": "Rank-1 children are about half of recursive cost; the selected word's effective child rank is about 3.9. Larger-rank delivery lowers recursive cost per unit of paid mass.", + "allowed_variations": [ + "One masked, overcomplete or block decoder family with exact labels and supports.", + "A scoped lower bound on effective rank for one alphabet.", + "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": [ + "Repacking idle remainders of an unchanged word (covered by the packing ceiling).", + "Repeating the eight-term all-pairs search inside its proved scope." + ], + "overlap_terms": [ + "rank shape", + "block climb", + "masked decoder", + "overcomplete", + "effective rank" + ] + }, + "scope_status": "refined", + "actual_scope": "Exhaust the 15,680 ordered P112 ten-term factorizations D=[X,XU], T=[X(I\u2212VU^T),XV], where U and V are ordered pairs of distinct Walsh characters and the two rank-two bases use identity or one of four elementary unimodular shears; compute every exact pairing-rank profile and the charged-center packing ceiling.", + "scope_change_reason": "The selected complex-rank-shape card asks for a fixed support alphabet whose profile could improve the local moment. The broad coupled rank-two P112 class is open after PR1197, but PR1923 and PR2022 added close ten-term results. This contribution narrows to an explicit asymmetric character-plane family plus four non-free basis changes, preserving the exact decoder identity while varying the supports. The optimistic ten-rank-one budget cleared the 5% gate, so the finite construction search was worth running. Its completed exact census is negative; it does not claim a universal floor.", + "bottleneck_link": "Replacing the selected eight rank-8 center terms (invoice 64) could change both the local rank distribution and the 64-per-call center charge. The exact Walsh-shear invoices are 82, and their favorable packing ceiling is below the selected word ceiling; no center or recursive saving results.", + "budget_minutes": 60, + "stop_rule": "Completed all 15,680 ordered character-pair/basis tuples in the declared five-basis domain, including exact identities, all term costs, the profile census, ceiling pricing, and mutation controls. No further speculative pivot in this cycle.", + "outcome": "negative-result", + "evidence": "verify.py regenerates RESULT.json. All 15,680 parameter tuples have profile {8:8,9:2}, invoice 82, and ceiling interval [834274164361/1000000000000000, 417137082181/500000000000000], below both the incumbent ceiling and 5% gate. Coefficient identities and UV invariance are exact; every rank is cross-checked by a second implementation. Positive full-matrix and negative mutation controls pass.", + "author": "Cinna", + "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, derivation, implementation, exact verification, cost analysis, and writing. No independent human review or proof-assistant verification is claimed.", + "open_questions": [ + { + "question": "Can arbitrary full-rank rational or real U,V with overlapping coefficient support produce a lower recursive profile than this finite Walsh-shear family?", + "why_it_matters": "PR1197 leaves the coupled rank-two case open; a lower center invoice and rank histogram could change the complex-side packing ceiling.", + "first_step": "Classify support strata of U,V and test rational points on strata allowing cancellation, then compute the full support-pairing profile and charge the frame/restoration interface.", + "blocked_by": "The support pattern varies over continuous algebraic loci; this finite five-basis enumeration does not bound the whole coupled class." + } + ], + "track": "complex-mechanisms", + "assignment_seed": "6ed83d31ab93b3878e4fc74abdee2988", + "assignment_nonce": "6ed83d31ab93b3878e4fc74abdee2988", + "scope_key": "complex-rank-shape-decoder/P112/asymmetric-Walsh-rank-two-shear/four-unimodular-bases", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "method": "Enumerate all 56 ordered distinct Walsh-character pairs independently for U and V. For each of identity, E12(+1), E12(\u22121), E21(+1), and E21(\u22121), set U_new=U M and V_new=V M^{-T}; verify U_new V_new^T=UV^T and the 8-dimensional factor identity exactly. Compute all ten support-pairing ranks with binary elimination, cross-check each against the pinned P112 geometry routine, census profiles, and price each profile with the pinned exact ceiling implementation.", + "nearest_overlap": "PR1197 leaves the coupled full-rank overlapping-support case open and includes this subfamily. PR1923 searches a fixed symmetric witness Householder orbit (invoice 82). PR2022 reports a broader at-most-eleven-total floor and cost-40 witnesses for its fixed decoder. This work adds only a profile census for an asymmetric finite subfamily. PR2021 is masked completion rank, not this all-pairs factor invoice.", + "favorable_budget": "A hypothetical ten-rank-one center invoice gives a ceiling near 0.004256765, above the selected 5% threshold 0.001774557. Actual domain census: ten-term histogram {8:8,9:2}, center 82; selected noncenter local mass 5522 is retained, giving ceiling upper 0.000834274164362. The ceiling allows fractional rank-51 idle packing and waives source, frame, adapter, restoration, hosting, precision, and interface costs.", + "coordination": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2028", + "final_overlap_check": { + "open_prs": 364, + "discussions": 680, + "complete_pagination": true, + "warnings": [], + "searched_at": "2026-10-14T17:55:25Z", + "nearest_open_prs": { + "2022": { + "head": "92ee132d0baf07f7ddf0fbbcd12756be8429bbf7", + "scope": "at-most-eleven-total floor and cost-40 witnesses for its fixed Eisenstein decoder" + }, + "2021": { + "head": "9943467c4b24d2050275a202e3866cfc522afbe7", + "scope": "masked two-column completion rank" + } + }, + "nearest_merged_prs": { + "1197": { + "head": "a0935afff6cc5540a582c5881bc8d5f98b587357", + "scope": "coupled rank-two overlapping lifts remain open outside its covered cases" + }, + "1923": { + "head": "0d33d6020aa50d383067510df78dcc0515bba4f4", + "scope": "Householder gauges of one fixed symmetric ten-term witness" + } + }, + "adjacent_claims": [ + "2003 paired-tetrad masked decoder", + "1952 cyclic masked rank-three child profile", + "1987 Karatsuba block in selected local word" + ], + "exact_walsh_shear_competitor_found": false + } +} diff --git a/research/p112-walsh-two-total-seed6ed83d/VERIFY.json b/research/p112-walsh-two-total-seed6ed83d/VERIFY.json new file mode 100644 index 0000000000..461672ccc0 --- /dev/null +++ b/research/p112-walsh-two-total-seed6ed83d/VERIFY.json @@ -0,0 +1,24 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "research/p112-single-lift/geometry.py", + "research/complex-local-word-ceiling/ceiling.py", + "research/complex-local-word-ceiling/RESULT.json" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Exact P112 geometry, all 15,680 identities and term ranks, five per-basis profile censuses, current ceiling, source-bound receipt, positive direct matrix control, and sign/drop/duplicate negative controls." + } + ] +} diff --git a/research/p112-walsh-two-total-seed6ed83d/verify.py b/research/p112-walsh-two-total-seed6ed83d/verify.py new file mode 100644 index 0000000000..ba50502b3b --- /dev/null +++ b/research/p112-walsh-two-total-seed6ed83d/verify.py @@ -0,0 +1,345 @@ +#!/usr/bin/env python3 +"""Exhaust the signed Walsh-character two-total shear family on exact P112.""" +import hashlib +import json +import sys +from collections import Counter +from fractions import Fraction as Q +from itertools import permutations +from pathlib import Path + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(ROOT / "research/p112-single-lift")) +sys.path.insert(0, str(ROOT / "research/complex-local-word-ceiling")) +import geometry # noqa: E402 +import ceiling as C # noqa: E402 + +M, FAMILIES, STAGES = 73, 896, 9 +BASE_PROFILE = {1: 2412, 2: 418, 3: 432, 4: 142, 5: 82} +OUT = HERE / "RESULT.json" + + +def require(ok, message): + if not ok: + raise ValueError(message) + + +def parity(x): + return x.bit_count() & 1 + + +def rank2(rows): + """Binary row rank; a separate implementation for cross-checking geometry.term_cost.""" + pivots = {} + for row in rows: + x = row + while x: + p = x.bit_length() - 1 + if p in pivots: + x ^= pivots[p] + else: + pivots[p] = x + break + return len(pivots) + + +def beta(left, right, data): + """Literal restricted pairing rank for one ordered factor pair.""" + reader_basis = geometry.binary_basis( + q for value, q in zip(left, data["duals"]) if value + ) + rows = [] + for value, label in zip(right, data["labels"]): + if value: + rows.append(sum(parity(q & label) << j + for j, q in enumerate(reader_basis))) + return rank2(rows) + + +def mat_vec(matrix, vector): + return [sum(a * b for a, b in zip(row, vector)) for row in matrix] + + +def column(matrix, j): + return [row[j] for row in matrix] + + +def characters(): + # Characters of F_2^3, with coordinate b=0,...,7 and character a=0,...,7. + return [[-1 if parity(a & b) else 1 for b in range(8)] for a in range(8)] + + +def coefficient_identity_cols(u, v, wrong_sign=False, omit_last=False): + """Check A B^T exactly in the eight-dimensional coefficient space.""" + result = [[0] * 8 for _ in range(8)] + for j in range(8): + t = [int(k == j) - v[0][k] * u[0][j] - v[1][k] * u[1][j] + for k in range(8)] + for k in range(8): + result[j][k] += t[k] + result_u = [0] if omit_last else list(range(2)) + for l in result_u: + sign = -1 if wrong_sign else 1 + for i in range(8): + for j in range(8): + result[i][j] += sign * u[l][i] * v[l][j] + return result + + +def decoder_columns(x, u, v): + xcols = [column(x, j) for j in range(8)] + ulifts = [mat_vec(x, vector) for vector in u] + vlifts = [mat_vec(x, vector) for vector in v] + dcols = xcols + ulifts + tcols = [] + for j in range(8): + tcols.append([ + xcols[j][i] + - u[0][j] * vlifts[0][i] + - u[1][j] * vlifts[1][i] + for i in range(len(x)) + ]) + tcols.extend(vlifts) + return dcols, tcols + + +def direct_identity(data, dcols, tcols): + roots = data["roots"] + x = data["X"] + require(len(dcols) == len(tcols) == 10, "ten factors") + for i in range(112): + for j in range(112): + lhs = sum(d[i] * t[j] for d, t in zip(dcols, tcols)) + gram = sum(a * b for a, b in zip(roots[i], roots[j])) // 4 + require(lhs == 2 * gram, "direct P112 identity failed") + require(sum(a * b for a, b in zip(x[i], x[j])) == 2 * gram, + "pinned XX^T identity failed") + + +def candidate_rows(data): + chars = characters() + options = list(permutations(range(8), 2)) + require(len(options) == 56, "ordered distinct Walsh-pair count") + basis_changes = [ + ("identity", ((1, 0), (0, 1)), ((1, 0), (0, 1))), + ("upper_plus", ((1, 1), (0, 1)), ((1, 0), (-1, 1))), + ("upper_minus", ((1, -1), (0, 1)), ((1, 0), (1, 1))), + ("lower_plus", ((1, 0), (1, 1)), ((1, -1), (0, 1))), + ("lower_minus", ((1, 0), (-1, 1)), ((1, 1), (0, 1))), + ] + rows = [] + profile_counts = Counter() + by_basis = {name: Counter() for name, _, _ in basis_changes} + for u_pair in options: + for v_pair in options: + base_u = [chars[u_pair[0]], chars[u_pair[1]]] + base_v = [chars[v_pair[0]], chars[v_pair[1]]] + for name, matrix, inverse_transpose in basis_changes: + u = [[sum(base_u[a][i] * matrix[a][j] for a in range(2)) + for i in range(8)] for j in range(2)] + v = [[sum(base_v[a][i] * inverse_transpose[a][j] for a in range(2)) + for i in range(8)] for j in range(2)] + require(coefficient_identity_cols(u, v) == + [[int(i == j) for j in range(8)] for i in range(8)], + "symbolic factor identity failed") + # Check the claimed non-free basis change preserves the rank-two correction. + for i in range(8): + for j in range(8): + before = sum(base_u[a][i] * base_v[a][j] for a in range(2)) + after = sum(u[a][i] * v[a][j] for a in range(2)) + require(before == after, "basis change altered UV^T") + dcols, tcols = decoder_columns(data["X"], u, v) + ranks = [] + for d, t in zip(dcols, tcols): + r = beta(d, t, data) + require(1 <= r <= 9, "every Walsh term must be nonzero with rank 1..9") + require(r == geometry.term_cost(d, t, data), + "independent binary-rank implementations disagree") + ranks.append(r) + profile = tuple(sorted(Counter(ranks).items())) + profile_counts[profile] += 1 + by_basis[name][profile] += 1 + rows.append({"U": list(u_pair), "V": list(v_pair), + "basis": name, "ranks": ranks}) + require(len(rows) == 15680, "complete five-basis ordered Walsh-pair product") + require(sum(profile_counts.values()) == 15680, "profile census coverage") + return rows, profile_counts, by_basis, chars + + +def controls(data, chars): + u_pair, v_pair = (0, 1), (2, 3) + identity = [[int(i == j) for j in range(8)] for i in range(8)] + u = [chars[a] for a in u_pair] + v = [chars[a] for a in v_pair] + require(coefficient_identity_cols(u, v) == identity, + "positive symbolic control") + require(coefficient_identity_cols(u, v, wrong_sign=True) != identity, + "wrong-sign control was not rejected") + require(coefficient_identity_cols(u, v, omit_last=True) != identity, + "omitted-total control was not rejected") + options = list(permutations(range(8), 2)) + require((0, 0) not in options and len(options) == 56, + "duplicate Walsh character pair control") + + dcols, tcols = decoder_columns(data["X"], u, v) + direct_identity(data, dcols, tcols) + # A direct matrix mutation checks that dropping the second added product is detected. + bad_tcols = tcols[:8] + [tcols[8], [0] * 112] + failed = False + try: + direct_identity(data, dcols, bad_tcols) + except ValueError as error: + failed = "direct P112 identity failed" in str(error) + require(failed, "direct dropped-term control did not fail") + return { + "positive_symbolic_identity": True, + "positive_direct_112x112_identity": True, + "wrong_sign_rejected": True, + "omitted_symbolic_term_rejected": True, + "omitted_direct_term_rejected": True, + "duplicate_character_pair_excluded": True, + "all_term_ranks_cross_checked": True, + } + + +def serialize_profile(profile): + return {str(r): n for r, n in profile} + + +def compute(): + data = geometry.build() + geometry.check_geometry(data) + rows, profile_counts, by_basis, chars = candidate_rows(data) + ctrl = controls(data, chars) + selected_sha = hashlib.sha256( + (ROOT / "certificates/selected-result.json").read_bytes() + ).hexdigest() + require(selected_sha == + "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selected record differs from the accepted seed's exact input") + pinned_ceiling = json.loads((ROOT / "research/complex-local-word-ceiling/RESULT.json").read_text()) + selected_profile = {int(r): n for r, n in pinned_ceiling["selected"]["local_profile_per_call"].items()} + selected_center = pinned_ceiling["model"]["centre_per_call"] + _, baseline = C.ceiling(selected_profile, M, FAMILIES, STAGES, selected_center) + require(str(baseline) == pinned_ceiling["ceiling"]["a_ceiling"], + "pinned incumbent ceiling changed") + target = baseline * Q(105, 100) + + profile_results = [] + best = None + for profile, count in sorted(profile_counts.items()): + local = {r: n for r, n in selected_profile.items() if r != 8} + require(local == BASE_PROFILE, "expected selected profile minus eight rank-8 center terms") + center = sum(r * n for r, n in profile) + for r, n in profile: + local[r] = local.get(r, 0) + n + low, high = C.ceiling(local, M, FAMILIES, STAGES, center) + candidate = { + "profile": serialize_profile(profile), + "candidates": count, + "center_charge": center, + "local_profile": {str(r): local[r] for r in sorted(local)}, + "a_lo": str(low), + "a_hi": str(high), + "meets_5_percent_gate": low >= target, + } + profile_results.append(candidate) + key = high + if best is None or key > best[0]: + best = (key, candidate) + + best_examples = {} + for row in rows: + if (serialize_profile(tuple(sorted(Counter(row["ranks"]).items()))) == + best[1]["profile"] and row["basis"] not in best_examples): + best_examples[row["basis"]] = row + + result = { + "status": "PASS_P112_WALSH_TWO_TOTAL", + "seed": "6ed83d31ab93b3878e4fc74abdee2988", + "task": "complex-rank-shape-decoder", + "base_commit": "ec8707299e2f40918f5f96cdab99ee49cdbabcf0", + "selected_record_sha256": selected_sha, + "model": { + "geometry": "P112, XX^T=2G, exact all-pairs identity", + "identity": "D=[X,XU], T=[X(I-VU^T),XV]", + "coefficient_field": "integers", + "characters": "chi_a(b)=(-1)^ for a,b in F_2^3", + "ordered_distinct_pairs_per_side": 56, + "initial_basis_candidate_count": 3136, + "additional_unimodular_shear_candidate_count": 12544, + "candidate_count": 15680, + "basis_changes": ["identity", "upper_plus", "upper_minus", "lower_plus", "lower_minus"], + "basis_change_matrices": [ + {"name": "identity", "M": [[1, 0], [0, 1]], "M_inverse_transpose": [[1, 0], [0, 1]]}, + {"name": "upper_plus", "M": [[1, 1], [0, 1]], "M_inverse_transpose": [[1, 0], [-1, 1]]}, + {"name": "upper_minus", "M": [[1, -1], [0, 1]], "M_inverse_transpose": [[1, 0], [1, 1]]}, + {"name": "lower_plus", "M": [[1, 0], [1, 1]], "M_inverse_transpose": [[1, -1], [0, 1]]}, + {"name": "lower_minus", "M": [[1, 0], [-1, 1]], "M_inverse_transpose": [[1, 1], [0, 1]]}, + ], + "basis_change_rule": "U_new=U M; V_new=V M^{-T}; U_new V_new^T=UV^T exactly", + "all_ten_terms_nonzero": True, + "support_cost": "binary rank of the restricted P112 label pairing", + "center_substitution": "replace the eight rank-8 center terms by this ten-term invoice", + }, + "incumbent": { + "local_profile": {str(r): n for r, n in selected_profile.items()}, + "center_charge": selected_center, + "a_ceiling_hi": str(baseline), + "a_ceiling_decimal": pinned_ceiling["ceiling"]["a_ceiling_decimal"], + "five_percent_threshold": str(target), + }, + "distinct_profiles": len(profile_counts), + "basis_census": { + name: { + "candidates": sum(counts.values()), + "profiles": [ + {"profile": serialize_profile(profile), "candidates": count} + for profile, count in sorted(counts.items()) + ], + } + for name, counts in sorted(by_basis.items()) + }, + "profile_results": profile_results, + "best_profile": best[1], + "best_candidate_examples": best_examples, + "controls": ctrl, + "conclusion": ( + "finite construction clears the 5% packing-ceiling gate" + if best[1]["meets_5_percent_gate"] else + "no member of this finite Walsh-character shear domain clears the 5% packing-ceiling gate" + ), + "limits": [ + "The result covers only the 15,680 ordered Walsh-pair/basis tuples in the five listed bases.", + "The ceiling permits fractional idle packing and waives source, frame, restoration, hosting, precision, and interface costs.", + "No physical supplier, new selected result, or kappa is established.", + ], + } + rows_blob = json.dumps(rows, sort_keys=True, separators=(",", ":")).encode() + result["candidate_rows_sha256"] = hashlib.sha256(rows_blob).hexdigest() + return result + + +def main(): + result = compute() + text = json.dumps(result, indent=1, sort_keys=True) + "\n" + if sys.argv[1:] == ["--write"]: + OUT.write_text(text) + else: + require(OUT.read_text() == text, "RESULT.json differs from exact recomputation") + print(result["status"], + "candidates", result["model"]["candidate_count"], + "profiles", result["distinct_profiles"], + "best_profile", json.dumps(result["best_profile"]["profile"], sort_keys=True), + "center", result["best_profile"]["center_charge"], + "a_hi", result["best_profile"]["a_hi"], + "gate", result["best_profile"]["meets_5_percent_gate"]) + + +if __name__ == "__main__": + try: + main() + except (OSError, ValueError) as error: + print("FAIL:", error) + raise SystemExit(1)