From 6687dfdd084a465582194258f416f24604136aaa Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 20:24:41 -0500 Subject: [PATCH 1/2] Research seven-source 16-event connector boundary --- .../PREDECESSOR.json | 88 ++ .../README.md | 199 ++++ .../RESULT.json | 943 ++++++++++++++++++ .../SOURCES.json | 48 + .../TASK.json | 298 ++++++ .../VERIFY.json | 33 + .../search.py | 288 ++++++ .../verify.py | 277 +++++ 8 files changed, 2174 insertions(+) create mode 100644 research/seven-source-16event-connector-seeda7de5e/PREDECESSOR.json create mode 100644 research/seven-source-16event-connector-seeda7de5e/README.md create mode 100644 research/seven-source-16event-connector-seeda7de5e/RESULT.json create mode 100644 research/seven-source-16event-connector-seeda7de5e/SOURCES.json create mode 100644 research/seven-source-16event-connector-seeda7de5e/TASK.json create mode 100644 research/seven-source-16event-connector-seeda7de5e/VERIFY.json create mode 100644 research/seven-source-16event-connector-seeda7de5e/search.py create mode 100644 research/seven-source-16event-connector-seeda7de5e/verify.py diff --git a/research/seven-source-16event-connector-seeda7de5e/PREDECESSOR.json b/research/seven-source-16event-connector-seeda7de5e/PREDECESSOR.json new file mode 100644 index 0000000000..3109a7cd7d --- /dev/null +++ b/research/seven-source-16event-connector-seeda7de5e/PREDECESSOR.json @@ -0,0 +1,88 @@ +{ + "artifact_path": "research/seven-source-weight123-connector-seed7db30a/RESULT.json", + "artifact_sha256": "7e6ddf449de9c9a5c4a408346f9c172a48fcb1ae97075b055797a39fa91c1011", + "coverage_histogram": { + "18": 7, + "19": 14, + "20": 63, + "21": 85, + "22": 175, + "23": 294, + "24": 420, + "25": 644, + "26": 1022, + "27": 1659, + "28": 2179, + "29": 3626, + "30": 6041, + "31": 7749, + "32": 8988, + "33": 12817, + "34": 14042, + "35": 16074, + "36": 11977, + "37": 13307, + "38": 9513, + "39": 8421, + "40": 5411, + "41": 4039, + "42": 2520, + "43": 1729, + "44": 882, + "45": 763, + "46": 266, + "47": 266, + "49": 84, + "50": 28, + "51": 14, + "53": 14, + "56": 2 + }, + "head": "b4eab83755969d406edba9f25b7890e4db4c4931", + "maximum_missing_masks": [ + 22, + 38, + 41, + 42, + 73, + 81, + 84 + ], + "maximum_prefix_states": [ + 0, + 1, + 3, + 7, + 6, + 14, + 10, + 26, + 18, + 50, + 34, + 98, + 66, + 64, + 0 + ], + "maximum_target_coverage": 56, + "maximum_word": [ + 0, + 1, + 2, + 0, + 3, + 2, + 4, + 3, + 5, + 4, + 6, + 5, + 1, + 6 + ], + "schema_version": 1, + "status": "open PR; author-checked result, not merged into main", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2229" +} diff --git a/research/seven-source-16event-connector-seeda7de5e/README.md b/research/seven-source-16event-connector-seeda7de5e/README.md new file mode 100644 index 0000000000..90c45aa6d9 --- /dev/null +++ b/research/seven-source-16event-connector-seeda7de5e/README.md @@ -0,0 +1,199 @@ +# Seven-source 16-event connector: exact 60-mask maximum and 142-call obstruction + +**Scoped construction and lower bound; no new κ.** For the original one-root +F2 dirty connector, exhaust the 18,918,900 normalized source paths where one of +seven sources is toggled four times and the other six twice. The outputs are all +63 masks of weights 1, 2, and 3. No path covers all 63. The exact maximum is 60, +attained by eight canonical words. One maximum path constructs a 60-output batch +at 136 complete map calls, saving 274 source-map calls against independent +per-output stars. The exact source path class is a scoped negative result; the +60-mask witness is a positive construction. + +Together with the independently replayed 14-toggle predecessor census, the +result excludes full batches at both 140 and 142 complete map calls in this +event alphabet. Thus a full 63-mask batch needs at least 144 complete map calls +here. No 144-call construction is given or excluded. + +## Best 16-event witness + +Bit `j` denotes source `B_j`; mask decimals use the same convention. The best +canonical source word is + +```text +0 1 2 0 3 1 4 3 0 5 4 0 6 5 2 6 +``` + +Its prefix parity states are + +```text +0 1 3 7 6 14 12 28 20 21 53 37 36 100 68 64 0 +``` + +It covers all seven singleton and 21 pair masks, plus 32 of the 35 triples. +The missing masks are + +```text +44 73 82 +``` + +`RESULT.json` gives one valid pair of prefix boundaries for each of the 60 +supported masks. The full histogram records eight maximum-coverage words and no +full-cover word. Relabeling the six twice-used sources is quotiented by assigning +their labels in first-appearance order; the four-use source is distinguished. + +At boundary `t`, write `q_t` for the seven-bit parity vector of the source +toggles already called. For arbitrary dirty connector `z_0`, arbitrary F2-linear +maps `B_j`, and arbitrary inputs `x_j`, + +```text +z_t = z_0 + sum_j q_t[j] B_j x_j. +``` + +For a supported output mask `M`, invoke its arbitrary map `A_M` at boundaries +`s,t` with `q_s XOR q_t = M`. The dirty term cancels: + +```text +A_M(z_s) + A_M(z_t) = A_M(sum_{j in M} B_j x_j). +``` + +Each target's arbitrary dirty value also cancels because its map is called +twice. The source word uses multiplicities `(4,2,2,2,2,2,2)`, so it restores the +dirty connector. This proves the 60-output construction at every vector +dimension; the finite simulations in `verify.py` are controls, not the general +argument. + +## Fully charged 60-output invoice + +The supported 60 masks contain 145 source/output incidences. Their independent +stars use 290 complete `B` calls and 120 complete `A` calls: 410 total. The +shared path uses 16 complete `B` calls and the same 120 complete `A` calls: 136 +total. The source-call savings per map are `[38, 40, 40, 38, 40, 40, 38]` for +this labeling. + +Encode each event with one opcode bit, a three-bit `B` identifier or a six-bit +`A` identifier. Event order carries the boundary, so the schedule needs no +runtime search table. The independent-star stream is 2,000 bits; the shared +stream is 904 bits. If `c(B_j)` and `c(A_M)` are complete call prices, `lambda` +is the price per stored descriptor bit, `delta` is the per-event root-dispatch +price, and `I` and `P` are common admission and one-time coefficient preparation, +then + +```text +C_shared = I + P + 4*c(B_0) + 2*sum_{j=1..6} c(B_j) + + 2*sum_{M in S} c(A_M) + 904*lambda + 136*delta +C_stars = I + P + 42*c(B_0) + 42*c(B_1) + 42*c(B_2) + + 40*c(B_3) + 42*c(B_4) + 42*c(B_5) + 40*c(B_6) + + 2*sum_{M in S} c(A_M) + 2000*lambda + 410*delta +C_shared - C_stars = -38*c(B_0) - 40*c(B_1) - 40*c(B_2) + -38*c(B_3) - 40*c(B_4) - 40*c(B_5) -38*c(B_6) + -1096*lambda -274*delta. +``` + +Each complete call includes source or target access, arithmetic, target update, +hosting, private-scratch restoration, and head return. All `A_M` calls remain +paid in both programs. This is a componentwise cost reduction for every +nonnegative descriptor and dispatch price and every positive complete map-call +price. No supplier in the selected assembly is shown to instantiate this +connector, so the result supplies no κ change. + +## Why 140 and 142 full-batch calls are excluded + +In this connector contract every active `B_j` and every required `A_M` must be +called an even positive number of times: arbitrary source contributions and +arbitrary dirty source/target rows must cancel. The 140-call floor is therefore +14 source calls plus 126 target calls. The exact 14-toggle predecessor census +has maximum pairwise-prefix-difference coverage 56 of 63, so it cannot attain +that floor. + +At 142 complete map calls, the extra pair of calls has only two possible +allocations: + +1. **16 source calls and 126 target calls.** Every target is read twice. The + complete 16-event census here proves maximum coverage 60, so the full family + is impossible in this profile. +2. **14 source calls and 128 target calls.** The 14-toggle census leaves at + least seven targets without a pair of prefix boundaries. Only one target + map can receive the extra two calls, so at least six targets still cannot be + produced. + +There is no 143-call profile because the complete map-call total is even. These +arguments exclude 140 and 142 only for the original source-toggle/single-target +event alphabet and the stated arbitrary dirty connector contract. They do not +exclude other operation alphabets, longer schedules, a 144-call schedule, or a +supplier outside this interface. + +## Exact search and reproduction + +The first search tests all 840 insertions of one extra source-toggle pair into +the pinned maximum 14-toggle predecessor word. It finds no full cover and a +maximum of 58 masks. The exact fallback enumerates every normalized word with +one four-use source and six two-use sources. The domain size is + +```text +C(16,4) * 12! / (2^6 * 6!) = 18,918,900. +``` + +`search.py` generates the pair partition for the six two-use sources and +canonicalizes by first appearance. `verify.py` independently generates +restricted-growth source words, checks the full coverage histogram with a +bitset difference representation, and replays the prior 14-toggle census. It +also checks the 60-output dirty-state identity in dimensions 1, 2, and 3 and +four failure controls. + +From the repository root: + +```sh +python3 -I -B research/seven-source-16event-connector-seeda7de5e/search.py +python3 -I -B research/seven-source-16event-connector-seeda7de5e/verify.py +python3 scripts/research_package.py --package research/seven-source-16event-connector-seeda7de5e --check-only +``` + +Expected markers: + +```text +SEVEN_SOURCE_16EVENT_SEARCH insertions=840 insertion_hits=0 fallback_examined=18918900 fallback_complete=true full_cover=0 best=60 +PASS_SEVEN_SOURCE_16EVENT_BOUND old_domain=135135 old_max=56 new_domain=18918900 new_max=60 full_hits=0 max_words=8 outputs=60 calls=136 savings=274 controls=4 +PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check) +``` + +## Pins, overlap and limits + +Cycle 28 used seed `a7de5e16e6ab896abb6ef4a0dc88a174`, track +`recursive-interfaces`, task `connector-alphabet-change`, priority revision 4, +selector scope key `0c9f43f3c7d61edb36fe`, refined scope key +`778d279ecd9a5bb9118d`, and base +`0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. The selected-record SHA-256 is +`10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`; the +baseline binding check passed. The selected review, source manifest, certificate, +and reproduction command are pinned in `TASK.json` and `SOURCES.json`. + +The predecessor is open PR #2229 at head +`b4eab83755969d406edba9f25b7890e4db4c4931`, with +`RESULT.json` SHA-256 +`7e6ddf449de9c9a5c4a408346f9c172a48fcb1ae97075b055797a39fa91c1011`. That PR +is author-checked but not merged; this package independently replays its +14-toggle census for the 140/142 call split argument. The refreshed overlap scan +covered 470 open PRs and 931 Discussion/comment/reply records with complete +pagination and no warnings. Closest work includes #2128 (six-source universal +DUO path) and #2146 (six-source TRIO exclusion); the exact 16-event +seven-source multiplicity class was not present in the scan. The scan is a +novelty lead, not a certificate. + +Local exact search and verification use CPython 3.14.7. The repository package +runner requests Python 3.12, which is unavailable in this environment; its +registered replay was not run. The package pin check and direct search/verifier +commands were run locally. The selected cold replay `make frontier1094-verify` +was not rerun because this research does not change the selected source, +certificate, or assembly. No independent human review or proof-assistant +formalization is claimed. Prepared by Cinna Davis with substantial OpenAI Codex +assistance in scope selection, proof derivation, exact search, verification, +cost accounting, overlap checks, and writing. + +## Open next questions + +Can any 144-call profile attain the lower bound for all 63 masks? First test the +18-source-call multiplicities `(6,2,2,2,2,2,2)` and `(4,4,2,2,2,2,2)` with all +target maps called twice. Separately bound or search the mixed profiles with 16 +source calls and 128 target calls, or 14 source calls and 130 target calls. +The complete 16-event class is settled, but no 144-call construction or selected +supplier placement is known. diff --git a/research/seven-source-16event-connector-seeda7de5e/RESULT.json b/research/seven-source-16event-connector-seeda7de5e/RESULT.json new file mode 100644 index 0000000000..e813d7d478 --- /dev/null +++ b/research/seven-source-16event-connector-seeda7de5e/RESULT.json @@ -0,0 +1,943 @@ +{ + "attained_subset_cost": { + "charges": "Every complete B and A call is paid, including source/target access, arithmetic, writes, hosting, private scratch restoration and head return. Shared input admission and coefficient preparation cancel. The static event order encodes map identifiers and boundaries.", + "complete_calls_saved": 274, + "event_bits_saved": 1096, + "invoice_difference": "-sum_j source_calls_saved_per_map[j]*c(B_j) - event_bits_saved*lambda - root_dispatches_saved*delta", + "root_dispatches_saved": 274, + "shared_complete_calls": 136, + "shared_event_bits": 904, + "shared_source_calls": 16, + "source_calls_saved_per_map": [ + 38, + 40, + 40, + 38, + 40, + 40, + 38 + ], + "source_incidence_per_map": [ + 21, + 21, + 21, + 20, + 21, + 21, + 20 + ], + "source_multiplicity": [ + 4, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "star_complete_calls": 410, + "star_event_bits": 2000, + "star_source_calls": 290, + "star_source_calls_per_map": [ + 42, + 42, + 42, + 40, + 42, + 42, + 40 + ], + "support_size": 60, + "support_weight_counts": { + "1": 7, + "2": 21, + "3": 32 + }, + "target_calls_each_program": 120 + }, + "fallback_search": { + "best": { + "covered_masks": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 16, + 17, + 18, + 19, + 20, + 21, + 22, + 24, + 25, + 26, + 28, + 32, + 33, + 34, + 35, + 36, + 37, + 38, + 40, + 41, + 42, + 48, + 49, + 50, + 52, + 56, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 72, + 74, + 76, + 80, + 81, + 84, + 88, + 96, + 97, + 98, + 100, + 104, + 112 + ], + "missing_masks": [ + 44, + 73, + 82 + ], + "prefix_states": [ + 0, + 1, + 3, + 7, + 6, + 14, + 12, + 28, + 20, + 21, + 53, + 37, + 36, + 100, + 68, + 64, + 0 + ], + "readout_boundary_pairs": { + "1": [ + 0, + 1 + ], + "10": [ + 4, + 6 + ], + "100": [ + 0, + 13 + ], + "104": [ + 6, + 13 + ], + "11": [ + 3, + 6 + ], + "112": [ + 8, + 13 + ], + "12": [ + 0, + 6 + ], + "13": [ + 1, + 6 + ], + "14": [ + 0, + 5 + ], + "16": [ + 6, + 7 + ], + "17": [ + 10, + 12 + ], + "18": [ + 3, + 9 + ], + "19": [ + 3, + 8 + ], + "2": [ + 1, + 2 + ], + "20": [ + 0, + 8 + ], + "21": [ + 0, + 9 + ], + "22": [ + 2, + 9 + ], + "24": [ + 6, + 8 + ], + "25": [ + 6, + 9 + ], + "26": [ + 4, + 7 + ], + "28": [ + 0, + 7 + ], + "3": [ + 0, + 2 + ], + "32": [ + 9, + 10 + ], + "33": [ + 8, + 10 + ], + "34": [ + 3, + 11 + ], + "35": [ + 3, + 12 + ], + "36": [ + 0, + 12 + ], + "37": [ + 0, + 11 + ], + "38": [ + 2, + 11 + ], + "4": [ + 2, + 3 + ], + "40": [ + 6, + 12 + ], + "41": [ + 6, + 11 + ], + "42": [ + 5, + 12 + ], + "48": [ + 8, + 12 + ], + "49": [ + 8, + 11 + ], + "5": [ + 2, + 4 + ], + "50": [ + 3, + 10 + ], + "52": [ + 1, + 10 + ], + "56": [ + 7, + 12 + ], + "6": [ + 0, + 4 + ], + "64": [ + 0, + 15 + ], + "65": [ + 1, + 15 + ], + "66": [ + 4, + 14 + ], + "67": [ + 2, + 15 + ], + "68": [ + 0, + 14 + ], + "69": [ + 1, + 14 + ], + "7": [ + 0, + 3 + ], + "70": [ + 4, + 15 + ], + "72": [ + 6, + 14 + ], + "74": [ + 5, + 14 + ], + "76": [ + 6, + 15 + ], + "8": [ + 4, + 5 + ], + "80": [ + 8, + 14 + ], + "81": [ + 9, + 14 + ], + "84": [ + 8, + 15 + ], + "88": [ + 7, + 14 + ], + "9": [ + 3, + 5 + ], + "96": [ + 12, + 14 + ], + "97": [ + 11, + 14 + ], + "98": [ + 4, + 13 + ] + }, + "word": [ + 0, + 1, + 2, + 0, + 3, + 1, + 4, + 3, + 0, + 5, + 4, + 0, + 6, + 5, + 2, + 6 + ] + }, + "complete": true, + "coverage_histogram": { + "18": 96, + "19": 208, + "20": 1144, + "21": 1832, + "22": 5024, + "23": 8732, + "24": 15280, + "25": 24172, + "26": 43192, + "27": 74376, + "28": 97000, + "29": 171352, + "30": 273736, + "31": 383784, + "32": 524320, + "33": 833972, + "34": 1014384, + "35": 1363912, + "36": 1442696, + "37": 1775336, + "38": 1727264, + "39": 1831604, + "40": 1632272, + "41": 1448420, + "42": 1210232, + "43": 935376, + "44": 685480, + "45": 530280, + "46": 336464, + "47": 219432, + "48": 129944, + "49": 82968, + "50": 44352, + "51": 23576, + "52": 11976, + "53": 8792, + "54": 2048, + "55": 2320, + "56": 1032, + "57": 208, + "58": 304, + "60": 8 + }, + "domain_size": 18918900, + "words_examined": 18918900 + }, + "insertion_search": { + "best": { + "covered_masks": [ + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 16, + 17, + 18, + 19, + 20, + 21, + 24, + 25, + 26, + 28, + 32, + 33, + 34, + 35, + 36, + 37, + 40, + 41, + 44, + 48, + 49, + 50, + 52, + 56, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 72, + 73, + 74, + 76, + 80, + 82, + 88, + 96, + 97, + 98, + 100, + 104, + 112 + ], + "extra_source": 0, + "missing_masks": [ + 22, + 38, + 42, + 81, + 84 + ], + "prefix_states": [ + 0, + 1, + 3, + 7, + 6, + 14, + 15, + 11, + 10, + 26, + 18, + 50, + 34, + 98, + 66, + 64, + 0 + ], + "readout_boundary_pairs": { + "1": [ + 0, + 1 + ], + "10": [ + 0, + 8 + ], + "100": [ + 4, + 13 + ], + "104": [ + 8, + 13 + ], + "11": [ + 0, + 7 + ], + "112": [ + 10, + 13 + ], + "12": [ + 2, + 6 + ], + "13": [ + 2, + 5 + ], + "14": [ + 0, + 5 + ], + "16": [ + 8, + 9 + ], + "17": [ + 2, + 10 + ], + "18": [ + 0, + 10 + ], + "19": [ + 1, + 10 + ], + "2": [ + 1, + 2 + ], + "20": [ + 4, + 10 + ], + "21": [ + 3, + 10 + ], + "24": [ + 8, + 10 + ], + "25": [ + 2, + 9 + ], + "26": [ + 0, + 9 + ], + "28": [ + 4, + 9 + ], + "3": [ + 0, + 2 + ], + "32": [ + 10, + 11 + ], + "33": [ + 2, + 12 + ], + "34": [ + 0, + 12 + ], + "35": [ + 1, + 12 + ], + "36": [ + 4, + 12 + ], + "37": [ + 3, + 12 + ], + "4": [ + 2, + 3 + ], + "40": [ + 8, + 12 + ], + "41": [ + 7, + 12 + ], + "44": [ + 5, + 12 + ], + "48": [ + 10, + 12 + ], + "49": [ + 2, + 11 + ], + "5": [ + 2, + 4 + ], + "50": [ + 0, + 11 + ], + "52": [ + 4, + 11 + ], + "56": [ + 8, + 11 + ], + "6": [ + 0, + 4 + ], + "64": [ + 0, + 15 + ], + "65": [ + 1, + 15 + ], + "66": [ + 0, + 14 + ], + "67": [ + 1, + 14 + ], + "68": [ + 4, + 14 + ], + "69": [ + 3, + 14 + ], + "7": [ + 0, + 3 + ], + "70": [ + 4, + 15 + ], + "72": [ + 8, + 14 + ], + "73": [ + 7, + 14 + ], + "74": [ + 8, + 15 + ], + "76": [ + 5, + 14 + ], + "8": [ + 2, + 7 + ], + "80": [ + 10, + 14 + ], + "82": [ + 10, + 15 + ], + "88": [ + 9, + 14 + ], + "9": [ + 2, + 8 + ], + "96": [ + 12, + 14 + ], + "97": [ + 2, + 13 + ], + "98": [ + 0, + 13 + ] + }, + "slots": [ + 5, + 6 + ], + "word": [ + 0, + 1, + 2, + 0, + 3, + 0, + 2, + 0, + 4, + 3, + 5, + 4, + 6, + 5, + 1, + 6 + ] + }, + "coverage_histogram": { + "50": 64, + "51": 181, + "52": 8, + "53": 126, + "55": 71, + "56": 212, + "57": 62, + "58": 116 + }, + "domain_size": 840, + "full_cover_hits": 0 + }, + "predecessor": { + "artifact_path": "research/seven-source-weight123-connector-seed7db30a/RESULT.json", + "artifact_sha256": "7e6ddf449de9c9a5c4a408346f9c172a48fcb1ae97075b055797a39fa91c1011", + "coverage_histogram": { + "18": 7, + "19": 14, + "20": 63, + "21": 85, + "22": 175, + "23": 294, + "24": 420, + "25": 644, + "26": 1022, + "27": 1659, + "28": 2179, + "29": 3626, + "30": 6041, + "31": 7749, + "32": 8988, + "33": 12817, + "34": 14042, + "35": 16074, + "36": 11977, + "37": 13307, + "38": 9513, + "39": 8421, + "40": 5411, + "41": 4039, + "42": 2520, + "43": 1729, + "44": 882, + "45": 763, + "46": 266, + "47": 266, + "49": 84, + "50": 28, + "51": 14, + "53": 14, + "56": 2 + }, + "head": "b4eab83755969d406edba9f25b7890e4db4c4931", + "maximum_missing_masks": [ + 22, + 38, + 41, + 42, + 73, + 81, + 84 + ], + "maximum_prefix_states": [ + 0, + 1, + 3, + 7, + 6, + 14, + 10, + 26, + 18, + 50, + 34, + 98, + 66, + 64, + 0 + ], + "maximum_target_coverage": 56, + "maximum_word": [ + 0, + 1, + 2, + 0, + 3, + 2, + 4, + 3, + 5, + 4, + 6, + 5, + 1, + 6 + ], + "schema_version": 1, + "status": "open PR; author-checked result, not merged into main", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2229" + }, + "result_type": "scoped_negative", + "schema_version": 1, + "target_masks": 63, + "target_weights": [ + 1, + 2, + 3 + ], + "whole_batch_142_call_analysis": { + "142_call_splits": [ + { + "excluded_by": "The complete 18,918,900-word census in this package has no full 63-mask cover; its maximum is 60.", + "profile": [ + 4, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "source_calls": 16, + "target_calls": 126 + }, + { + "excluded_by": "The 14-toggle census supports at most 56 masks by pairs, leaving at least seven unsupported. A single four-call A_M can serve at most one target, so at least six targets still lack a pair of prefix boundaries.", + "profile": "all seven B maps twice; one A_M four times and the other 62 A maps twice", + "source_calls": 14, + "target_calls": 128 + } + ], + "conclusion": "No full 63-mask schedule uses 140 or 142 complete map calls in this event alphabet. All call totals are even, hence any such full batch needs at least 144 complete map calls. No 144-call schedule is constructed or excluded here.", + "excluded_140_profile": "The 14-toggle all-two-source class has maximum prefix-difference coverage 56 of 63, so the all-targets-twice floor is impossible.", + "minimum_profile": { + "source_calls": 14, + "target_calls": 126, + "total": 140 + }, + "per_map_call_parity": "Each active B_j and each required A_M must be called an even positive number of times, because its independent dirty/source contribution must cancel.", + "scope": "Original one-root F2 source-toggle and single-target A-map event alphabet; arbitrary dirty source and target rows." + } +} diff --git a/research/seven-source-16event-connector-seeda7de5e/SOURCES.json b/research/seven-source-16event-connector-seeda7de5e/SOURCES.json new file mode 100644 index 0000000000..5b484dafcf --- /dev/null +++ b/research/seven-source-16event-connector-seeda7de5e/SOURCES.json @@ -0,0 +1,48 @@ +{ + "schema_version": 1, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "files": [ + { + "path": "certificates/selected-result.json", + "usage": "input", + "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11", + "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + { + "path": "research/universal-connector-boundary/CERTIFICATE.json", + "usage": "input", + "git_blob": "079e3e1441dc07c2f0536e9527acf290e51ea9c0", + "sha256": "e733746ba3e5151c829b4e8728bfff5ae3ed24d8d203eb77c735d20758e8266a" + }, + { + "path": "research/universal-connector-boundary/README.md", + "usage": "input", + "git_blob": "d277f7c5830b1f2bc42e1ff41ab86e7d7564929f", + "sha256": "23415f7829ab8d80a783142f10f7d31abbce84579362769984680af3df954476" + }, + { + "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": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "usage": "provenance", + "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8", + "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b" + }, + { + "path": "research/community-frontier1094-audit/ASSEMBLY.json", + "usage": "provenance", + "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0", + "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + } + ] +} diff --git a/research/seven-source-16event-connector-seeda7de5e/TASK.json b/research/seven-source-16event-connector-seeda7de5e/TASK.json new file mode 100644 index 0000000000..4cc8f7fe55 --- /dev/null +++ b/research/seven-source-16event-connector-seeda7de5e/TASK.json @@ -0,0 +1,298 @@ +{ + "schema_version": 1, + "cycle": 28, + "task_id": "connector-alphabet-change", + "scope_status": "changed", + "scope_change_reason": "The selected card asks for a new connector operation. This experiment retains the original one-root F2 connector and changes the source multiplicity from two toggles per source to one source toggled four times and six toggled twice. It tests the next possible even source-call count after the exact 140-call floor exclusion and targets the complete 63-mask sparse family. The first bounded construction is a two-boundary insertion of one restored toggle pair into the pinned 14-toggle maximum witness; if that surgery fails, one exact pivot covers the full normalized 16-event class.", + "actual_scope": "Determine whether inserting one extra pair of the same source toggle at any two boundaries of the pinned seven-source 14-toggle maximum witness yields prefix differences covering every mask of weight 1, 2, or 3; if no insertion works, exhaust all normalized 16-event words with multiplicities (4,2,2,2,2,2,2). Combined with the independently replayed 14-toggle predecessor census, derive that no full 63-mask schedule can use 140 or 142 complete map calls in the original one-root, single-target event alphabet; the lower bound is 144, with no 144-call construction claimed.", + "selection": { + "seed": "a7de5e16e6ab896abb6ef4a0dc88a174", + "track": "recursive-interfaces", + "task_id": "connector-alphabet-change", + "selector_scope_key": "0c9f43f3c7d61edb36fe", + "refined_scope_key": "778d279ecd9a5bb9118d", + "priority_revision": 4, + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "excluded_draws": [ + { + "seed": "8fa4c33aff8c9683496a1d06e701220b", + "track": "consolidation", + "reason": "Excluded construction-ineligible track; selector rerun once." + } + ] + }, + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "budget_minutes": 60, + "coordination": "https://github.com/CrocSwap/integer-mult-bounds/discussions/2221", + "claim_expiry_utc": "2026-10-15T03:00:00Z", + "question": "Can one additional restored source-toggle pair extend a seven-source, one-root F2 connector path from the excluded 140-call floor to a 142-complete-call schedule realizing all 63 output masks of weights 1, 2, and 3?", + "method": "Enumerate the 840 schedules obtained by selecting one source j in {0,...,6} and two insertion slots p<=q among the 15 boundaries of the pinned 14-toggle maximum word. Test the exact prefix-difference set against all 63 masks. If no insertion succeeds, use one bounded pivot: exhaust all 18,918,900 canonical multiset words with one label four times and six labels twice, stopping at the first full-cover word or after complete coverage. Independently replay a witness and every output boundary pair.", + "search_domain": { + "first_stage": "7 * C(16,2) = 840 pair insertions into the 14-toggle witness, with two insertions at one slot allowed.", + "fallback": "16!/(4! (2!)^6 6!) = 18,918,900 normalized words of multiplicities (4,2,2,2,2,2,2), source-label permutations quotiented.", + "stop_rule": "Stop at the first exact full-cover construction; if the 840 local surgeries miss, exhaust the fallback class. Never generalize a miss outside the tested domain." + }, + "optimistic_full_cost": { + "target_maps": 63, + "target_complete_calls": 126, + "shared_source_multiplicity": [ + 4, + 2, + 2, + 2, + 2, + 2, + 2 + ], + "shared_source_calls": 16, + "independent_star_source_calls": 308, + "shared_complete_calls": 142, + "star_complete_calls": 434, + "source_calls_saved": 292, + "descriptor_encoding": "One opcode bit plus a 3-bit source-map ID for B calls or a 6-bit output-map ID for A calls; event order gives boundary placement.", + "shared_descriptor_bits": 946, + "star_descriptor_bits": 2114, + "descriptor_bits_saved": 1168, + "invoice_shared": "I + P + 4*c(B0) + 2*sum_{j=1..6}c(Bj) + 2*sum_{M}c(A_M) + 946*lambda + 142*delta", + "invoice_stars": "I + P + 44*sum_{j=0..6}c(Bj) + 2*sum_{M}c(A_M) + 2114*lambda + 434*delta", + "difference": "-40*c(B0) - 42*sum_{j=1..6}c(Bj) - 1168*lambda - 292*delta", + "complete_call_scope": "Each c(B) and c(A) includes source/target access, arithmetic, target updates, private scratch restoration, hosting, and head return. Input admission I and coefficient preparation P are common and cancel. The static event order includes map IDs and boundary placement; no search table or frame change is charged separately.", + "other_constraints": "This is a connector-level screen only. It does not place a supplier in the selected assembly; the selected record remains complex-bound, so no kappa improvement is claimed." + }, + "predecessors": [ + { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2229", + "head": "b4eab83755969d406edba9f25b7890e4db4c4931", + "scope": "Author-checked 14-toggle all-two-occurrence exact census: maximum 56/63, zero full covers; maximum word is the source path being extended. This is an open PR, not merged main evidence.", + "artifact": "research/seven-source-weight123-connector-seed7db30a/RESULT.json", + "sha256": "7e6ddf449de9c9a5c4a408346f9c172a48fcb1ae97075b055797a39fa91c1011" + }, + { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/943", + "head": "cf360b4b09b7d0419decdd6ac85421fefed55bdd", + "scope": "Dirty connector contract and paired-prefix-difference identity." + }, + { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/934", + "head": "f3100aec6ce6a7b061987875d5e9a8b93801ac0b", + "scope": "Connector query framework." + } + ], + "overlap": { + "searched_at": "2026-10-15T01:24:18.708198+00:00", + "open_prs": { + "complete_pagination": true, + "fetched_at": "2026-10-15T01:21:34.090492+00:00", + "records": 470 + }, + "discussions": { + "complete_pagination": true, + "fetched_at": "2026-10-15T01:24:18.533225+00:00", + "records": 931 + }, + "warnings": [], + "nearest": [ + { + "pr": 2128, + "head": "697369a971eed02c0fbcd75ebefec9f59945f08e", + "scope": "Six-source universal path with pair-source DUO calls." + }, + { + "pr": 2146, + "head": "302b0e87d9328fabc2a670248afb357bbb44041b", + "scope": "Six-source one-TRIO exact exclusion." + }, + { + "pr": 2229, + "head": "b4eab83755969d406edba9f25b7890e4db4c4931", + "scope": "Open predecessor: exact seven-source 14-toggle path class; this result changes source multiplicity to (4,2,2,2,2,2,2)." + }, + { + "discussion": 2221, + "scope": "Own active Cycle28 claim, updated with result and released at handoff." + } + ], + "limits": "Open PRs include drafts; complete PR and Discussion pagination. The scan did not find an external matching 16-event seven-source claim. The predecessor PR #2229 is still open and was rechecked directly. Overlap search is a lead, not a novelty certificate." + }, + "source_hashes": { + "certificates/selected-result.json": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "research/universal-connector-boundary/CERTIFICATE.json": "e733746ba3e5151c829b4e8728bfff5ae3ed24d8d203eb77c735d20758e8266a", + "research/universal-connector-boundary/README.md": "23415f7829ab8d80a783142f10f7d31abbce84579362769984680af3df954476", + "research/community-frontier1094-audit/SELECTED-SOURCE.json": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b", + "research/community-frontier1094-audit/ASSEMBLY.json": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045" + }, + "status": "verified", + "attribution": "Prepared by Cinna Davis with substantial OpenAI Codex assistance in scope selection, proof derivation, exact search and verification.", + "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" + ] + }, + "selected_record_binding": { + "status": "Maintainer-reviewed conditional finite construction; selected record remains complex-bound.", + "review": "docs/research/community-batch1099-review.md", + "source_manifest": "research/community-frontier1094-audit/SELECTED-SOURCE.json", + "certificate": "research/community-frontier1094-audit/ASSEMBLY.json", + "certificate_sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045", + "reproduce": "make frontier1094-verify", + "baseline_check": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY; selected files unchanged, so full replay is not rerun." + }, + "stage_one_result": { + "domain_size": 840, + "full_cover_hits": 0, + "maximum_coverage": 58, + "best_source": 0, + "best_insertion_slots": [ + 5, + 6 + ], + "best_word": [ + 0, + 1, + 2, + 0, + 3, + 0, + 2, + 0, + 4, + 3, + 5, + 4, + 6, + 5, + 1, + 6 + ], + "best_prefix_states": [ + 0, + 1, + 3, + 7, + 6, + 14, + 15, + 11, + 10, + 26, + 18, + 50, + 34, + 98, + 66, + 64, + 0 + ], + "best_missing_masks": [ + 22, + 38, + 42, + 81, + 84 + ] + }, + "stage_two_result": "Completed exact enumeration of all 18,918,900 normalized multiplicity-(4,2,2,2,2,2,2) source words. Zero full covers; maximum coverage 60, attained by eight canonical words. The best witness gives a 60-output positive construction at 136 complete map calls, 274 fewer source calls than independent stars. Together with the 14-toggle predecessor census, both 140- and 142-call full-family profiles are excluded in the stated event alphabet.", + "outcome": "completed", + "evidence": "Final search replay: SEVEN_SOURCE_16EVENT_SEARCH insertions=840 insertion_hits=0 fallback_examined=18918900 fallback_complete=true full_cover=0 best=60. Independent verifier: PASS_SEVEN_SOURCE_16EVENT_BOUND old_domain=135135 old_max=56 new_domain=18918900 new_max=60 full_hits=0 max_words=8 outputs=60 calls=136 savings=274 controls=4. Original connector positive control: PASS_UNIVERSAL_CONNECTOR_BOUNDARY pairings=945 max_coverage=31 queries=74 leaves=182. Package metadata/pins and git diff checks pass.", + "stop_rule": "Stop after the first exact full cover or after all 18,918,900 normalized words. Completed the entire domain with no cover; do not extend the result to other source multiplicities or longer paths.", + "open_questions": [ + { + "question": "Can a full 63-mask schedule attain 144 complete calls using a source-toggle profile with 18 calls, or with a 16-call source path plus extra output readouts?", + "why_it_matters": "The current exact lower bound is 144. A construction at that floor would close the first remaining call-count profile and preserve most of the 434-call independent-star saving.", + "first_step": "Enumerate the smallest 144-call profiles: (6,2,2,2,2,2,2) and (4,4,2,2,2,2,2) source toggles with 126 paired target calls; separately derive bounds for source-16/output-128 and source-14/output-130 splits.", + "blocked_by": "The 16-event class is fully excluded, but profiles with 18 source toggles or extra A_M calls have not been searched. No selected-supplier caller or kappa transfer is established." + } + ], + "result_summary": { + "domain16": 18918900, + "examined16": 18918900, + "full_cover_count16": 0, + "maximum_coverage16": 60, + "maximum_word_count16": 8, + "best_word": [ + 0, + 1, + 2, + 0, + 3, + 1, + 4, + 3, + 0, + 5, + 4, + 0, + 6, + 5, + 2, + 6 + ], + "best_missing_masks": [ + 44, + 73, + 82 + ], + "subset_calls": { + "star": 410, + "shared": 136, + "saved": 274, + "star_event_bits": 2000, + "shared_event_bits": 904, + "event_bits_saved": 1096 + }, + "full_batch_lower_bound_calls": 144, + "no_144_call_upper_bound": true + }, + "bottleneck_link": "If it can be admitted by a recursive supplier, source-path sharing reduces connector children for a sparse output batch. This package charges the complete local interface and states explicitly that no selected supplier or kappa transfer is established.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, proof derivation, exact search implementation, independent verifier, exact cost accounting, overlap checks and writing. No independent human review or proof-assistant formalization is claimed.", + "outcome_summary": "Scoped negative for the 16-source-call full-mask class, plus a 60-output construction and a source-pinned lower bound of at least 144 complete map calls for the full 63-mask batch in the original one-root event alphabet.", + "claim_status": "will be released after publication and handoff", + "verification": { + "python": "CPython 3.14.7", + "search": "PASS; 840 pair insertions and all 18,918,900 normalized 16-event words.", + "independent_verifier": "PASS; independent restricted-growth enumerations for the 14- and 16-event domains, exact histograms, arbitrary dirty maps in dimensions 1-3 and four negative controls.", + "connector_control": "PASS_UNIVERSAL_CONNECTOR_BOUNDARY pairings=945 max_coverage=31 queries=74 leaves=182.", + "package_check": "PASS_PACKAGE_METADATA_AND_PINS (metadata only).", + "python_3_12_replay": "Not run; Python 3.12 unavailable in environment.", + "selected_cold_replay": "make frontier1094-verify not rerun; selected source, certificate and assembly are unchanged." + }, + "remaining_obligations": [ + "No construction or exclusion at 144 complete map calls; other source multiplicities and extra A-map readouts remain outside this search.", + "No selected-supplier placement, supplier admission or kappa change is established.", + "No independent human review or proof-assistant formalization is claimed." + ] +} diff --git a/research/seven-source-16event-connector-seeda7de5e/VERIFY.json b/research/seven-source-16event-connector-seeda7de5e/VERIFY.json new file mode 100644 index 0000000000..982f0314e7 --- /dev/null +++ b/research/seven-source-16event-connector-seeda7de5e/VERIFY.json @@ -0,0 +1,33 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "research/universal-connector-boundary/CERTIFICATE.json", + "research/universal-connector-boundary/README.md" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/search.py" + ], + "checks": "Exact 840 pair insertions followed, if needed, by the complete 18,918,900-word normalized multiplicity-(4,2,2,2,2,2,2) census; deterministic RESULT.json.", + "timeout_seconds": 600 + }, + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "checks": "Independent restricted-growth enumerations of the 14- and 16-event domains; exact histograms, maximum and no-full-cover results; 60-output dirty-state replay in dimensions 1-3; four failure controls.", + "timeout_seconds": 600 + } + ] +} diff --git a/research/seven-source-16event-connector-seeda7de5e/search.py b/research/seven-source-16event-connector-seeda7de5e/search.py new file mode 100644 index 0000000000..f0c18aacfa --- /dev/null +++ b/research/seven-source-16event-connector-seeda7de5e/search.py @@ -0,0 +1,288 @@ +#!/usr/bin/env python3 +"""Search one-pair interval extensions, then the normalized 16-event class.""" + +from collections import Counter +from itertools import combinations +import json +from pathlib import Path + + +HERE = Path(__file__).resolve().parent +N = 7 +LENGTH = 16 +TARGETS = tuple(m for m in range(1, 1 << N) if m.bit_count() in (1, 2, 3)) +TARGET_SET = set(TARGETS) +DOMAIN_SIZE = 18_918_900 + + +def prefixes(word): + q = [0] + for label in word: + q.append(q[-1] ^ (1 << label)) + return q + + +def differences(q): + return {q[i] ^ q[j] for i in range(len(q)) for j in range(i + 1, len(q))} + + +def coverage(q): + return TARGET_SET.intersection(differences(q)) + + +def readout_pairs(q, masks): + result = {} + for mask in sorted(masks, key=lambda m: (m.bit_count(), m)): + for i in range(len(q)): + for j in range(i + 1, len(q)): + if q[i] ^ q[j] == mask: + result[str(mask)] = [i, j] + break + if str(mask) in result: + break + return result + + +def insert_pair(word, label, p, q): + """Insert two label toggles at slots p<=q among 15 original boundaries.""" + out = [] + for slot in range(len(word) + 1): + if slot == p: + out.append(label) + if p == q: + out.append(label) + if slot == q and q != p: + out.append(label) + if slot < len(word): + out.append(word[slot]) + return tuple(out) + + +def insertions(word): + for label in range(N): + for p in range(len(word) + 1): + for q in range(p, len(word) + 1): + yield label, p, q, insert_pair(word, label, p, q) + + +def canonical_words(): + """One word per orbit with one four-use label and six pair labels.""" + word = [None] * LENGTH + for heavy in combinations(range(LENGTH), 4): + heavy_mask = 0 + for position in heavy: + word[position] = 0 + heavy_mask |= 1 << position + + def pair_remaining(remaining, next_label): + if remaining == 0: + yield tuple(word) + return + first_bit = remaining & -remaining + first = first_bit.bit_length() - 1 + rest = remaining ^ first_bit + choices = rest + while choices: + bit = choices & -choices + other = bit.bit_length() - 1 + choices ^= bit + word[first] = word[other] = next_label + yield from pair_remaining(rest ^ bit, next_label + 1) + + yield from pair_remaining(((1 << LENGTH) - 1) ^ heavy_mask, 1) + + +def word_record(word, q, masks): + return { + "word": list(word), + "prefix_states": list(q), + "covered_masks": sorted(masks), + "missing_masks": sorted(TARGET_SET - set(masks)), + "readout_boundary_pairs": readout_pairs(q, masks), + } + + +def main(): + predecessor = json.loads((HERE / "PREDECESSOR.json").read_text(encoding="utf-8")) + task = json.loads((HERE / "TASK.json").read_text(encoding="utf-8")) + expected = task["predecessors"][0] + if predecessor["head"] != expected["head"] or predecessor["artifact_sha256"] != expected["sha256"]: + raise SystemExit("predecessor pin mismatch") + base_word = tuple(predecessor["maximum_word"]) + if prefixes(base_word) != predecessor["maximum_prefix_states"]: + raise SystemExit("predecessor prefix receipt mismatch") + + insertion_histogram = Counter() + insertion_best = None + insertion_cases = 0 + for label, p, q_slot, word in insertions(base_word): + insertion_cases += 1 + prefix = prefixes(word) + masks = coverage(prefix) + insertion_histogram[len(masks)] += 1 + if insertion_best is None or len(masks) > len(insertion_best["covered_masks"]): + insertion_best = { + "extra_source": label, + "slots": [p, q_slot], + **word_record(word, prefix, masks), + } + if masks == TARGET_SET: + result = { + "schema_version": 1, + "result_type": "construction", + "target_masks": len(TARGETS), + "target_weights": [1, 2, 3], + "predecessor": predecessor, + "insertion_search": { + "domain_size": insertion_cases, + "full_cover_hits": 1, + "coverage_histogram": {str(k): insertion_histogram[k] for k in sorted(insertion_histogram)}, + "best": insertion_best, + }, + "fallback_search": {"domain_size": DOMAIN_SIZE, "words_examined": 0, "complete": False}, + "construction": { + **word_record(word, prefix, masks), + "source_multiplicity": [word.count(j) for j in range(N)], + "source_calls": LENGTH, + "target_calls": 2 * len(TARGETS), + "complete_calls": LENGTH + 2 * len(TARGETS), + }, + } + write_result(result) + print(f"SEVEN_SOURCE_16EVENT_SEARCH insertions={insertion_cases} insertion_hits=1 fallback=not_needed calls=142 masks=63") + print("word=" + " ".join(map(str, word))) + return + + if insertion_cases != 840: + raise SystemExit(f"internal insertion-domain error: {insertion_cases}") + + fallback_histogram = Counter() + fallback_best = None + fallback_examined = 0 + for word in canonical_words(): + fallback_examined += 1 + prefix = prefixes(word) + masks = coverage(prefix) + fallback_histogram[len(masks)] += 1 + if fallback_best is None or len(masks) > len(fallback_best["covered_masks"]): + fallback_best = word_record(word, prefix, masks) + if masks == TARGET_SET: + result = { + "schema_version": 1, + "result_type": "construction", + "target_masks": len(TARGETS), + "target_weights": [1, 2, 3], + "predecessor": predecessor, + "insertion_search": { + "domain_size": insertion_cases, + "full_cover_hits": 0, + "coverage_histogram": {str(k): insertion_histogram[k] for k in sorted(insertion_histogram)}, + "best": insertion_best, + }, + "fallback_search": { + "domain_size": DOMAIN_SIZE, + "words_examined": fallback_examined, + "complete": False, + "coverage_histogram_prefix": {str(k): fallback_histogram[k] for k in sorted(fallback_histogram)}, + }, + "construction": { + **word_record(word, prefix, masks), + "source_multiplicity": [word.count(j) for j in range(N)], + "source_calls": LENGTH, + "target_calls": 2 * len(TARGETS), + "complete_calls": LENGTH + 2 * len(TARGETS), + }, + } + write_result(result) + print(f"SEVEN_SOURCE_16EVENT_SEARCH insertions=840 insertion_hits=0 fallback_examined={fallback_examined} fallback_complete=false calls=142 masks=63") + print("word=" + " ".join(map(str, word))) + return + + if fallback_examined != DOMAIN_SIZE: + raise SystemExit(f"internal fallback-domain error: {fallback_examined}") + result = { + "schema_version": 1, + "result_type": "scoped_negative", + "target_masks": len(TARGETS), + "target_weights": [1, 2, 3], + "predecessor": predecessor, + "insertion_search": { + "domain_size": insertion_cases, + "full_cover_hits": 0, + "coverage_histogram": {str(k): insertion_histogram[k] for k in sorted(insertion_histogram)}, + "best": insertion_best, + }, + "fallback_search": { + "domain_size": DOMAIN_SIZE, + "words_examined": fallback_examined, + "complete": True, + "coverage_histogram": {str(k): fallback_histogram[k] for k in sorted(fallback_histogram)}, + "best": fallback_best, + }, + } + write_result(result) + print(f"SEVEN_SOURCE_16EVENT_SEARCH insertions=840 insertion_hits=0 fallback_examined={fallback_examined} fallback_complete=true full_cover=0 best={len(fallback_best['covered_masks'])}") + + +def write_result(result): + best = result.get("fallback_search", {}).get("best") + if best is not None: + support = best["covered_masks"] + incidence = [sum((mask >> j) & 1 for mask in support) for j in range(N)] + multiplicity = [best["word"].count(j) for j in range(N)] + star_source_calls = [2 * value for value in incidence] + saved_by_source = [star_source_calls[j] - multiplicity[j] for j in range(N)] + star_b = sum(star_source_calls) + shared_b = sum(multiplicity) + target_calls = 2 * len(support) + result["attained_subset_cost"] = { + "support_size": len(support), + "support_weight_counts": { + str(w): sum(mask.bit_count() == w for mask in support) + for w in (1, 2, 3) + }, + "source_incidence_per_map": incidence, + "source_multiplicity": multiplicity, + "star_source_calls_per_map": star_source_calls, + "source_calls_saved_per_map": saved_by_source, + "star_source_calls": star_b, + "shared_source_calls": shared_b, + "target_calls_each_program": target_calls, + "star_complete_calls": star_b + target_calls, + "shared_complete_calls": shared_b + target_calls, + "complete_calls_saved": star_b - shared_b, + "star_event_bits": 4 * star_b + 7 * target_calls, + "shared_event_bits": 4 * shared_b + 7 * target_calls, + "event_bits_saved": 4 * (star_b - shared_b), + "root_dispatches_saved": star_b - shared_b, + "invoice_difference": "-sum_j source_calls_saved_per_map[j]*c(B_j) - event_bits_saved*lambda - root_dispatches_saved*delta", + "charges": "Every complete B and A call is paid, including source/target access, arithmetic, writes, hosting, private scratch restoration and head return. Shared input admission and coefficient preparation cancel. The static event order encodes map identifiers and boundaries.", + } + + if result.get("result_type") == "scoped_negative": + result["whole_batch_142_call_analysis"] = { + "scope": "Original one-root F2 source-toggle and single-target A-map event alphabet; arbitrary dirty source and target rows.", + "per_map_call_parity": "Each active B_j and each required A_M must be called an even positive number of times, because its independent dirty/source contribution must cancel.", + "minimum_profile": {"source_calls": 14, "target_calls": 126, "total": 140}, + "excluded_140_profile": "The 14-toggle all-two-source class has maximum prefix-difference coverage 56 of 63, so the all-targets-twice floor is impossible.", + "142_call_splits": [ + { + "source_calls": 16, + "target_calls": 126, + "profile": [4, 2, 2, 2, 2, 2, 2], + "excluded_by": "The complete 18,918,900-word census in this package has no full 63-mask cover; its maximum is 60." + }, + { + "source_calls": 14, + "target_calls": 128, + "profile": "all seven B maps twice; one A_M four times and the other 62 A maps twice", + "excluded_by": "The 14-toggle census supports at most 56 masks by pairs, leaving at least seven unsupported. A single four-call A_M can serve at most one target, so at least six targets still lack a pair of prefix boundaries." + } + ], + "conclusion": "No full 63-mask schedule uses 140 or 142 complete map calls in this event alphabet. All call totals are even, hence any such full batch needs at least 144 complete map calls. No 144-call schedule is constructed or excluded here." + } + (HERE / "RESULT.json").write_text(json.dumps(result, indent=2, sort_keys=True) + "\n", encoding="utf-8") + + +if __name__ == "__main__": + main() diff --git a/research/seven-source-16event-connector-seeda7de5e/verify.py b/research/seven-source-16event-connector-seeda7de5e/verify.py new file mode 100644 index 0000000000..6084523429 --- /dev/null +++ b/research/seven-source-16event-connector-seeda7de5e/verify.py @@ -0,0 +1,277 @@ +#!/usr/bin/env python3 +"""Independently verify the 14- and 16-event prefix-difference censuses.""" + +from collections import Counter +from itertools import combinations +import json +from pathlib import Path +import random +import sys + + +HERE = Path(__file__).resolve().parent +N = 7 +TARGETS = tuple(m for m in range(1, 1 << N) if m.bit_count() in (1, 2, 3)) +TARGET_BITS = sum(1 << mask for mask in TARGETS) +DOMAIN14 = 135_135 +DOMAIN16 = 18_918_900 + + +def require(condition, message): + if not condition: + raise SystemExit("FAIL_SEVEN_SOURCE_16EVENT_BOUND: " + message) + + +def prefix_states(word): + states = [0] + for label in word: + states.append(states[-1] ^ (1 << label)) + return states + + +def difference_bits(states): + bits = 0 + for i, left in enumerate(states): + for j in range(i + 1, len(states)): + bits |= 1 << (left ^ states[j]) + return bits + + +def support_from_bits(bits): + return {mask for mask in TARGETS if (bits >> mask) & 1} + + +def canonical14_words(): + """Restricted-growth labels, independently of the pairing generator.""" + remaining = [2] * N + word = [0] * (2 * N) + + def visit(position, seen): + if position == len(word): + yield tuple(word) + return + for label in range(seen): + if remaining[label] == 0: + continue + remaining[label] -= 1 + word[position] = label + yield from visit(position + 1, seen) + remaining[label] += 1 + if seen < N: + label = seen + remaining[label] -= 1 + word[position] = label + yield from visit(position + 1, seen + 1) + remaining[label] += 1 + + yield from visit(0, 0) + + +def canonical16_words(): + """Restricted-growth labels for six pair sources plus a distinguished four-use source.""" + remaining = [4] + [2] * (N - 1) + word = [0] * 16 + + def visit(position, seen_pairs): + if position == len(word): + yield tuple(word) + return + if remaining[0]: + remaining[0] -= 1 + word[position] = 0 + yield from visit(position + 1, seen_pairs) + remaining[0] += 1 + for label in range(1, seen_pairs + 1): + if remaining[label] == 0: + continue + remaining[label] -= 1 + word[position] = label + yield from visit(position + 1, seen_pairs) + remaining[label] += 1 + if seen_pairs < N - 1: + label = seen_pairs + 1 + remaining[label] -= 1 + word[position] = label + yield from visit(position + 1, seen_pairs + 1) + remaining[label] += 1 + + yield from visit(0, 0) + + +def insert_pair(word, label, p, q): + result = [] + for boundary in range(len(word) + 1): + if boundary == p: + result.append(label) + if boundary == q: + result.append(label) + if boundary < len(word): + result.append(word[boundary]) + return tuple(result) + + +def valid_source_word(word, multiplicity): + return len(word) == sum(multiplicity) and [word.count(j) for j in range(N)] == list(multiplicity) + + +def readout_pairs(states, support): + result = {} + for mask in sorted(support): + for i, left in enumerate(states): + for j in range(i + 1, len(states)): + if left ^ states[j] == mask: + result[str(mask)] = [i, j] + break + if str(mask) in result: + break + return result + + +def mat_apply(rows, vector): + output = 0 + for bit, row in enumerate(rows): + if (row & vector).bit_count() & 1: + output |= 1 << bit + return output + + +def simulate_construction(word, states, pairs, support): + for dimension in (1, 2, 3): + rng = random.Random(0x16E7 + dimension) + b_maps = [[rng.randrange(1 << dimension) for _ in range(dimension)] for _ in range(N)] + inputs = [rng.randrange(1 << dimension) for _ in range(N)] + source_terms = [mat_apply(b_maps[j], inputs[j]) for j in range(N)] + dirty_connector = rng.randrange(1 << dimension) + for mask in support: + start, stop = pairs[str(mask)] + dirty_target = rng.randrange(1 << dimension) + a_map = [rng.randrange(1 << dimension) for _ in range(dimension)] + z_start = dirty_connector + z_stop = dirty_connector + for j in range(N): + if (states[start] >> j) & 1: + z_start ^= source_terms[j] + if (states[stop] >> j) & 1: + z_stop ^= source_terms[j] + actual = dirty_target ^ mat_apply(a_map, z_start) ^ mat_apply(a_map, z_stop) + target_input = 0 + for j in range(N): + if (mask >> j) & 1: + target_input ^= source_terms[j] + expected = dirty_target ^ mat_apply(a_map, target_input) + require(actual == expected, f"dirty-state simulation failed at dimension {dimension}, mask {mask}") + require(states[-1] == 0, "source connector was not restored") + + +def main(): + task = json.loads((HERE / "TASK.json").read_text(encoding="utf-8")) + predecessor = json.loads((HERE / "PREDECESSOR.json").read_text(encoding="utf-8")) + result = json.loads((HERE / "RESULT.json").read_text(encoding="utf-8")) + pin = task["predecessors"][0] + require(predecessor["head"] == pin["head"] and predecessor["artifact_sha256"] == pin["sha256"], "predecessor source pin mismatch") + + # Independent 14-event positive control: restricted-growth enumeration. + old_hist = Counter() + old_count = 0 + old_full = 0 + for word in canonical14_words(): + old_count += 1 + states = prefix_states(word) + bits = difference_bits(states) + support_bits = bits & TARGET_BITS + score = support_bits.bit_count() + old_hist[score] += 1 + old_full += score == len(TARGETS) + expected_old_hist = {int(k): v for k, v in predecessor["coverage_histogram"].items()} + require(old_count == DOMAIN14, f"14-event domain count {old_count}") + require(dict(old_hist) == expected_old_hist, "14-event histogram differs from pinned predecessor receipt") + require(old_full == 0 and max(old_hist) == 56 and old_hist[56] == 2, "14-event positive control boundary mismatch") + old_word = tuple(predecessor["maximum_word"]) + old_states = prefix_states(old_word) + require(old_states == predecessor["maximum_prefix_states"], "pinned 14-event prefix states are inconsistent") + require(len(support_from_bits(difference_bits(old_states))) == 56, "pinned 14-event witness does not cover 56 masks") + + # Recheck the complete 840-case insertion family using a separate boundary builder. + stage_hist = Counter() + stage_count = stage_full = 0 + stage_best = None + for label in range(N): + for p in range(15): + for q in range(p, 15): + word = insert_pair(old_word, label, p, q) + states = prefix_states(word) + support = support_from_bits(difference_bits(states)) + stage_count += 1 + stage_hist[len(support)] += 1 + stage_full += len(support) == len(TARGETS) + if stage_best is None or len(support) > len(stage_best["support"]): + stage_best = {"label": label, "slots": [p, q], "word": word, "states": states, "support": support} + recorded_stage = result["insertion_search"] + require(stage_count == 840 and stage_full == recorded_stage["full_cover_hits"] == 0, "insertion full-cover count mismatch") + require(dict(stage_hist) == {int(k): v for k, v in recorded_stage["coverage_histogram"].items()}, "insertion histogram mismatch") + require(len(stage_best["support"]) == 58, "insertion best score mismatch") + + # Independent 16-event exact census with canonical restricted-growth words and bitset coverage. + histogram = Counter() + count = full_hits = 0 + for word in canonical16_words(): + count += 1 + states = prefix_states(word) + support_bits = difference_bits(states) & TARGET_BITS + score = support_bits.bit_count() + histogram[score] += 1 + full_hits += score == len(TARGETS) + if count % 2_000_000 == 0: + print(f"VERIFY_PROGRESS words={count}", flush=True) + recorded = result["fallback_search"] + require(count == DOMAIN16 == recorded["domain_size"] == recorded["words_examined"], "16-event domain count mismatch") + require(dict(histogram) == {int(k): v for k, v in recorded["coverage_histogram"].items()}, "16-event histogram mismatch") + require(full_hits == 0 and max(histogram) == 60 and histogram[60] == 8, "16-event maximum/full-cover boundary mismatch") + require(sum(histogram.values()) == DOMAIN16, "16-event histogram total mismatch") + + best = recorded["best"] + best_word = tuple(best["word"]) + best_states = prefix_states(best_word) + best_support = support_from_bits(difference_bits(best_states)) + require(valid_source_word(best_word, [4, 2, 2, 2, 2, 2, 2]), "best 16-event word has wrong multiplicities") + require(best_states == best["prefix_states"], "best 16-event prefix receipt mismatch") + require(best_support == set(best["covered_masks"]), "best 16-event support receipt mismatch") + require(sorted(TARGET_SET - best_support) == best["missing_masks"], "best 16-event missing-mask receipt mismatch") + require(len(best_support) == 60 and best["missing_masks"] == [44, 73, 82], "best witness support boundary mismatch") + pairs = best["readout_boundary_pairs"] + require(set(map(int, pairs)) == best_support, "best witness readout pair inventory mismatch") + for mask, pair in pairs.items(): + i, j = pair + require(0 <= i < j < len(best_states) and best_states[i] ^ best_states[j] == int(mask), f"bad boundary pair for mask {mask}") + simulate_construction(best_word, best_states, pairs, best_support) + + cost = result["attained_subset_cost"] + incidence = [sum((mask >> j) & 1 for mask in best_support) for j in range(N)] + star_per_map = [2 * x for x in incidence] + multiplicity = [best_word.count(j) for j in range(N)] + saved_per_map = [star_per_map[j] - multiplicity[j] for j in range(N)] + star_b = sum(star_per_map) + shared_b = sum(multiplicity) + target_calls = 2 * len(best_support) + require(cost["source_incidence_per_map"] == incidence, "cost source incidences mismatch") + require(cost["source_calls_saved_per_map"] == saved_per_map, "cost per-source savings mismatch") + require((cost["star_complete_calls"], cost["shared_complete_calls"], cost["complete_calls_saved"]) == (star_b + target_calls, shared_b + target_calls, star_b - shared_b), "complete-call invoice mismatch") + require((cost["star_event_bits"], cost["shared_event_bits"], cost["event_bits_saved"]) == (4 * star_b + 7 * target_calls, 4 * shared_b + 7 * target_calls, 4 * (star_b - shared_b)), "descriptor invoice mismatch") + require((cost["star_complete_calls"], cost["shared_complete_calls"], cost["complete_calls_saved"]) == (410, 136, 274), "reported 60-output call savings mismatch") + + # Negative controls: malformed counts, corrupted prefix state and wrong output boundary must reject. + require(not valid_source_word(best_word[:-1], [4, 2, 2, 2, 2, 2, 2]), "dropped-toggle control was accepted") + corrupt = list(best_states) + corrupt[5] ^= 1 + require(corrupt != prefix_states(best_word), "corrupted-prefix control was accepted") + require(best_states[0] ^ best_states[2] != 1, "wrong-boundary control unexpectedly realizes mask 1") + require(len(best_support) != len(TARGETS), "full-family negative control unexpectedly passed") + + print(f"PASS_SEVEN_SOURCE_16EVENT_BOUND old_domain={old_count} old_max=56 new_domain={count} new_max=60 full_hits=0 max_words=8 outputs=60 calls=136 savings=274 controls=4") + + +TARGET_SET = set(TARGETS) + + +if __name__ == "__main__": + main() From be03870d764e7875ea9a9f6cc69933c9b1a2456a Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 20:26:36 -0500 Subject: [PATCH 2/2] Record seven-source connector handoff --- .../README.md | 2 ++ .../TASK.json | 11 +++++++++-- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/research/seven-source-16event-connector-seeda7de5e/README.md b/research/seven-source-16event-connector-seeda7de5e/README.md index 90c45aa6d9..9c15cb0d32 100644 --- a/research/seven-source-16event-connector-seeda7de5e/README.md +++ b/research/seven-source-16event-connector-seeda7de5e/README.md @@ -158,6 +158,8 @@ PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check) ## Pins, overlap and limits +Public review: [PR #2236](https://github.com/CrocSwap/integer-mult-bounds/pull/2236), research commit `6687dfdd084a465582194258f416f24604136aaa`. + Cycle 28 used seed `a7de5e16e6ab896abb6ef4a0dc88a174`, track `recursive-interfaces`, task `connector-alphabet-change`, priority revision 4, selector scope key `0c9f43f3c7d61edb36fe`, refined scope key diff --git a/research/seven-source-16event-connector-seeda7de5e/TASK.json b/research/seven-source-16event-connector-seeda7de5e/TASK.json index 4cc8f7fe55..b82a6ffaca 100644 --- a/research/seven-source-16event-connector-seeda7de5e/TASK.json +++ b/research/seven-source-16event-connector-seeda7de5e/TASK.json @@ -280,7 +280,7 @@ "author": "Cinna Davis", "ai_assistance": "Substantial OpenAI Codex assistance in scope selection, proof derivation, exact search implementation, independent verifier, exact cost accounting, overlap checks and writing. No independent human review or proof-assistant formalization is claimed.", "outcome_summary": "Scoped negative for the 16-source-call full-mask class, plus a 60-output construction and a source-pinned lower bound of at least 144 complete map calls for the full 63-mask batch in the original one-root event alphabet.", - "claim_status": "will be released after publication and handoff", + "claim_status": "released", "verification": { "python": "CPython 3.14.7", "search": "PASS; 840 pair insertions and all 18,918,900 normalized 16-event words.", @@ -294,5 +294,12 @@ "No construction or exclusion at 144 complete map calls; other source multiplicities and extra A-map readouts remain outside this search.", "No selected-supplier placement, supplier admission or kappa change is established.", "No independent human review or proof-assistant formalization is claimed." - ] + ], + "claim_released_at_utc": "2026-10-15T01:26:21Z", + "public_artifact": { + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2236", + "research_commit": "6687dfdd084a465582194258f416f24604136aaa", + "exact_base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "status": "open focused PR" + } }