diff --git a/research/nine-source-johnson-chain-seed923edf/CLAIM.md b/research/nine-source-johnson-chain-seed923edf/CLAIM.md new file mode 100644 index 0000000000..e5f59d7cea --- /dev/null +++ b/research/nine-source-johnson-chain-seed923edf/CLAIM.md @@ -0,0 +1,78 @@ +# Cycle 32 local research claim + +**Status:** RESULT SUBMITTED as [PR #2296](https://github.com/CrocSwap/integer-mult-bounds/pull/2296). +The PR was open and mergeable at head `b4af93f238e69ccf000eb9e90030be4c01cda391` +against base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2` at the initial +submission check; hosted checks were queued. The subsequent handoff metadata +update advanced the branch; consult the PR for its current head and checks. The +public Discussion claim remains local-only: the +authenticated GraphQL overlap refresh hung and was stopped after about two +minutes, the final pre-submission retry produced no output before timing out +after 50 seconds at 03:56 UTC on 2026-10-15, and a prior direct REST Discussions +comment attempt returned 404. No public claim was posted. + +- **Track / task / seed:** `recursive-interfaces` / `connector-alphabet-change` / + `923edf31ad6e8cfdc58bb11a6c6d6b3d`. +- **Exact base:** `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. +- **Catalogue / selected record:** revision 4; catalogue SHA256 + `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`; selected + record SHA256 `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- **Question:** In the established singleton F2 dirty-connector alphabet, can + five separate dirty outputs with supports + `{01234, 01235, 01256, 01567, 05678}` be computed with nine read-only + sources at the complete-call floor? These five 5-subsets form a path in + `J(9,5)`, each step replacing one source, and their union is all nine + sources. +- **Changed scope:** The selector card asks to add one connector operation. + This investigation adds no operation; it studies one explicit sparse + output-support family under the existing alphabet. It is a construction, + not a repeat of Cycle 31's eight-source full weight-four two-sweep census. +- **Candidate screen:** The two-unpaid-coordinate coverage-law question is + already claimed in Discussion #1587. Centre-path hosting is claimed in + #1516 through 05:00 UTC, with older related nonadjacent-path records #1963 + and #2058. The joint-query + lane has open PRs #2153 and #2268, including the immediately preceding + Cycle 30 contribution. The general connector lane has active GF(4) and + seven-source claims plus open alphabet/path PRs; this claim narrows it to a + different positive n=9, weight-five support chain with no new operation. +- **Method / domain:** Use the source walk `0 → S1 → S2 → S3 → S4 → S5 → 0`, + toggle each symmetric difference, and read each `A_i` once at `q=0` and once + at `q=S_i`. Charge all B and A calls. Exhaust all `2^9` source assignments, + dirty connector bits and `2^5` dirty-output vectors. Stop after exact replay, + the lower-bound proof and the listed failure controls; no search over + unrelated support families. +- **Favorable screen:** Optimistic floor and proposed schedule are both + `2*9 + 2*5 = 28` complete calls. Five independent restored row stars cost + `5*(2*5+2)=60`. The intended saving is 32 calls in this abstract interface; + under stable per-call source prices `c_j`, the weighted saving is exactly + `2*sum_j (d_j-1)c_j`, where `d=(5,4,3,2,1,4,3,2,1)`; A-call prices cancel. + Position-dependent transitions and concrete supplier placement remain + unpriced, so no recursive supplier or kappa is claimed. +- **Expected evidence:** A standalone verifier, exact source/readout word, + arbitrary dirty-state replay, lower-bound argument, negative controls, + complete provenance pins, and a focused package PR. Submitted as PR #2296; + hosted checks were queued when checked. +- **Relevant work and distinction:** Open PR #2208 (head + `28480ef4fdb4caeab89765ea56595bf1f6f37688`) develops all-word two-root + dirty-connector bounds and an exact minimum-read compiler for supplied source + walks over as many as 511 outputs. It is adjacent source-walk work, but uses + a two-root framed interface and does not present this one-connector, five- + mask Johnson chain or its 28-call floor. PR #2271 (head + `95fd439596f72575d3869277c2d01aca1ca6ab6a`) is a 12-row bit-register Gray + tour through three masks, not this nine-source recursive B/A interface. + PR #2283 (head `21145202e9a27cd9b18ffc7e23383cc83461c4a0`) is Cycle 31's + negative result for the full n=8 weight-four shell under two complete + sweeps. PR #2229 covers n=7 weights 1--3; PR #2266 changes to GF(4) for two + sources. Active neighboring claims #2262 (GF(4)) and #2275 (seven-source + paired-call roots) do not use this mask family. Targeted live PR searches at + 04:00 UTC found no `J(9,5)`, exact five-mask or "nine-source Johnson-chain" + match. The complete cached snapshot covered 511 open PRs and 990 Discussions + (PR data 03:42 UTC; Discussion data 03:26 UTC, 2026-10-15). +- **Expiry:** The local claim is released on completion; the recorded planning + expiry was 2026-10-15 05:45 UTC. + +The selected conditional result is `836330098538459/500000000000000000` at +this base, reviewed in `docs/research/community-batch1099-review.md`; the +selected assembly and source manifest are pinned in `SOURCES.json`. The +selected supplier reproduction is `make frontier1094-verify`; it is not part +of this connector-level experiment. diff --git a/research/nine-source-johnson-chain-seed923edf/README.md b/research/nine-source-johnson-chain-seed923edf/README.md new file mode 100644 index 0000000000..3f3a9e67c7 --- /dev/null +++ b/research/nine-source-johnson-chain-seed923edf/README.md @@ -0,0 +1,216 @@ +# Nine-source Johnson-path connector construction + +**Exact connector-level construction; no selected-kappa change.** Five +distinct dirty outputs on nine read-only F2 sources have supports +`01234, 01235, 01256, 01567, 05678`. A single restored source path computes +all five outputs in **28 complete calls**, meeting the general floor of two +calls per active source and two per output. Five independent restored row +stars cost 60 calls. The construction uses only the existing singleton +connector alphabet and makes no supplier or multiplication-bound claim. + +**Handoff:** [PR #2296](https://github.com/CrocSwap/integer-mult-bounds/pull/2296) +is open against the exact base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. +At the initial submission check, head `b4af93f238e69ccf000eb9e90030be4c01cda391` +was mergeable and hosted checks were queued. The subsequent handoff metadata +update advanced the branch; consult the PR for its current head and checks. +The public Discussion claim remains unposted because +the authenticated GraphQL route did not complete and the prior REST comment +route returned 404; the local claim and PR preserve the coordination record. + +Prepared by Cinna Davis with substantial OpenAI Codex assistance in scope +selection, derivation, implementation and verification. No other contributor +work is claimed. Apache-2.0. + +## Assignment, scope and coordination + +- Accepted seed: `923edf31ad6e8cfdc58bb11a6c6d6b3d`; track + `recursive-interfaces`; task `connector-alphabet-change`. +- Excluded draw: `3c0e460e62633c4b16b5923d0f386d45` selected + `adversarial-audit` from the prior submitted branch, so it was discarded. +- Exact base: `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`; catalogue revision 4, + catalogue SHA256 + `d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7`; + selected-record SHA256 + `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. +- Scope changed from adding a connector operation to keeping the existing + alphabet and constructing one sparse support family. The exact local claim + is in [CLAIM.md](CLAIM.md). The generalization is limited to support paths + that introduce a fresh source at each one-element exchange. +- Overlap: the complete cached snapshot held 511 open PRs and 990 Discussions + (no warnings). The exact local overlap-helper searches for the nine-source + weight-five path returned no direct matches. PR data was fetched at 03:42 UTC + and Discussion data at 03:26 UTC on 2026-10-15. A newer authenticated + GraphQL refresh hung and was stopped after about two minutes. The final + pre-submission refresh produced no output and + timed out after 50 seconds at 03:56 UTC, so the full cached snapshot was not + refreshed. Targeted live PR searches at 04:00 UTC found no `J(9,5)`, exact + five-mask, or "nine-source Johnson-chain" match. A broader search surfaced + open PR #2208 at head + `28480ef4fdb4caeab89765ea56595bf1f6f37688`, which studies all-word two-root + dirty-connector bounds and a minimum-read source-walk compiler for up to 511 + outputs. That work is adjacent, but does not give this single-connector + five-mask path or its 28-call floor. The nearest small source-path result, + PR #2271 at + `95fd439596f72575d3869277c2d01aca1ca6ab6a`, is a 12-row local bit-register + tour through three different masks. Cycle 31 PR #2283 at + `21145202e9a27cd9b18ffc7e23383cc83461c4a0` is a negative result for the + entire n=8 weight-four shell under two complete sweeps. PR #2229 studies n=7 + weights 1--3; PR #2266 changes the alphabet to GF(4) for two sources. + Active nearby claims #2262 (GF(4)) and #2275 (seven-source paired-call root + counts) use different objects and support families. PR #2208 changes the + interface to two roots and studies many outputs/readout tariffs; this result + uses one F2 connector and five specified outputs, with no frame transitions. +- Discussion claim status: local-only because the authenticated GraphQL + request hung, the final pre-submission refresh timed out without output, and + a prior direct REST Discussions comment attempt returned 404. Claim expiry + recorded in [CLAIM.md](CLAIM.md) is 2026-10-15 05:45 UTC. + +## Model and fully charged cost screen + +Use the pinned singleton F2 interface: `B_j: z += B_j x_j` for read-only +sources `j=0,...,8`, and `A_i: y_i += A_i z` for five separate outputs. At +entry, all source rows, targets and connector `z` are arbitrary and dirty. +Each complete call restores its private scratch and tape heads. The interface +and predecessor are pinned in [SOURCES.json](SOURCES.json), especially the +[universal connector statement](../universal-connector-boundary/README.md). + +Before implementation, the target was 28 complete calls: every one of the +nine active source maps must be toggled an even positive number of times to +restore dirty `z`, so it costs at least 18 B calls. Every nonzero output map +must be read an even positive number of times to cancel arbitrary dirty `z`, +so five outputs cost at least ten A calls. The independent restored-row +baseline is 60 calls: for each weight-five row, read its `A_i` at `q=0`, +toggle five sources into `z`, read `A_i` at `q=S_i`, and toggle those five +sources back, for `5+2+5=12` calls per row. The path below reaches 28 exactly, +saving 32 complete calls (53 1/3%) in the unit-call model. + +For the lower bound, specialize every operator to scalar identity maps and +vary one source and the dirty connector independently. Restoring `z` forces +each active `B_j` count even, while producing every nonzero output and +cancelling arbitrary `z` forces each `A_i` count even and positive. This +gives `2*9 + 2*5` for any correct schedule in the stated alphabet. + +The same comparison holds with unequal **per-call** prices. Let `c_j > 0` be +the complete price of `B_j`, `a_i > 0` the complete price of `A_i`, and +`d_j` the number of outputs containing source `j`. Here +`d=(5,4,3,2,1,4,3,2,1)`. The shared path costs +`2 sum_j c_j + 2 sum_i a_i`; independent row stars cost +`2 sum_j d_j c_j + 2 sum_i a_i`. Thus the exact saving is +`2 sum_j (d_j-1)c_j > 0`. Readout prices cancel; the saving comes from +source maps that occur in multiple rows. This weighted invoice charges each +complete B/A call, including its recursive child bill when such a bill is +assigned. It assumes a call's price is stable across positions in the word. + +The path adds no clean rows, copies, helper operations or separate frames, and +returns `z` to its dirty entry value. The abstract connector model has no +position-dependent frame-transition charge. A concrete supplier would still +need its actual child prices, any schedule-dependent transition or host cost, +precision and tape bill, and a placement proof. This local cost reduction is +not a kappa claim. + +## Construction + +Let the five supports be + +```text +S1 = {0,1,2,3,4} +S2 = {0,1,2,3,5} +S3 = {0,1,2,5,6} +S4 = {0,1,5,6,7} +S5 = {0,5,6,7,8}. +``` + +They form a path in `J(9,5)`: each next support removes one current source +and introduces a source not used before. Their union is all nine sources, and +only source 0 is common to all five outputs; the route does not rely on a +large shared core. +The source word follows the parity states + +```text +0 -> S1 -> S2 -> S3 -> S4 -> S5 -> 0 +``` + +by toggling each symmetric difference: + +```text +B0 B1 B2 B3 B4 | B4 B5 | B3 B6 | B2 B7 | B1 B8 | B0 B5 B6 B7 B8 +``` + +At the initial `q=0` prefix, call each `A_i` once. At the later prefix +`q=S_i`, call that same `A_i` once more. The resulting full schedule uses 18 +source calls and ten output readouts. Each `B_j` appears exactly twice, so +arbitrary connector contents are restored. + +For each output, the two `A_i` calls contribute + +```text +A_i z_initial + A_i(z_initial + sum_{j in S_i} B_j x_j) += sum_{j in S_i} A_i B_j x_j, +``` + +because the interface is over F2 and `A_i` is linear. Thus arbitrary initial +target and connector contents cancel in the update, while every source input +remains unchanged. The scalar verifier exhausts all source values and dirty +bits; this algebraic identity establishes the same schedule for arbitrary +compatible linear maps. + +More generally, take `p` distinct supports `S_1,...,S_p` of size `r`, where +each transition replaces one current source by a fresh source and +`n=r+p-1`. The same closed path `0,S_1,...,S_p,0` uses +`r+2(p-1)+r=2n` source calls; each source appears twice. Two A readouts per +output give `2n+2p`, the complete-call lower floor. Separate row stars cost +`p(2r+2)`. In the recorded instance `n=9`, `r=p=5`, these are 28 and 60. + +## Verification + +Run from repository root with Python 3.10 or later and the standard library: + +```sh +python3 -B research/nine-source-johnson-chain-seed923edf/verify.py +python3 scripts/research_package.py --package research/nine-source-johnson-chain-seed923edf --check-only +``` + +The exact verifier checks the five supports, all nine source labels, every +Johnson-path transition, the 18-toggle word, the ten readouts and the 28-call +floor. For each of 512 source assignments, both dirty connector bits and all +32 dirty-output vectors (32,768 cases), it replays both the shared path and an +independent 60-call row-star schedule. Negative controls expose single-readout +connector leakage, a wrong output boundary, and a missing restoration call. +The verifier also checks the weighted formula at the nonuniform prices +`c_B=(1,...,9)` and `a=(1,...,5)`, where the saving is 120 price units. + +Expected output starts with: + +```text +PASS_NINE_SOURCE_WEIGHT_FIVE_JOHNSON_CHAIN +supports=01f,02f,067,0e3,1e1 +common_sources=0 +source_calls=18 +readout_calls=10 +total_complete_calls=28 +independent_row_stars=60 +saved_calls=32 +weighted_price_control_saving=120 +dirty_state_cases=32768 +``` + +The registered package replay uses Python 3.12. This host has Python 3.14.7 +and no `python3.12`; the direct verifier and package metadata/pin check were +run locally. Hosted replay remains an obligation. + +## Selected context + +The selected conditional result remains +`836330098538459/500000000000000000`, reviewed in +`docs/research/community-batch1099-review.md`. Its source manifest, +`ASSEMBLY.json`, reproduction `make frontier1094-verify`, Makefile rule and +actual verifier are pinned in [SOURCES.json](SOURCES.json). That reproduction +was resolved but not rerun: this contribution changes no selected source, +certificate, supplier or frontier record. + +## Open next questions + +The next useful question is whether nonuniform B/A call prices preserve a net +saving over separate row stars for this fresh-source Johnson-path family. That +requires assigning actual recursive child prices before claiming any effect +on the selected bound. diff --git a/research/nine-source-johnson-chain-seed923edf/SOURCES.json b/research/nine-source-johnson-chain-seed923edf/SOURCES.json new file mode 100644 index 0000000000..2b553d1ee3 --- /dev/null +++ b/research/nine-source-johnson-chain-seed923edf/SOURCES.json @@ -0,0 +1,132 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "AGENTS.md", + "usage": "provenance", + "git_blob": "1dce1b16a687a5d1a507ef64b9d4da19dd9e43f9", + "sha256": "5378ffbf3a119fcd0c23bcce20f34e5dd2fa792a00a0033e47667aeba72bbc37" + }, + { + "path": "CONTRIBUTING.md", + "usage": "provenance", + "git_blob": "e51435543687f1bd88ab22248082dc689ce8b853", + "sha256": "df5b5646602f42cb5da5844f04ac925182ddcd0f627b9de1c96a5095bb7a277a" + }, + { + "path": "Makefile", + "usage": "provenance", + "git_blob": "448f13b58fbe3492e2ea6b2005c8822aefe2765c", + "sha256": "029076ba6558f4c97d59d508baeb47847e0fad3545ed1fd22943ab9d6c84c2b9" + }, + { + "path": "autoresearch.md", + "usage": "provenance", + "git_blob": "9b6cbfef0fb725f28c177038d32f482706e12c94", + "sha256": "79d0c8be61d90dd6c46b6e7250e0c88713d29854128d8d1361b6343682dad1d8" + }, + { + "path": "certificates/selected-result.json", + "usage": "provenance", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "docs/research/agent-task-catalog.json", + "usage": "provenance", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "docs/research/community-batch1099-review.md", + "usage": "provenance", + "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099", + "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb" + }, + { + "path": "docs/research/research-priority-log.md", + "usage": "provenance", + "git_blob": "457b6c703cbc2436c224945f4d9c4cf97911261e", + "sha256": "6e861e9198370aac3f8fabf8d68d95d605dcfaf9e6bf5f05e58378b0f2bedf5d" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "provenance", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + { + "path": "research/community-frontier1094-audit/INDEPENDENT1094.json", + "usage": "provenance", + "git_blob": "009a385e26858058a18188364078d162aa6f9519", + "sha256": "301fb8a0e4ab7e3c383ff974c54c08178283b2a3453c5282757f692a3c7a4bfd" + }, + { + "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "provenance", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/universal-connector-boundary/CERTIFICATE.json", + "usage": "provenance", + "git_blob": "079e3e1441dc07c2f0536e9527acf290e51ea9c0", + "sha256": "e733746ba3e5151c829b4e8728bfff5ae3ed24d8d203eb77c735d20758e8266a" + }, + { + "path": "research/universal-connector-boundary/EXPECTED.json", + "usage": "provenance", + "git_blob": "c0f2eef36c9543745bb9d00f66913b0abf5cc904", + "sha256": "658924c2940cbe193378d5ef09f4d62500fc7b385c16c0ea33846be836c429d2" + }, + { + "path": "research/universal-connector-boundary/README.md", + "usage": "provenance", + "git_blob": "d277f7c5830b1f2bc42e1ff41ab86e7d7564929f", + "sha256": "23415f7829ab8d80a783142f10f7d31abbce84579362769984680af3df954476" + }, + { + "path": "research/universal-connector-boundary/SOURCES.json", + "usage": "provenance", + "git_blob": "885157ac149d8c8b8daad7e2b324e6d0ee454a51", + "sha256": "6c51dd06c73a4e94f28b636b9d07a22b8917baebdbf4a3b85b0f8541ea7dcbfe" + }, + { + "path": "research/universal-connector-boundary/dense_checks.py", + "usage": "provenance", + "git_blob": "62f15821973de3d517396917f1992f2bd6ddb84d", + "sha256": "7a568bca612fede226fc5326492953392d895d04e88fad417119d40d148a9fc6" + }, + { + "path": "research/universal-connector-boundary/independent.py", + "usage": "provenance", + "git_blob": "af9a81a137991431c4d243475b2d6dac9c3d8790", + "sha256": "fb765d0d26e0cdf1d266663fe7068957fcfba77b9bd89396af29966f89f1b6cf" + }, + { + "path": "research/universal-connector-boundary/references/PR934-NOTICE.md", + "usage": "provenance", + "git_blob": "22bc8648ac14639249923aa328603877aaceaf1a", + "sha256": "2b085e535c310847dd489ca60e5d12277bdb601aa1af3c731f36eb0275184528" + }, + { + "path": "research/universal-connector-boundary/references/PR934-README.md", + "usage": "provenance", + "git_blob": "7158c8c1f9d64506cb2a52ca047f947e544e0ae6", + "sha256": "d187dc94bf631bd5b6da2cc1019a2d1ba687b624fdaf32aae05dffc67872509d" + }, + { + "path": "research/universal-connector-boundary/verify.py", + "usage": "provenance", + "git_blob": "de6483bb7ff51940dbbb76c18f91af4c907e07da", + "sha256": "e4fa4700f9e1ae6ca09c3c76ebc569e8361b89b699425a67839d999d8812e42d" + }, + { + "path": "scripts/verify_frontier1094.py", + "usage": "provenance", + "git_blob": "96e6c1386bd052b9bcaf136d934406f3f0c3f777", + "sha256": "c7e20f59968ed5736fb859735de4de207de3418083e37012310ebcded946b949" + } + ] +} diff --git a/research/nine-source-johnson-chain-seed923edf/TASK.json b/research/nine-source-johnson-chain-seed923edf/TASK.json new file mode 100644 index 0000000000..a8aa0f17c7 --- /dev/null +++ b/research/nine-source-johnson-chain-seed923edf/TASK.json @@ -0,0 +1,201 @@ +{ + "schema_version": 1, + "task_id": "connector-alphabet-change", + "priority_revision": 4, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "original_card": { + "id": "connector-alphabet-change", + "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?", + "starting_points": [ + "research/universal-connector-boundary/README.md", + "certificates/selected-result.json" + ], + "methods": [ + "Construct and charge a legal extra operation on a minimal instance.", + "Prove a target-specific bound after adding one specified operation family." + ], + "acceptance_gate": "State which fixed-alphabet premise changes and charge its implementation; do not declare it free.", + "first_step": { + "command": [ + "python3", + "-B", + "research/universal-connector-boundary/verify.py" + ], + "expected": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY", + "inspect": "Reproduce the 945-pairing control, then read Exact interface to list the allowed calls.", + "scope": "Positive control / source-bound orientation only; this is not a new construction or full cold replay." + }, + "first_experiment": "Add exactly one legally priced operation and test a tiny dirty-input instance before enumerating larger cases.", + "bottleneck_link": "A new legal connector operation could change recursive interface cost; a larger census in the same alphabet is a separate side result.", + "allowed_variations": [ + "Choose one additional operation and a small source count for its first counterexample." + ], + "scope_change_triggers": [ + "Keeping the alphabet and only increasing the source count; record this as a changed assignment." + ], + "overlap_terms": [ + "universal connector", + "source-toggle", + "connector alphabet" + ] + }, + "scope_status": "changed", + "actual_scope": "In the established singleton F2 dirty-connector alphabet, construct an exact complete-call-floor schedule for nine read-only source maps B0..B8 and five distinct dirty output maps Ai with supports S1=01234, S2=01235, S3=01256, S4=01567, S5=05678. These five weight-five masks form a path in J(9,5), each step replacing one source, and use all nine sources.", + "scope_change_reason": "The selected card asks to extend the connector alphabet, but the live connector and output-path lanes are crowded. This scope adds no operation: it tests an explicit sparse support family whose consecutive masks form a Johnson path. It is distinct from Cycle 31 PR #2283, which searched a two-sweep path for all 70 weight-four masks at n=8 and found a scoped obstruction, and from PR #2271, a 12-row local bit-register tour through three different masks.", + "bottleneck_link": "A path through sparse output supports can share repeated B-source transitions and remove work from a recursive connector interface; reaching the 2n+2p call floor is a precise local target, while supplier placement and weighted child prices remain open.", + "budget_minutes": 60, + "stop_rule": "Screen the fully charged per-complete-call floor against separate row stars. If favorable, construct the explicit n=9, r=5, p=5 Johnson path; replay all 32768 dirty scalar cases and run one-readout, wrong-boundary and missing-restoration controls. Stop after the exact replay and lower-bound proof; do not search unrelated support families or infer supplier placement/kappa.", + "outcome": "completed", + "evidence": "PASS_NINE_SOURCE_WEIGHT_FIVE_JOHNSON_CHAIN: 18 source calls plus ten readouts = exact 28-call floor; five independent row stars cost 60. Both schedules were replayed for all 32768 arbitrary dirty scalar states. Single-readout leakage, wrong-boundary and missing-restoration controls pass. Source incidence vector is (5,4,3,2,1,4,3,2,1); for stable positive per-call prices the exact saving over row stars is 2*sum_j(d_j-1)c_j, while A-call prices cancel. No supplier placement or kappa claim.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, derivation, implementation and verification.", + "open_questions": [ + { + "question": "Can a source-pinned selected supplier realize the fresh-source Johnson-path schedule with stable per-call B/A prices and no offsetting frame or host charges?", + "why_it_matters": "The abstract weighted saving is strict for positive source prices, but only actual source-role placement and transition billing can connect it to the selected recursive moment.", + "first_step": "Identify a selected source word with nine roles matching the supports and price each B/A invocation, frame transition, host, precision and tape effect against separate stars.", + "blocked_by": "No matching selected supplier or source-role map is identified in this finite connector package." + } + ], + "track": "recursive-interfaces", + "assignment_seed": "923edf31ad6e8cfdc58bb11a6c6d6b3d", + "discarded_excluded_draws": [ + { + "seed": "3c0e460e62633c4b16b5923d0f386d45", + "track": "adversarial-audit", + "reason": "Excluded track; draw was also made from the prior submitted branch rather than current main and was not accepted." + } + ], + "selector_scope_key": "ff4f5113ed2256ab19ed", + "catalog_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selector_suggestions": [ + { + "task_id": "coverage-law-change", + "scope_key": "f383d8fc405ee6982cdd" + }, + { + "task_id": "connector-alphabet-change", + "scope_key": "ff4f5113ed2256ab19ed" + }, + { + "task_id": "joint-query-controller", + "scope_key": "0e34adbc1dd119161c3a" + } + ], + "claim_status": "local-only-unposted; result submitted as PR #2296", + "claim_expiry_utc": "2026-10-15T05:45:00Z", + "claim_text_path": "CLAIM.md", + "submission": { + "pull_request": 2296, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2296", + "state": "OPEN", + "initial_head": "b4af93f238e69ccf000eb9e90030be4c01cda391", + "base": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "mergeable": true, + "hosted_checks": "queued at initial submission check" + }, + "overlap_snapshot": { + "checked_at_utc": "2026-10-15T03:44:32Z", + "open_prs": 511, + "discussion_records": 990, + "open_prs_fetched_at_utc": "2026-10-15T03:42:09Z", + "discussions_fetched_at_utc": "2026-10-15T03:26:59Z", + "complete_pagination": true, + "warnings": [], + "exact_terms": [ + "nine-source weight-five connector", + "J(9,5) path", + "n=9 weight-five mask chain", + "complete-call floor 28", + "01234 01235 01256 01567 05678" + ], + "direct_remote_matches": 0, + "live_refresh": "The earlier GraphQL request hung and was stopped after about two minutes; the final pre-submission refresh produced no output and timed out after 50 seconds at 2026-10-15T03:56:30Z. The cached snapshots were not refreshed.", + "pre_submission_refresh_at_utc": "2026-10-15T03:56:30Z", + "pre_submission_refresh_result": "timeout after 50 seconds; no output; no new overlap data", + "related_open_pr_heads": { + "PR2128": "697369a971eed02c0fbcd75ebefec9f59945f08e", + "PR2208": "28480ef4fdb4caeab89765ea56595bf1f6f37688", + "PR2229": "b4eab83755969d406edba9f25b7890e4db4c4931", + "PR2266": "9382f0d9796cd58831f876943162c536fa14cfd5", + "PR2271": "95fd439596f72575d3869277c2d01aca1ca6ab6a", + "PR2283": "21145202e9a27cd9b18ffc7e23383cc83461c4a0" + }, + "targeted_live_pr_search": { + "searched_at_utc": "2026-10-15T04:00:24Z", + "queries": [ + "J(9,5)", + "01234 01235 01256 01567 05678", + "nine-source Johnson-chain" + ], + "exact_query_matches": 0, + "adjacent_open_pr": { + "number": 2208, + "head": "28480ef4fdb4caeab89765ea56595bf1f6f37688", + "scope": "all-word two-root dirty-connector bounds and minimum-read walk compilation for many outputs" + } + }, + "related_discussions": [ + "Discussion #1516: active centre-path hosting claim; different object", + "Discussion #1587: active two-unpaid-coordinate claim; different object", + "Discussion #2221: completed n=7 low-weight mask result", + "Discussion #2262: active GF(4) scalar-source claim", + "Discussion #2275: active n=7 paired-call root-count claim" + ] + }, + "selected_context": { + "kappa": "836330098538459/500000000000000000", + "review": "docs/research/community-batch1099-review.md", + "source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "reproduce": "make frontier1094-verify", + "certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "source_manifest_sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b", + "review_sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb", + "reproduction_run_this_cycle": false + }, + "candidate_screen": [ + { + "scope": "coverage-law-change: two unpaid coordinates per family", + "status": "rejected-overlap", + "evidence": "Active Discussion #1587, expires 2026-10-15T07:30Z; this is the current selector card question." + }, + { + "scope": "centre-path-sharing: host or share the selected centre path", + "status": "rejected-overlap", + "evidence": "Active Discussion #1516 claim through 2026-10-15T05:00Z; related older records #1963 and #2058." + }, + { + "scope": "joint-query-controller: QQ16 changed interface", + "status": "rejected-overlap-and-repeat", + "evidence": "Open PR #2153 and prior Cycle 30 PR #2268; not repeated." + }, + { + "scope": "connector-alphabet-change: explicit new operation", + "status": "scope-changed", + "evidence": "Open connector work includes PRs #2128, #2208, #2229, #2266, #2271 and Cycle 31 PR #2283 plus active Discussions #2262 and #2275. Live searches for J(9,5) and the exact five-mask vector returned no PR match. Adjacent PR #2208 develops all-word two-root dirty-connector bounds and a minimum-read compiler for supplied walks over many outputs; it does not provide this one-connector five-mask chain or 28-call floor. Use the existing alphabet." + } + ], + "cost_screen": { + "source_call_floor": 18, + "output_readout_floor": 10, + "optimistic_and_constructed_total": 28, + "row_star_comparator": 60, + "unit_call_saving": 32, + "source_incidence_counts": [ + 5, + 4, + 3, + 2, + 1, + 4, + 3, + 2, + 1 + ], + "weighted_saving": "2*sum_j(d_j-1)c_Bj; target A prices cancel", + "per_call_scope": "Each B_j and A_i price is a complete invocation price, including its recursive child bill if assigned; prices are assumed stable across positions.", + "not_invoiced": "No position-dependent transition or concrete supplier placement price is known; no selected kappa is inferred." + } +} diff --git a/research/nine-source-johnson-chain-seed923edf/VERIFY.json b/research/nine-source-johnson-chain-seed923edf/VERIFY.json new file mode 100644 index 0000000000..e81f6a6b00 --- /dev/null +++ b/research/nine-source-johnson-chain-seed923edf/VERIFY.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-O", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 120, + "checks": "Verify the five supports and Johnson path; exhaust all 32768 dirty scalar states for both shared and independent row-star schedules; require the exact 28-call floor, weighted price identity and three failure controls." + } + ] +} diff --git a/research/nine-source-johnson-chain-seed923edf/verify.py b/research/nine-source-johnson-chain-seed923edf/verify.py new file mode 100644 index 0000000000..e176afa747 --- /dev/null +++ b/research/nine-source-johnson-chain-seed923edf/verify.py @@ -0,0 +1,182 @@ +#!/usr/bin/env python3 +"""Exact dirty-state replay for a nine-source Johnson-path connector batch.""" + +from __future__ import annotations + +from collections import Counter + +N = 9 +MASKS = (0x01F, 0x02F, 0x067, 0x0E3, 0x1E1) +SOURCE_WORD = (0, 1, 2, 3, 4, 4, 5, 3, 6, 2, 7, 1, 8, 0, 5, 6, 7, 8) +READOUT_BOUNDARIES = (5, 7, 9, 11, 13) +DIRTY_OUTPUTS = len(MASKS) + + +def require(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def parity_dot(source_values: int, support: int) -> int: + return (source_values & support).bit_count() & 1 + + +def prefix_masks() -> tuple[int, ...]: + q = 0 + states = [q] + for source in SOURCE_WORD: + q ^= 1 << source + states.append(q) + return tuple(states) + + +def replay(source_values: int, dirty_connector: int, dirty_outputs: int) -> tuple[int, int]: + """Execute the scheduled scalar F2 calls; return final z and output bits.""" + q = 0 + z = dirty_connector + outputs = dirty_outputs + + # Each A_i is read once at the common zero prefix. + for i in range(DIRTY_OUTPUTS): + outputs ^= dirty_connector << i + + readout_at = {boundary: i for i, boundary in enumerate(READOUT_BOUNDARIES)} + for boundary, source in enumerate(SOURCE_WORD, start=1): + value = (source_values >> source) & 1 + z ^= value + q ^= 1 << source + if boundary in readout_at: + output = readout_at[boundary] + outputs ^= z << output + + require(q == 0, "source connector did not return to its entry parity") + expected_z = dirty_connector + require(z == expected_z, "dirty connector value was not restored") + return z, outputs + + +def replay_row_stars(source_values: int, dirty_connector: int, + dirty_outputs: int) -> tuple[int, int]: + """Independent per-output schedule used for the 60-call comparator.""" + z = dirty_connector + outputs = dirty_outputs + for i, support in enumerate(MASKS): + outputs ^= z << i + for source in range(N): + if (support >> source) & 1: + z ^= (source_values >> source) & 1 + outputs ^= z << i + for source in range(N): + if (support >> source) & 1: + z ^= (source_values >> source) & 1 + return z, outputs + + +def verify_instance() -> tuple[int, int, tuple[int, ...]]: + universe = (1 << N) - 1 + require(len(set(MASKS)) == DIRTY_OUTPUTS, "output supports must be distinct") + require(all(mask.bit_count() == 5 for mask in MASKS), "each output must have weight five") + require(set().union(*(set(j for j in range(N) if (mask >> j) & 1) for mask in MASKS)) == set(range(N)), + "the output family must use all nine sources") + common = universe + for mask in MASKS: + common &= mask + require(common == 1, "only source 0 should be common to all five outputs") + require(all((left ^ right).bit_count() == 2 for left, right in zip(MASKS, MASKS[1:])), + "successive supports must differ by one exchange in J(9,5)") + + counts = Counter(SOURCE_WORD) + require(counts == Counter({j: 2 for j in range(N)}), "every source must be toggled exactly twice") + states = prefix_masks() + require(tuple(states[b] for b in READOUT_BOUNDARIES) == MASKS, + "the source word must visit all five requested supports") + require(states[-1] == 0, "source path must end at zero") + + cases = 0 + for source_values in range(1 << N): + for dirty_connector in (0, 1): + for dirty_outputs in range(1 << DIRTY_OUTPUTS): + final_z, actual_outputs = replay(source_values, dirty_connector, dirty_outputs) + expected_outputs = dirty_outputs + for i, support in enumerate(MASKS): + expected_outputs ^= parity_dot(source_values, support) << i + require(final_z == dirty_connector, "connector restoration failed") + require(actual_outputs == expected_outputs, "dirty-state output map mismatch") + stars_z, stars_outputs = replay_row_stars( + source_values, dirty_connector, dirty_outputs) + require(stars_z == dirty_connector and stars_outputs == expected_outputs, + "independent row-star control disagrees with the target map") + cases += 1 + + require(cases == (1 << N) * 2 * (1 << DIRTY_OUTPUTS), "dirty-state domain is incomplete") + + # Failure control 1: a lone A readout leaks arbitrary entry dirt. + dirty_y, dirty_z, zero_sources = 0, 1, 0 + lone_read = dirty_y ^ dirty_z ^ parity_dot(zero_sources, 0) + require(lone_read != dirty_y, "single-readout dirty-z control failed to expose leakage") + + # Failure control 2: reading output 0 at the S2 boundary instead of S1 + # returns source 4 even though source 4 is absent from its requested row. + wrong_source_values = 1 << 4 + wrong_boundary_term = parity_dot(wrong_source_values, states[READOUT_BOUNDARIES[1]]) + correct_row_term = parity_dot(wrong_source_values, MASKS[0]) + require(wrong_boundary_term != correct_row_term, "wrong-boundary control failed") + + # Failure control 3: omit the final B8 call and set x8=1; the connector + # then retains the source-8 coefficient instead of restoring to entry. + without_last = SOURCE_WORD[:-1] + q = 0 + for source in without_last: + q ^= 1 << source + omitted_restore_residual = parity_dot(1 << 8, q) + require(omitted_restore_residual == 1, "missing-restoration control failed") + + # The exact call floor and the row-by-row comparator use the same complete + # unit-call alphabet: 2 per active source, 2 per output; 2r+2 per row star. + source_calls = len(SOURCE_WORD) + readout_calls = 2 * DIRTY_OUTPUTS + lower_floor = 2 * N + 2 * DIRTY_OUTPUTS + row_stars = DIRTY_OUTPUTS * (2 * 5 + 2) + require(source_calls == 2 * N and readout_calls == 2 * DIRTY_OUTPUTS, + "schedule call counts do not meet the source/readout lower floor") + require(source_calls + readout_calls == lower_floor == 28, + "schedule did not attain the exact complete-call floor") + require(row_stars == 60, "row-star baseline arithmetic changed") + + # Heterogeneous complete-call prices are charged by operator type. The + # output-readout bill is identical in both schedules; B_j is used 2*d_j + # times in separate stars and exactly twice in the shared path. + degrees = tuple(sum((mask >> j) & 1 for mask in MASKS) for j in range(N)) + require(degrees == (5, 4, 3, 2, 1, 4, 3, 2, 1), "source incidence vector changed") + source_prices = tuple(range(1, N + 1)) + target_prices = tuple(range(1, DIRTY_OUTPUTS + 1)) + shared_weighted = 2 * sum(source_prices) + 2 * sum(target_prices) + stars_weighted = (2 * sum(degrees[j] * source_prices[j] for j in range(N)) + + 2 * sum(target_prices)) + weighted_saving = 2 * sum((degrees[j] - 1) * source_prices[j] for j in range(N)) + require(stars_weighted - shared_weighted == weighted_saving == 120, + "heterogeneous complete-call price accounting failed") + require(weighted_saving > 0, "positive source call prices should yield a strict saving") + return cases, weighted_saving, degrees + + +def main() -> None: + cases, weighted_saving, degrees = verify_instance() + print("PASS_NINE_SOURCE_WEIGHT_FIVE_JOHNSON_CHAIN") + print(f"supports={','.join(f'{m:03x}' for m in MASKS)}") + print("common_sources=0") + print(f"source_word={','.join(str(j) for j in SOURCE_WORD)}") + print("source_calls=18") + print("readout_calls=10") + print("total_complete_calls=28") + print("independent_row_stars=60") + print("saved_calls=32") + print(f"source_incidence_counts={','.join(str(x) for x in degrees)}") + print(f"weighted_price_control_saving={weighted_saving}") + print(f"dirty_state_cases={cases}") + print("controls=single-readout,wrong-boundary,missing-restoration") + print("scope=singleton F2 connector; weighted formula assumes stable per-call prices; no supplier or kappa claim") + + +if __name__ == "__main__": + main()