Research: one connector is blocked by selected output caps

research/single-connector-cap-obstruction-seed653bd5/CLAIM.md

@@ -0,0 +1,19 @@
+# Claim and coordination
+
+**CLAIM — recursive interfaces, refined to one framed accumulator.**
+
+- Seed: `653bd5f4eaffb9d44cab3bdd1378ae10`; catalogue task: `connector-alphabet-change`; scope key: `ff4f5113ed2256ab19ed`; priority revision: 3.
+- Base: `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; selected-record SHA-256: `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`.
+- Object: the eight independent external inputs and four late additive ports of each fixed block in `research/complex-block-rank-optimum/CERTIFICATE.json`.
+- Question: can one extra dirty array, with a monotone frame, receive all eight external inputs and supply the two required output incidences of each input while all four target arrays retain their distinct rank-eight terminal caps?
+- Changed premise: add one physical accumulator and route the external-source `Qz` terms through that single array. Existing helpers may retain the `Ry` and dirty-endpoint work but may not carry `Qz`; there is no direct source-to-target route or second `Qz` accumulator. Sources stay read-only, targets stay additive, and frames do not descend.
+- Method and domain: exact F2-subspace joins from the 12 selected source blocks, with the two 12-block PR1319 words as pinned comparison controls; four output caps per block. Use an exact obstruction before considering scalar schedules or recursive prices.
+- Nearby work: PR #1522 / Discussion #1493 share centered dyadic BIT outputs in a different source-tour alphabet; PR #1717 shares a paired rank-eight output delta; PR #1739 changes a connector source/map transition. Generic source tours and alphabet searches are not claimed here. The refreshed overlap scan at 2026-10-14 09:28:19 UTC covered 442 open PRs and 407 Discussion/comment/reply records, complete pagination and no warnings; no direct prior frame-join/cap match appeared.
+- Additional close predecessor: PR #781 / PR #855 and local `research/complex-packet-borrowing23` use one coded helper for a distinct six-source all-K packet cell and account its native provider bill. Here the proposed single accumulator must receive all eight independent external inputs in each selected late block; the new question is whether that full span can ever reach the four retained caps.
+- Expected result: a source-pinned proof and exact checker for feasibility or a scoped interface obstruction, including a feasible-frame positive control and cap-mutation negative control. No new kappa is expected.
+- Optimistic cost screen: if a required final source-to-port update is frame-incompatible, the one-connector route has no feasible finite bill even before charging its extra child, so a large search is unwarranted.
+- Expiry: `2026-10-14 11:20 UTC`.
+
+Discussion claim URL: https://github.com/CrocSwap/integer-mult-bounds/discussions/1771
+
+This is not an independent audit of the selected construction. It tests a new one-accumulator route against the selected block's exact frames and retained target contract.

research/single-connector-cap-obstruction-seed653bd5/PR-BODY.md

@@ -0,0 +1,37 @@
+## Result
+
+Scoped negative result for one added dirty accumulator in the selected late complex block. If the single added array reads all eight independent external inputs and is the sole carrier of their `Qz` terms to the four retained additive ports, monotone frame growth makes the route infeasible: the joined input frame is not contained in any rank-eight target cap. Existing helpers may still carry the retained `Ry` and dirty-endpoint work, but cannot store external `Qz` terms. The last external input contributes to two distinct ports, so after the connector has read all eight inputs at least one required output update would force its target to rank nine.
+
+The exact checker covers the 12 blocks in the selected word and 24 blocks from two pinned PR1319 comparison words: 36 block instances and 144 target-cap pairs. Every pair has `dim(span(F_1,...,F_8) + H_j) = 9`; the six rank-eight joins across the three words also differ from every cap. No scalar schedule, gate count or connector tour can evade this frame obstruction inside the stated class.
+
+This is not a general connector lower bound, a result about multiple `Qz` accumulators or direct source-to-target routes, a selected-supplier replacement, or a new `kappa`.
+
+## Provenance and scope
+
+The exact base is `0b1cccf86e2f5132ed286a26ef0a681a495740ea`; the selected-record SHA-256 is `10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32`. `SOURCES.json` pins the selected review, source manifest, assembly certificate, task catalogue, block certificate and compressed block sources.
+
+The closest neighboring constructions are PR #1522's centered BIT source tour, PR #1717's paired dirty-output delta, PR #1739's source/map transition, and PR #781/#855's separate six-source coded-helper packet cell and provider-cost analysis. Those results and their authors remain credited; this result is only the all-eight-input frame-join obstruction for the selected four-port block interface.
+
+## Reproduction
+
+From the repository root:
+
+```sh
+python3 -I -B research/single-connector-cap-obstruction-seed653bd5/verify.py
+python3 -I -B research/complex-block-rank-optimum/verify.py
+python3 scripts/research_package.py --package research/single-connector-cap-obstruction-seed653bd5 --check-only
+make selected-record-check
+```
+
+The local replay passed on Python 3.14.7:
+
+```text
+PASS_SINGLE_CONNECTOR_CAP_OBSTRUCTION selected_blocks=12 selected_pairs=48 all_blocks=36 all_pairs=144 rank8_joins=6 rank9_joins=30 positive_control=1 cap_mutation_rejected=1
+PASS_FIXED_BLOCK_MOMENT_PREMISES blocks=36 subsets=9180 minors=36 controls=12
+PASS_PACKAGE_METADATA_AND_PINS (not a mathematical acceptance check)
+PASS selected record, exact kappa, original source inventory and proof supplement: 836330098538459/500000000000000000
+```
+
+The full research-package wrapper is configured for Python 3.12; the generic metadata check and direct verifiers were run locally. No full selected-construction cold replay is claimed.
+
+Authored by Cinna Davis with substantial OpenAI Codex assistance in scoping, proof development, exact verification, source handling and writing.

research/single-connector-cap-obstruction-seed653bd5/PROOF.md

@@ -0,0 +1,91 @@
+# A single framed accumulator cannot serve all four late ports
+
+## Statement
+
+Fix one block interface in `research/complex-block-rank-optimum/CERTIFICATE.json`.
+Let its eight independent read-only external inputs have frames
+`F_1,...,F_8`, and let its four additive targets end at the distinct
+rank-eight caps `H_1,...,H_4`. The required external-input contribution is the
+four-by-eight rational matrix `Q` in the certificate. Every column of `Q` has
+nonzero entries at exactly two distinct output ports.
+
+Consider the following added resource and no other routing change: one extra
+array `c` receives all eight external inputs and is the sole carrier of their
+`Qz` contributions to the four targets. Its frame grows only by inclusion.
+The existing helper values and `Ry` contributions may follow their retained
+route, but no existing helper can become an alternate carrier of `Qz`. Inputs
+are read-only; targets are additive and retain their certified final caps;
+there is no direct input-to-target operation, second `Qz` accumulator, target
+scratch, or frame descent.
+
+For every one of the 12 selected-word blocks, and also for each of the 24
+blocks in the two pinned PR1319 comparison words, this route is infeasible.
+This is a fixed-interface obstruction. It does not rule out multiple
+accumulators, direct source-to-target routes, earlier target access, or changed
+caps.
+
+## Proof
+
+Put `S = F_1 + ... + F_8`. When `c` is updated from an input at frame `F_i`,
+the common operation frame must contain both the current frame of `c` and
+`F_i`. Monotonicity therefore leaves the connector frame containing every
+input frame after all eight independent values have been read. In particular,
+its frame `C` then contains `S`.
+
+Choose the last external input whose value is first incorporated into `c`.
+Its column of `Q` is nonzero at two distinct targets. Since that input is
+independent and the one connector is the sole carrier, both target increments
+still require a later operation that transfers information from `c`. For any
+such operation on target `j`, the common frame contains `C`, and hence `S`.
+The target frame also grows to that common frame. Because target frames only
+grow and the final frame is `H_j`, a legal update must keep its common frame
+inside `H_j`. Thus a necessary condition is `S ⊆ H_j`.
+
+The certificate's exact binary spans give, for every block and every output
+cap,
+
+```text
+dim(S + H_j) = 9,       dim(H_j) = 8.
+```
+
+So `S` is not contained in any `H_j`; every required connector-to-target
+update would force the target to rank nine and violate its endpoint. This
+contradicts the required nonzero two-port contribution of the last input.
+The contradiction is independent of scalar coefficients and gate count.
+
+The conclusion also holds if the connector reads inputs more than once or
+changes its scalar value between reads: its frame cannot forget a frame it
+has already visited. Reading the final independent input and writing through
+the connector are distinct two-array operations, so the required target
+update occurs after the connector contains `S`.
+
+## Exact certificate check
+
+`verify.py` recomputes ranks over the nine-dimensional binary frame space from
+the pinned certificate. It checks all eight input frames contain the common
+frame, all eight columns of `Q` have weight two, all four caps have rank eight,
+and all 144 input-join/cap pairs force a rank-nine common frame. There are 12
+selected blocks and 24 comparison blocks. In the selected blocks, the source
+join has rank eight in bases 592 and 696 and rank nine in the other ten blocks;
+the rank-eight joins still differ from every target cap.
+
+The verifier also checks that its containment predicate accepts a synthetic
+cap containing the source join and that it rejects a rank-mutated target cap.
+The source certificate is pinned by SHA-256 and its predecessor's exact
+source-bound verifier is run separately.
+
+## Complete-cost screen and limits
+
+There is no feasible completed cost for this one-connector route under the
+stated endpoint contract. Charging source reads, the extra connector's
+hosting/restoration children, output updates, precision or tape cannot repair
+the frame contradiction; charging the necessary rank-nine target climb
+violates the cap. The screen therefore stops before any scalar schedule or
+recursive-moment search. No improvement to the selected paid moment or `kappa`
+is claimed.
+
+This does not bound a design with two or more accumulators, does not establish
+a global lower bound for the complex supplier, and does not modify the
+selected construction. It is a scoped negative result for one additional
+monotone accumulator routing all eight external source columns through the
+four retained late target caps.

research/single-connector-cap-obstruction-seed653bd5/README.md

@@ -0,0 +1,86 @@
+# One framed connector cannot reach the selected block's late ports
+
+**Scoped recursive-interface obstruction; no new `kappa`.** In each of the 12
+selected late blocks, the join of the eight read-only input frames is not
+contained in any of the four retained rank-eight target caps. A single
+monotone accumulator that reads all eight inputs must therefore force a
+rank-nine target climb before it can deliver the last source contribution.
+The target endpoint forbids that climb.
+
+The obstruction is checked over the 12 selected-word blocks and 24 pinned
+blocks from the PR1319 base/extra words: **36 blocks, 144 target-cap pairs**.
+Every pair has `dim(span(F_1,...,F_8) + H_j) = 9`. The selected input join has
+rank eight in blocks 592 and 696 and rank nine in the other ten blocks; none
+of the four target caps contains it in either case.
+
+This tests one added physical accumulator as the sole carrier for the eight
+external `Qz` terms of the four-output correction. The retained helper route
+may still carry `Ry` and dirty endpoint information, but cannot act as another
+`Qz` carrier. It does not cover
+multiple accumulators, direct input-to-target operations, target retiming, or
+different endpoint caps. It is not a general connector lower bound, selected
+supplier replacement, or exponent improvement.
+
+The accepted selected record remains
+`836330098538459/500000000000000000` (`0.001672660197076918`). The source record
+is pinned by SHA-256
+`10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32` at base
+`0b1cccf86e2f5132ed286a26ef0a681a495740ea`. Its review, source manifest,
+assembly certificate and reproduction command are separately pinned in
+`SOURCES.json`.
+
+## Reproduce
+
+From the repository root with Python 3.12 or later and no third-party
+dependencies:
+
+```sh
+python3 -I -B research/single-connector-cap-obstruction-seed653bd5/verify.py
+python3 -I -B research/complex-block-rank-optimum/verify.py
+python3 scripts/research_package.py --package research/single-connector-cap-obstruction-seed653bd5 --check-only
+make selected-record-check
+```
+
+The first command prints:
+
+```text
+PASS_SINGLE_CONNECTOR_CAP_OBSTRUCTION selected_blocks=12 selected_pairs=48 all_blocks=36 all_pairs=144 rank8_joins=6 rank9_joins=30 positive_control=1 cap_mutation_rejected=1
+```
+
+The predecessor checker prints `PASS_FIXED_BLOCK_MOMENT_PREMISES` and checks
+the stored source-bound certificate. The package metadata command checks
+source pins; it is not a mathematical acceptance check. No full selected
+construction replay is part of this contribution.
+
+## Coordination and nearby results
+
+The focused claim is [Discussion #1771](https://github.com/CrocSwap/integer-mult-bounds/discussions/1771).
+The 2026-10-14 09:28 UTC overlap refresh covered 442 open PRs and 407
+Discussion/comment/reply records with complete pagination and no warnings.
+The refreshed records showed related but different work: [PR #1522's centered
+BIT source tour](https://github.com/CrocSwap/integer-mult-bounds/discussions/1493),
+[PR #1717's paired dirty-output delta](https://github.com/CrocSwap/integer-mult-bounds/pull/1717),
+and [PR #1739's source/map transition](https://github.com/CrocSwap/integer-mult-bounds/pull/1739).
+The close geometric predecessor is [PR #781's six-source coded helper](https://github.com/CrocSwap/integer-mult-bounds/pull/781)
+and its provider-cost follow-up [PR #855](https://github.com/CrocSwap/integer-mult-bounds/pull/855),
+documented in `research/complex-packet-borrowing23`. That construction serves
+a separate all-K packet cell with one coded helper and multiple target pairs;
+this result tests the full join of all eight independent inputs in a selected
+four-port late block. No priority claim is made for source tours, coded helpers
+or connector extensions generally.
+
+The frame data and source-specific interface come from
+`research/complex-block-rank-optimum`, whose proof credits Thomas DiFiore's
+helper-basis screen and Douglas Colkitt's fixed-word packing work. The generic
+dirty-connector interface descends from Ross Richardson's PR #934. This result
+adds only the frame-join/cap incompatibility lemma and its exact replay.
+
+## Open next questions
+
+- Can two or more accumulators partition the external inputs so each partial
+  source join lies in the caps of the targets it must still serve? A first
+  step is to specify the partition, each frame itinerary, and all transfers,
+  then compute a complete hosting/restoration bill.
+
+Authored by Cinna Davis with substantial OpenAI Codex assistance in scoping,
+proof development, exact verification and exposition.

research/single-connector-cap-obstruction-seed653bd5/SOURCES.json

@@ -0,0 +1,90 @@
+{
+  "schema_version": 1,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1",
+      "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075"
+    },
+    {
+      "path": "docs/research/community-batch1099-review.md",
+      "usage": "provenance",
+      "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099",
+      "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb"
+    },
+    {
+      "path": "research/community-frontier1094-audit/ASSEMBLY.json",
+      "usage": "provenance",
+      "git_blob": "5fd676df060f3b450782fdf5ff5f6beb63a5eeb0",
+      "sha256": "1122cb3a575f8c788345fc1bf4c108ac7c3250fb81a5988671f5eb04b3ab3045"
+    },
+    {
+      "path": "research/community-frontier1094-audit/SELECTED-SOURCE.json",
+      "usage": "provenance",
+      "git_blob": "6a75493790b4eff9c4a98051ef8b01d6aad0d5a8",
+      "sha256": "79b3de5db3dbcb9829789ba58e9e45758926031e2a7d80667a08429d369be53b"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/CERTIFICATE.json",
+      "usage": "input",
+      "git_blob": "59a9863fa8d823524cd42b6845c548089b6ef694",
+      "sha256": "d3ada9ac84a74f72ce9364dd47ee2ab9f02d1a6513df135e81dad11d0e6c6958"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/INPUTS.json",
+      "usage": "input",
+      "git_blob": "1fc0a9fb55e0bdb841ba457c9b92c6bdf496971d",
+      "sha256": "fef08f8a18429f1b68c5eb8657c7fbfc84492752e9639ae97e570a16f87490fe"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/README.md",
+      "usage": "input",
+      "git_blob": "77bd353fdadbfe7fea2fbca725e4ad04e9091d88",
+      "sha256": "f14fe8cee84ff43c8656e553885fc9cf2570e91fb794523343a3c2528905f835"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/inputs/pr1319-base.json.gz",
+      "usage": "input",
+      "git_blob": "eacf8c773cb50637f93a762342b3b5f0853fe29a",
+      "sha256": "e8e6e78ff7422275c38324499e1f33fb2ecd30de9503aef2b8f1ee80d8c4df8e"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/inputs/pr1319-extra.json.gz",
+      "usage": "input",
+      "git_blob": "4d464f55a2955e5c832b5ce789d5d0e0a39fb4e1",
+      "sha256": "7b0e9fbda32749aabc7e156d9fe09bceb0624a178628fe69e5dfea783462f905"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/inputs/selected-programs.json.gz",
+      "usage": "input",
+      "git_blob": "4eed995798f4aaa8efdd6f788dd07b3723940a81",
+      "sha256": "241fde27d4e43f5a9cb6b128f9f76c5131a53d09f0371676163f914d0b0fef3a"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/inputs/selected.json.gz",
+      "usage": "input",
+      "git_blob": "5f9ef680983b0b63a4c82a4ed909837b78e690cd",
+      "sha256": "16bc0ebb04b4be6c0ade74badc6a0c0cdba4215eda86e4ff9f13abf8ecebd219"
+    },
+    {
+      "path": "research/complex-block-rank-optimum/verify.py",
+      "usage": "input",
+      "git_blob": "5b08fcad862e6bd35d491bf49894e475396320b3",
+      "sha256": "3741b64dc76f771b74f06c80d4dfcbb6263bf34a790478640d813b59f8b38a3d"
+    },
+    {
+      "path": "research/universal-connector-boundary/README.md",
+      "usage": "provenance",
+      "git_blob": "d277f7c5830b1f2bc42e1ff41ab86e7d7564929f",
+      "sha256": "23415f7829ab8d80a783142f10f7d31abbce84579362769984680af3df954476"
+    }
+  ]
+}