From 79dca6e94ed4c7c9d0ef9aeafb4489d99e2ecb29 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 18:31:49 -0500 Subject: [PATCH 1/2] research: bound arity-four connector bundle --- .../connector-quad-six-seedde3f84/README.md | 75 +++++ .../connector-quad-six-seedde3f84/RESULT.json | 213 +++++++++++++ .../SOURCES.json | 48 +++ .../connector-quad-six-seedde3f84/TASK.json | 131 ++++++++ .../connector-quad-six-seedde3f84/VERIFY.json | 27 ++ .../connector-quad-six-seedde3f84/verify.py | 287 ++++++++++++++++++ 6 files changed, 781 insertions(+) create mode 100644 research/connector-quad-six-seedde3f84/README.md create mode 100644 research/connector-quad-six-seedde3f84/RESULT.json create mode 100644 research/connector-quad-six-seedde3f84/SOURCES.json create mode 100644 research/connector-quad-six-seedde3f84/TASK.json create mode 100644 research/connector-quad-six-seedde3f84/VERIFY.json create mode 100644 research/connector-quad-six-seedde3f84/verify.py diff --git a/research/connector-quad-six-seedde3f84/README.md b/research/connector-quad-six-seedde3f84/README.md new file mode 100644 index 0000000000..bd14346bb9 --- /dev/null +++ b/research/connector-quad-six-seedde3f84/README.md @@ -0,0 +1,75 @@ +# One arity-four source bundle on the universal connector + +**Scoped negative result for a new connector operation; no selected-supplier or κ change.** Let the added operation be + +```text +Q_S: z += sum(B_j x_j for j in S), |S| = 4, +``` + +where the four existing source maps are applied into the same dirty connector in one root transition. All four source-map additions remain charged. The connector and five/six input rows may start dirty; sources are read-only; targets are independent and are not observed between operations. Every output map is required to be applied an even positive number of times so connector dirt cancels. The only alphabet change is this one Q4 operation. + +## Exact source-word reduction + +At each boundary let `q_t` be the parity vector of source-map additions so far. Then + +```text +z_t = z_initial + sum_j q_t[j] B_j x_j. +``` + +If output map `A_m` is applied at two boundaries `s,t`, the dirty connector cancels and the target receives + +```text +A_m(z_s + z_t) = A_m(sum_j (q_s XOR q_t)[j] B_j x_j). +``` + +Thus two reads of every nonzero output mask are possible exactly when the boundary-difference set contains every nonzero mask. The fixed connector lemma in the pinned universal-connector certificate supplies both directions of this test for arbitrary dirty rows and arbitrary admissible linear maps. + +We first screened the smallest useful five-source profile. A four-source bundle plus eight singleton calls restores all five source maps with nine source transitions and ten boundary values. Relabeling sets `S={0,1,2,3}` and rotating the unique Q4 transition to the start. The five singleton-count profiles are `(3,1,1,1,2)` (four label choices) and `(1,1,1,1,4)`. The exact 15,120 distinct orders have no full 31-mask cover; the maximum is 25. This is a pivot result for that source-call profile only. + +The six-source minimum is one Q4 plus ten singleton calls: the four Q-sources have odd singleton counts and the two other sources have positive even counts. There are six profiles: one Q-source receives two extra singleton uses, or one outside source receives two extra uses. After the same label and cycle normalization, the exact domain has **756,000** orders and twelve boundary values. Despite 66 unordered boundary pairs for 63 required masks, there is no full cover; the maximum is **41/63**. The complete histograms, an attaining 41-mask word, its 22 missing masks, the five-source pivot, and pins are in [RESULT.json](RESULT.json). + +## Cost consequence in the uniform local model + +Write `o` for one root instruction/call and `p` for one source or output map addition. A Q4 transition costs one `o` and four `p`; it does not erase any of the four child additions. Let `rho >= 0` collect every extra Q4-specific cost: macro implementation, nonuniform source-child deltas, staging, temporary storage, hosting, precision, restoration, interface transitions, and dispatch not already counted. + +The best nearby six-source TRIO profile in PR #2146 is `138o + 140p` at head [`302b0e87d9328fabc2a670248afb357bbb44041b`](https://github.com/CrocSwap/integer-mult-bounds/commit/302b0e87d9328fabc2a670248afb357bbb44041b). The one-DUO comparator PR #2128 is `140o + 142p` at head [`697369a971eed02c0fbcd75ebefec9f59945f08e`](https://github.com/CrocSwap/integer-mult-bounds/commit/697369a971eed02c0fbcd75ebefec9f59945f08e). + +For a six-source Q4 word: + +| Source transitions | Pair coverage | Minimum output calls | Root calls | Map additions | Comparison with PR #2146 | +|---:|---:|---:|---:|---:|---| +| 9 | At most `C(10,2)=45`, so at least 18 masks have no two-read representation | 162 | 171 | 174 | Dominated | +| 11 | Exact census maximum 41, so at least 22 masks have no two-read representation | 170 | 181 | 184 | Dominated | +| 13 or more | Even source multiplicity makes the next length 13; at least 16 B additions remain | 126 | 139 or more | 142 or more | Dominated | + +For each output mask without a boundary pair, an even target update needs at least four `A_m` reads. That gives the first two rows. In the last row, the minimum paired-readout bill is already componentwise above PR #2146. Every additional Q4 surcharge only raises the cost. Therefore this single-Q4 six-source family cannot improve the existing `(root calls, map additions)` frontier in the uniform positive `(o,p)` model. This is a root-interface obstruction only; it says nothing universal about other alphabets, additional Q4 calls, altered output contracts, nonuniform actual child prices, or the multiplication theorem. + +## Reproduction and controls + +From the repository root: + +```sh +python3 scripts/research_package.py --package research/connector-quad-six-seedde3f84 --check-only +python3 -I -B research/connector-quad-six-seedde3f84/verify.py +``` + +The package runner is registered for the repository's Python 3.12 environment. This host has Python 3.14.7 and no `python3.12`; local direct verification is on 3.14.7. Expected direct output: + +```text +PASS_QUAD4_SCOPED_OBSTRUCTION n5 15120 max 25 n6 756000 max 41 full 0 +``` + +The verifier checks every live source SHA-256 and Git blob, exhausts all distinct words, independently compares set- and bitset-based difference calculations on the pinned positive control, verifies source restoration, and rejects both a deleted-source control and a coverage mutation that preserves source multiplicities. `SOURCES.json` pins the selected record, catalogue, baseline certificate, and verifier at exact base `0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2`. + +## Assignment and attribution + +- Accepted seed: `de3f84ac54d98bf098a9e9bab973b212`; track `recursive-interfaces`; task `connector-alphabet-change`; priority revision 4; selector scope key `ff4f5113ed2256ab19ed`. +- The exact n=6 one-Q4/10-singleton domain is the main result. The n=5 screen was a bounded pivot, not a claim about longer n=5 words. +- Nearest predecessor scopes: PR #2128 (pair-source DUO), PR #2134 and PR #2146 (three-source TRIO paths), and PR #2182 (fixed-port and two-root connector boundaries). Their work is not copied or modified. +- Live lexical searches also surfaced PR #2098 (an order-four typed echo with a 3|7 handoff across two banks; not a four-source connector bundle) and PR #2116 (a four-output target in the group algebra of `A4`; not an F2 source-bundle operation). Both were read and found to use different interfaces. +- Coordination claim and correction history: [Discussion #1166 comment](https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18935950). +- Prepared by Cinna Davis with substantial OpenAI Codex assistance in scope selection, exact enumeration design, implementation, debugging, and packaging. No physical operation implementation, independent human review, supplier, or new κ is claimed. New package material is Apache-2.0; predecessor licenses are unchanged. + +## Open next questions + +This one-Q4 six-source family has a scoped cost obstruction. Any different operation arity, output-readout contract, or physical Q4 implementation is a separate hypothesis requiring a fresh budget and overlap check; no additional question is left open within this package's stated scope. diff --git a/research/connector-quad-six-seedde3f84/RESULT.json b/research/connector-quad-six-seedde3f84/RESULT.json new file mode 100644 index 0000000000..f61cf6bb38 --- /dev/null +++ b/research/connector-quad-six-seedde3f84/RESULT.json @@ -0,0 +1,213 @@ +{ + "controls": { + "independent_control": "set-based and bitset-based pair-difference implementations agree", + "negative_controls": [ + "deleting the final singleton breaks source restoration", + "swapping source steps 0 and 3 preserves multiplicities and restoration but lowers coverage to 27" + ], + "positive_control": "pinned five_extra_source word covers all 31 nonzero masks and restores all five sources" + }, + "cost_screen": { + "best_current_trio": { + "head": "302b0e87d9328fabc2a670248afb357bbb44041b", + "map_additions": 140, + "root_calls": 138, + "source": "PR2146", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2146" + }, + "duo_predecessor": { + "head": "697369a971eed02c0fbcd75ebefec9f59945f08e", + "map_additions": 142, + "root_calls": 140, + "source": "PR2128", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2128" + }, + "eleven_source_calls": { + "boundary_values": 12, + "exact_domain_orders": 756000, + "exact_max_pair_covered_masks": 41, + "map_additions_lower_bound": 184, + "output_calls_lower_bound": 170, + "root_calls_lower_bound": 181, + "unpairable_outputs_lower_bound": 22 + }, + "interpretation": "For n=6 with all 63 targets, arbitrary dirty connector and even positive output multiplicities, the 9-call case has at least 18 unpairable masks, the exact 11-call census leaves at least 22 unpairable masks, and every later parity-allowed source length is componentwise worse than the existing 138o+140p TRIO profile. Any extra Q4 overhead rho only increases these bills.", + "nine_source_calls": { + "boundary_values": 10, + "map_additions_lower_bound": 174, + "output_calls_lower_bound": 162, + "pair_slots_upper_bound": 45, + "root_calls_lower_bound": 171, + "unpairable_outputs_lower_bound": 18 + }, + "thirteen_or_more_source_calls": { + "dominates_trio_componentwise": true, + "map_additions_lower_bound": 142, + "minimum_b_additions": 16, + "minimum_output_calls": 126, + "minimum_source_calls": 13, + "root_calls_lower_bound": 139 + }, + "unit_model": "(root_call_count, map_addition_count) charged as (o,p); one Q4 costs four B additions plus one root transition before surcharge rho" + }, + "five_source_pivot": { + "best_example": { + "extra_source": 0, + "singleton_order": [ + 0, + 1, + 0, + 2, + 0, + 4, + 3, + 4 + ], + "states": [ + 0, + 15, + 14, + 12, + 13, + 9, + 8, + 24, + 16, + 0 + ] + }, + "best_missing_masks": [ + "01010", + "01011", + "10010", + "10011", + "11010", + "11011" + ], + "boundary_values": 10, + "bundle_first_by_cycle_rotation": true, + "bundle_mask": 15, + "bundle_sources": [ + 0, + 1, + 2, + 3 + ], + "coverage_histogram": { + "15": 792, + "18": 4464, + "20": 3984, + "21": 408, + "22": 3168, + "23": 1728, + "25": 576 + }, + "distinct_orders": 15120, + "full_mask_covers": 0, + "maximum_covered_masks": 25, + "multiplicity_profiles": 5, + "singleton_calls": 8, + "source_transitions": 9, + "sources": 5 + }, + "operation": "Q_S: z += sum(B_j*x_j for j in S), exactly one root transition and four charged B-map additions", + "runner_sha256": "76f7d8c4079f246ec45206d47295e47119bda841460e9deedf0ceca4a7ff2d08", + "schema_version": 1, + "scope": "one four-source bundle plus the minimal parity-allowed singleton profile, with two readouts per nonzero output mask", + "six_source_minimal_profile": { + "best_example": { + "extra_source": 0, + "singleton_order": [ + 0, + 1, + 0, + 2, + 4, + 0, + 5, + 3, + 4, + 5 + ], + "states": [ + 0, + 15, + 14, + 12, + 13, + 9, + 25, + 24, + 56, + 48, + 32, + 0 + ] + }, + "best_missing_masks": [ + "001010", + "001011", + "010010", + "010011", + "011010", + "011011", + "011100", + "011101", + "011110", + "011111", + "100010", + "100011", + "100100", + "100101", + "100110", + "100111", + "101010", + "101011", + "110010", + "110011", + "111010", + "111011" + ], + "boundary_values": 12, + "bundle_first_by_cycle_rotation": true, + "bundle_mask": 15, + "bundle_sources": [ + 0, + 1, + 2, + 3 + ], + "coverage_histogram": { + "21": 9120, + "25": 73008, + "28": 100608, + "30": 126864, + "31": 20544, + "32": 104256, + "34": 135360, + "35": 27648, + "36": 46080, + "37": 43392, + "38": 10368, + "39": 46080, + "41": 12672 + }, + "distinct_orders": 756000, + "full_mask_covers": 0, + "maximum_covered_masks": 41, + "multiplicity_profiles": 6, + "singleton_calls": 10, + "source_transitions": 11, + "sources": 6 + }, + "source_sha256": { + "certificates/selected-result.json": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "docs/research/agent-task-catalog.json": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "research/universal-connector-boundary/CERTIFICATE.json": "e733746ba3e5151c829b4e8728bfff5ae3ed24d8d203eb77c735d20758e8266a", + "research/universal-connector-boundary/EXPECTED.json": "658924c2940cbe193378d5ef09f4d62500fc7b385c16c0ea33846be836c429d2", + "research/universal-connector-boundary/README.md": "23415f7829ab8d80a783142f10f7d31abbce84579362769984680af3df954476", + "research/universal-connector-boundary/SOURCES.json": "6c51dd06c73a4e94f28b636b9d07a22b8917baebdbf4a3b85b0f8541ea7dcbfe", + "research/universal-connector-boundary/verify.py": "e4fa4700f9e1ae6ca09c3c76ebc569e8361b89b699425a67839d999d8812e42d" + }, + "status": "PASS_QUAD4_SCOPED_OBSTRUCTION" +} diff --git a/research/connector-quad-six-seedde3f84/SOURCES.json b/research/connector-quad-six-seedde3f84/SOURCES.json new file mode 100644 index 0000000000..eb69948b32 --- /dev/null +++ b/research/connector-quad-six-seedde3f84/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": "docs/research/agent-task-catalog.json", + "usage": "input", + "git_blob": "e8870e5917057d59b730eb14721a778639eca050", + "sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7" + }, + { + "path": "research/universal-connector-boundary/CERTIFICATE.json", + "usage": "input", + "git_blob": "079e3e1441dc07c2f0536e9527acf290e51ea9c0", + "sha256": "e733746ba3e5151c829b4e8728bfff5ae3ed24d8d203eb77c735d20758e8266a" + }, + { + "path": "research/universal-connector-boundary/EXPECTED.json", + "usage": "input", + "git_blob": "c0f2eef36c9543745bb9d00f66913b0abf5cc904", + "sha256": "658924c2940cbe193378d5ef09f4d62500fc7b385c16c0ea33846be836c429d2" + }, + { + "path": "research/universal-connector-boundary/README.md", + "usage": "input", + "git_blob": "d277f7c5830b1f2bc42e1ff41ab86e7d7564929f", + "sha256": "23415f7829ab8d80a783142f10f7d31abbce84579362769984680af3df954476" + }, + { + "path": "research/universal-connector-boundary/SOURCES.json", + "usage": "input", + "git_blob": "885157ac149d8c8b8daad7e2b324e6d0ee454a51", + "sha256": "6c51dd06c73a4e94f28b636b9d07a22b8917baebdbf4a3b85b0f8541ea7dcbfe" + }, + { + "path": "research/universal-connector-boundary/verify.py", + "usage": "input", + "git_blob": "de6483bb7ff51940dbbb76c18f91af4c907e07da", + "sha256": "e4fa4700f9e1ae6ca09c3c76ebc569e8361b89b699425a67839d999d8812e42d" + } + ] +} diff --git a/research/connector-quad-six-seedde3f84/TASK.json b/research/connector-quad-six-seedde3f84/TASK.json new file mode 100644 index 0000000000..0a923bfb3e --- /dev/null +++ b/research/connector-quad-six-seedde3f84/TASK.json @@ -0,0 +1,131 @@ +{ + "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": "refined", + "actual_scope": "Test exactly one new arity-four bundle Q_S: z += sum_{j in S} B_j x_j, charged as four B-map additions and one root transition, on the minimal restored all-mask six-source paired-readout connector profile. Search all 756,000 words with one Q4 and ten singleton calls; use a complete five-source screen only as the evidence-driven pivot record. Derive the cost obstruction for every other parity-allowed source-call count in the same one-Q4 alphabet.", + "scope_change_reason": "The generic one-operation card is refined to the unused arity-four source bundle. The exact five-source minimal profile has no cover (maximum 25/31); this evidence motivated the single pivot to n=6, the first domain with enough boundary pairs for 63 masks.", + "bottleneck_link": "A universal connector word determines how many expensive recursive source and output calls are needed. An arity-four bundle could reduce root transitions only if its boundary differences still realize every output mask; this local interface result does not itself admit a selected multiplication supplier or change kappa.", + "budget_minutes": 60, + "stop_rule": "Exhaust the 15,120-word five-source pivot and 756,000-word six-source minimal profile; derive pair-readout lower bounds for the shorter and longer parity-allowed profiles. Stop after this one Q4 family; do not expand to other arities or source counts this cycle.", + "outcome": "negative-result", + "evidence": "Exact normalized enumeration: n=5 has 15,120 orders, zero full covers, maximum 25/31; n=6 has 756,000 orders, zero full covers, maximum 41/63. For n=6, the 9-source-call case has at most 45 pair masks and needs at least 162 output calls; the 11-call census leaves at least 22 masks unpairable, needing at least 170 output calls. Any next source length is at least 13 calls and 16 B additions, hence at least (139,142) in the uniform (o,p) model, componentwise worse than the PR2146 TRIO profile (138,140). Positive and negative controls, exact pins and deterministic result are in this package.", + "author": "Cinna Davis", + "ai_assistance": "Substantial OpenAI Codex assistance with scope selection, exact enumeration design, implementation, debugging, source checks, and packaging. The claimed coverage and cost statements are limited to the exact domain and derivation in this package.", + "open_questions": [], + "accepted_seed": "de3f84ac54d98bf098a9e9bab973b212", + "track": "recursive-interfaces", + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selector_scope_key": "ff4f5113ed2256ab19ed", + "selector_note": "Accepted draw was run in the fresh worktree at the exact base. An earlier selector invocation from the Cycle-25 shell was discarded because it used the wrong checkout/base and its seed was not accepted.", + "no_open_questions_reason": "This one-Q4 paired-readout mechanism has a scoped cost obstruction. Any different operator family, output-readout contract, or physical macro price is a new question and must be assigned and priced separately.", + "assignment": { + "seed": "de3f84ac54d98bf098a9e9bab973b212", + "track": "recursive-interfaces", + "task_id": "connector-alphabet-change", + "priority_revision": 4, + "catalogue_sha256": "d46eb6d5b3e279428753d770653663fbdf1063e55c255ea073d768f344927ef7", + "base_commit": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32", + "selector_scope_key": "ff4f5113ed2256ab19ed", + "accepted_suggestion": "connector-alphabet-change", + "prework_selector_note": "An invocation from the Cycle-25 shell was discarded because it ran against the wrong checkout/base; its draw was not accepted. This recorded seed was freshly drawn from the isolated Cycle-26 worktree." + }, + "upstream_checkpoint": { + "checked_at_utc": "2026-10-14T23:00Z", + "canonical_main": "0fdd7d82de03e43c9e5a1000dfbcd380d1b687d2", + "priority_revision": 4, + "selected_record_sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32" + }, + "overlap_status": { + "cached_overlap_searched_at_utc": "2026-10-14T23:12:52Z", + "open_prs_complete_through_utc": "2026-10-14T23:03:49Z", + "discussions_complete_through_utc": "2026-10-14T23:05:44Z", + "exact_terms": "six-source arity-four; four-source bundle; one Q4 call; weight-four source operator", + "exact_match_count": 0, + "direct_threads_checked": [ + "Discussion #1166 refreshed 2026-10-14T23:30Z", + "Discussion #1167 refreshed 2026-10-14T23:31Z" + ], + "live_refresh_limit": "full overlap refresh exceeded the 45-second bound; exact cached search and direct recent thread checks completed", + "live_pr_search": "Targeted GitHub searches for Q4, four-source, and arity-four; #2098 and #2116 were inspected and distinguished; the known #2128/#2134/#2146/#2182 heads were rechecked." + }, + "predecessors": [ + { + "pr": 2128, + "head": "697369a971eed02c0fbcd75ebefec9f59945f08e", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2128", + "scope": "six-source pair-source DUO; nominal uniform profile 140o+142p" + }, + { + "pr": 2134, + "head": "388a63c83cf24c3355be9798bde5a381188dadb3", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2134", + "scope": "six-source one-TRIO path, wider output-readout variant" + }, + { + "pr": 2146, + "head": "302b0e87d9328fabc2a670248afb357bbb44041b", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2146", + "scope": "six-source one-TRIO paired-readout profile; comparator 138o+140p" + }, + { + "pr": 2182, + "head": "dc252de1cc594829c3031abdb4de104713bc474a", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2182", + "scope": "fixed-port five-source and two-root connector boundary" + }, + { + "pr": 2098, + "head": "157a7239166b8fe640edb232f5eee9a4b2579569", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2098", + "scope": "typed order-four echo with a 3|7 source-bank handoff; inspected and distinguished from the Q4 source-bundle operation" + }, + { + "pr": 2116, + "head": "19cdf74af162f1444830f1a0f0a8e0fe306564ad", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2116", + "scope": "A4 group-algebra four-output word; inspected and distinguished from the F2 connector source-bundle operation" + } + ], + "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18935950", + "completed_at_utc": "2026-10-14T23:15Z" +} diff --git a/research/connector-quad-six-seedde3f84/VERIFY.json b/research/connector-quad-six-seedde3f84/VERIFY.json new file mode 100644 index 0000000000..1c7ca11bd9 --- /dev/null +++ b/research/connector-quad-six-seedde3f84/VERIFY.json @@ -0,0 +1,27 @@ +{ + "schema_version": 1, + "status": "ready", + "python": "3.12", + "requirements": [], + "inputs": [ + "certificates/selected-result.json", + "docs/research/agent-task-catalog.json", + "research/universal-connector-boundary/CERTIFICATE.json", + "research/universal-connector-boundary/EXPECTED.json", + "research/universal-connector-boundary/README.md", + "research/universal-connector-boundary/SOURCES.json", + "research/universal-connector-boundary/verify.py" + ], + "commands": [ + { + "argv": [ + "{python}", + "-I", + "-B", + "{package}/verify.py" + ], + "timeout_seconds": 180, + "checks": "Pinned inputs and Git blobs; exact 15,120-word n=5 and 756,000-word n=6 censuses; source restoration; complete pair-mask coverage histograms; arbitrary-dirty positive connector control; source-deletion and coverage-mutation negative controls; complete charged call/addition dominance screen." + } + ] +} diff --git a/research/connector-quad-six-seedde3f84/verify.py b/research/connector-quad-six-seedde3f84/verify.py new file mode 100644 index 0000000000..f8caf04d2c --- /dev/null +++ b/research/connector-quad-six-seedde3f84/verify.py @@ -0,0 +1,287 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: Apache-2.0 +"""Exact finite screen for one arity-four connector bundle.""" +from __future__ import annotations + +import argparse +from collections import Counter +import hashlib +import json +from pathlib import Path + + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] + + +def need(condition: bool, message: str) -> None: + if not condition: + raise ValueError(message) + + +def read_json(path: Path): + return json.loads(path.read_text(encoding="utf-8")) + + +def git_blob_sha1(data: bytes) -> str: + return hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest() + + +def check_pins() -> dict[str, str]: + manifest = read_json(HERE / "SOURCES.json") + digests = {} + for row in manifest["files"]: + data = (ROOT / row["path"]).read_bytes() + sha256 = hashlib.sha256(data).hexdigest() + need(sha256 == row["sha256"], "source SHA256 mismatch: " + row["path"]) + need(git_blob_sha1(data) == row["git_blob"], "source Git blob mismatch: " + row["path"]) + digests[row["path"]] = sha256 + return digests + + +def target_mask(n: int) -> int: + # Bits indexed by source mask; mask 0 is deliberately excluded. + return (1 << (1 << n)) - 2 + + +def difference_bits(states: list[int]) -> int: + bits = 0 + for i, left in enumerate(states): + for right in states[i + 1:]: + bits |= 1 << (left ^ right) + return bits + + +def difference_set(states: list[int]) -> set[int]: + return {left ^ right for i, left in enumerate(states) for right in states[i + 1:] if left != right} + + +def mask_labels(mask: int, n: int) -> list[str]: + return [format(x, f"0{n}b") for x in range(1, 1 << n) if (mask >> x) & 1] + + +def enumerate_profile(n: int, qmask: int, counts: list[int]) -> tuple[int, Counter[int], int, list[int], list[int]]: + """Enumerate each distinct singleton order once after the unique Q edge.""" + total = best = 0 + histogram: Counter[int] = Counter() + best_order: list[int] = [] + best_states: list[int] = [] + path = [0, qmask] + best_bits = 0 + + def visit(remaining: list[int], current: int, suffix: list[int]) -> None: + nonlocal total, best, best_order, best_states, best_bits + if not any(remaining): + need(current == 0, "source path failed to restore the dirty connector") + need(len(path) == (1 + sum(counts)) + 1, "wrong source-boundary count") + bits = difference_bits(path) + covered = (bits & ~1).bit_count() + histogram[covered] += 1 + total += 1 + if covered > best: + best, best_order, best_states, best_bits = covered, suffix.copy(), path.copy(), bits + return + for source, count in enumerate(remaining): + if count: + remaining[source] -= 1 + nxt = current ^ (1 << source) + path.append(nxt) + suffix.append(source) + visit(remaining, nxt, suffix) + suffix.pop() + path.pop() + remaining[source] += 1 + + visit(counts.copy(), qmask, []) + return total, histogram, best, best_order, best_states + + +def census(n: int) -> dict: + need(n in (5, 6), "only the declared five- and six-source cases are in scope") + qmask = 0b1111 + need(qmask < (1 << n), "four-source bundle exceeds the source dimension") + # Every Q-source has odd singleton multiplicity; every outside source has + # positive even multiplicity. Minimal profiles have 8 singletons at n=5, + # and 10 at n=6. The next count is outside this exact minimal-profile census. + singletons = 8 if n == 5 else 10 + base = [1, 1, 1, 1] + [2] * (n - 4) + profiles = [] + for extra_source in range(n): + counts = base.copy() + counts[extra_source] += 2 + profiles.append((extra_source, counts)) + + total = best = 0 + histogram: Counter[int] = Counter() + best_example = None + for extra_source, counts in profiles: + need(sum(counts) == singletons, "profile has wrong singleton total") + need(all(counts[j] % 2 == 1 for j in range(4)), "Q-source parity error") + need(all(counts[j] > 0 and counts[j] % 2 == 0 for j in range(4, n)), + "outside-source positivity/parity error") + profile_total, profile_hist, profile_best, order, states = enumerate_profile(n, qmask, counts) + total += profile_total + histogram.update(profile_hist) + if profile_best > best: + best = profile_best + best_example = {"extra_source": extra_source, "singleton_order": order, "states": states} + + expected = 15_120 if n == 5 else 756_000 + need(total == expected, f"distinct-order count mismatch for n={n}: {total}") + return { + "sources": n, + "bundle_sources": [0, 1, 2, 3], + "bundle_mask": qmask, + "bundle_first_by_cycle_rotation": True, + "singleton_calls": singletons, + "source_transitions": singletons + 1, + "boundary_values": singletons + 2, + "multiplicity_profiles": len(profiles), + "distinct_orders": total, + "full_mask_covers": histogram.get((1 << n) - 1, 0), + "maximum_covered_masks": best, + "coverage_histogram": {str(k): histogram[k] for k in sorted(histogram)}, + "best_example": best_example, + "best_missing_masks": mask_labels( + target_mask(n) & ~difference_bits(best_example["states"]), n + ), + } + + +def certified_cost_screen(n6: dict) -> dict: + # The existing six-source TRIO profile in PR2146 is (138,140) in the + # uniform root-call/map-addition model. Q4 source-call counts are odd: + # Q contributes four B additions, singleton total is even, and every + # B_j must occur positively and evenly. + max_pairs_at_nine_calls = (10 * 9) // 2 + d11 = n6["maximum_covered_masks"] + missing_at_11 = 63 - d11 + need(0 <= d11 <= 63, "invalid n=6 difference coverage") + return { + "unit_model": "(root_call_count, map_addition_count) charged as (o,p); one Q4 costs four B additions plus one root transition before surcharge rho", + "best_current_trio": { + "root_calls": 138, + "map_additions": 140, + "source": "PR2146", + "head": "302b0e87d9328fabc2a670248afb357bbb44041b", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2146", + }, + "duo_predecessor": { + "root_calls": 140, + "map_additions": 142, + "source": "PR2128", + "head": "697369a971eed02c0fbcd75ebefec9f59945f08e", + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2128", + }, + "nine_source_calls": { + "boundary_values": 10, + "pair_slots_upper_bound": max_pairs_at_nine_calls, + "unpairable_outputs_lower_bound": 63 - max_pairs_at_nine_calls, + "output_calls_lower_bound": 2 * max_pairs_at_nine_calls + 4 * (63 - max_pairs_at_nine_calls), + "root_calls_lower_bound": 9 + 2 * max_pairs_at_nine_calls + 4 * (63 - max_pairs_at_nine_calls), + "map_additions_lower_bound": 12 + 2 * max_pairs_at_nine_calls + 4 * (63 - max_pairs_at_nine_calls), + }, + "eleven_source_calls": { + "boundary_values": 12, + "exact_max_pair_covered_masks": d11, + "unpairable_outputs_lower_bound": missing_at_11, + "output_calls_lower_bound": 2 * d11 + 4 * missing_at_11, + "root_calls_lower_bound": 11 + 2 * d11 + 4 * missing_at_11, + "map_additions_lower_bound": 14 + 2 * d11 + 4 * missing_at_11, + "exact_domain_orders": n6["distinct_orders"], + }, + "thirteen_or_more_source_calls": { + "minimum_source_calls": 13, + "minimum_b_additions": 16, + "minimum_output_calls": 126, + "root_calls_lower_bound": 139, + "map_additions_lower_bound": 142, + "dominates_trio_componentwise": True, + }, + "interpretation": "For n=6 with all 63 targets, arbitrary dirty connector and even positive output multiplicities, the 9-call case has at least 18 unpairable masks, the exact 11-call census leaves at least 22 unpairable masks, and every later parity-allowed source length is componentwise worse than the existing 138o+140p TRIO profile. Any extra Q4 overhead rho only increases these bills.", + } + + +def verify_controls() -> dict: + cert = read_json(ROOT / "research/universal-connector-boundary/CERTIFICATE.json") + baseline = cert["schedules"]["five_extra_source"]["source_word"] + counts = Counter(baseline) + need(set(counts) == set(range(5)) and all(count > 0 and count % 2 == 0 for count in counts.values()), + "pinned five-source positive control does not restore every source") + states = [0] + for source in baseline: + states.append(states[-1] ^ (1 << source)) + need(states[-1] == 0, "pinned positive control does not close") + bitset = difference_bits(states) & ~1 + as_set = difference_set(states) + need(bitset == sum(1 << x for x in as_set), "independent set/bitset difference controls disagree") + need(bitset == target_mask(5), "pinned universal connector positive control lost a mask") + + broken = baseline[:-1] + broken_counts = Counter(broken) + need(not (set(broken_counts) == set(range(5)) and all(c > 0 and c % 2 == 0 for c in broken_counts.values())), + "source-deletion negative control unexpectedly restores every source") + mutant = baseline.copy() + mutant[0], mutant[3] = mutant[3], mutant[0] + mutant_states = [0] + for source in mutant: + mutant_states.append(mutant_states[-1] ^ (1 << source)) + need((difference_bits(mutant_states) & ~1) != target_mask(5), + "paired source-order mutation unexpectedly retains full mask coverage") + return { + "positive_control": "pinned five_extra_source word covers all 31 nonzero masks and restores all five sources", + "independent_control": "set-based and bitset-based pair-difference implementations agree", + "negative_controls": [ + "deleting the final singleton breaks source restoration", + "swapping source steps 0 and 3 preserves multiplicities and restoration but lowers coverage to 27", + ], + } + + +def compute_result() -> dict: + source_hashes = check_pins() + n5 = census(5) + n6 = census(6) + controls = verify_controls() + need(n5["maximum_covered_masks"] == 25 and n5["full_mask_covers"] == 0, + "five-source pivot control changed") + need(n6["maximum_covered_masks"] == 41 and n6["full_mask_covers"] == 0, + "six-source census control changed") + need(63 - n6["maximum_covered_masks"] == 22, "wrong unpaired six-source mask count") + return { + "schema_version": 1, + "status": "PASS_QUAD4_SCOPED_OBSTRUCTION", + "scope": "one four-source bundle plus the minimal parity-allowed singleton profile, with two readouts per nonzero output mask", + "operation": "Q_S: z += sum(B_j*x_j for j in S), exactly one root transition and four charged B-map additions", + "source_sha256": source_hashes, + "runner_sha256": hashlib.sha256((HERE / "verify.py").read_bytes()).hexdigest(), + "five_source_pivot": n5, + "six_source_minimal_profile": n6, + "cost_screen": certified_cost_screen(n6), + "controls": controls, + } + + +def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--write-result", action="store_true") + args = parser.parse_args() + result = compute_result() + encoded = json.dumps(result, indent=2, sort_keys=True) + "\n" + receipt = HERE / "RESULT.json" + if args.write_result: + receipt.write_text(encoded, encoding="utf-8") + else: + need(receipt.is_file(), "missing RESULT.json; run with --write-result once") + need(receipt.read_text(encoding="utf-8") == encoded, + "RESULT.json differs from the exact recomputation") + print("PASS_QUAD4_SCOPED_OBSTRUCTION", + "n5", result["five_source_pivot"]["distinct_orders"], + "max", result["five_source_pivot"]["maximum_covered_masks"], + "n6", result["six_source_minimal_profile"]["distinct_orders"], + "max", result["six_source_minimal_profile"]["maximum_covered_masks"], + "full", result["six_source_minimal_profile"]["full_mask_covers"]) + + +if __name__ == "__main__": + main() From 21fee7f7fb9ed42298ee998dbc120e684ca7fb71 Mon Sep 17 00:00:00 2001 From: Cinna Davis <1337isnot1337@users.noreply.github.com> Date: Wed, 14 Oct 2026 18:35:05 -0500 Subject: [PATCH 2/2] Record quad connector PR handoff status --- research/connector-quad-six-seedde3f84/TASK.json | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/research/connector-quad-six-seedde3f84/TASK.json b/research/connector-quad-six-seedde3f84/TASK.json index 0a923bfb3e..47c390f79f 100644 --- a/research/connector-quad-six-seedde3f84/TASK.json +++ b/research/connector-quad-six-seedde3f84/TASK.json @@ -127,5 +127,16 @@ } ], "claim_url": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-18935950", - "completed_at_utc": "2026-10-14T23:15Z" + "completed_at_utc": "2026-10-14T23:34:00Z", + "submission": { + "pr": 2201, + "url": "https://github.com/CrocSwap/integer-mult-bounds/pull/2201", + "state": "open", + "ci_status_at_handoff": "queued", + "remaining_obligations": [ + "Hosted Python 3.12 registered-package replay", + "Hosted repository workflow checks", + "Maintainer review" + ] + } }