Research: fixed-port two-projection connector with 10 frame XORs

research/two-projection-connector-seed51a5/NOTICE.md

@@ -0,0 +1,9 @@
+# Attribution and license
+
+Contribution by Cinna Davis with substantial OpenAI Codex assistance in the mathematical construction, exhaustive finite search, exact schedule replay, cost accounting and writing. New work is Apache-2.0 under the repository LICENSE. No independent human peer review is asserted.
+
+The fixed-alphabet connector predecessor is Ross Richardson's PR #943. Its current source certificate, interface statement and notice are pinned in SOURCES.json; no predecessor executable or code is imported.
+
+Nearest related open work was checked directly before the claim and again during packaging: PR #1531 (charged DUO source calls, head `892b28a3358b16c9083036f71e1ef505ccf5d20a`), PR #1770 (weighted one-row optimum, head `caae2d1a0b4497fbd5a7cd2d057d9a9b099f8873`), PR #1811 (fixed-alphabet parity-hyperplane rows, head `7ac80c37c843cdb48f48772dc46817d5f591fd3e`), and PR #1812 (paid two-root transfers, head `e43abcde1c98c718f5b4d0b25cf4cd9c04200bd8`). The present object keeps B/A calls at physical helper row z0 and uses both paid row-shear directions in a persistent two-row frame. PR #1812 instead allows B/A calls to select either root and counts eight one-way transfers. Those operation alphabets and costs differ. No priority claim is made for 72-call query coverage.
+
+The selected finite construction, its inherited assumptions, review and source assembly remain unchanged. This contribution is an abstract conditional interface result; no supplier adoption or new multiplication exponent is claimed.

research/two-projection-connector-seed51a5/PROOF.md

@@ -0,0 +1,101 @@
+# Exact construction and charged boundary
+
+## 1. Contract
+
+Work over the field F2 with five arbitrary source rows x0..x4, 31 arbitrary dirty output rows y_m indexed by masks m=1..31, and two arbitrary dirty helper rows z0,z1, all of common length L. The source and output maps B_j and A_m are arbitrary compatible exact F2-linear maps. The required map is
+
+```text
+y_m <- y_m + sum_{j in mask m} A_m B_j x_j
+```
+
+with every x_j and both helper rows unchanged. The old targets are arbitrary and are only incremented. The operation schedule is independent of row contents.
+
+The inherited one-row multiplication calls, acting in the current physical helper frame, are
+
+```text
+B_j: z0 <- z0 + B_j x_j
+A_m: y_m <- y_m + A_m z0
+```
+
+The changed interface permits paid invertible linear frame changes on the two helper rows. Each inherited B_j and A_m operation still acts on physical row z0; the frame maps it to a logical direction. The only extra operations are the charged row XORs u0 and u1. No product is combined with another product; no copy, clean row, overwrite or observation is used.
+
+## 2. Global frames and conjugated calls
+
+Represent the helper pair as a column z=(z0,z1)^T and a physical frame as p=Fz for an invertible 2x2 matrix F over F2. In the current frame, the base B_j call updates p0. In logical coordinates this injects
+
+```text
+F^-1 e0 * B_j x_j, where e0=(1,0)^T.
+```
+
+A base A_m call reads physical p0, so its logical readout covector is the first row e0^T F. The helper state is unchanged by A_m.
+
+Use the two one-CNOT frame generators
+
+```text
+u0 = [[1,1],[0,1]]    (physical z0 <- z0 + z1)
+u1 = [[1,0],[1,1]]    (physical z1 <- z1 + z0)
+```
+
+The identity frame gives source direction (1,0) and readout covector (1,0). Frame `u1` gives source direction (1,1). Frame `u0` gives readout covector (1,1). The implementation maintains a global frame instead of returning to identity after each call. A transition from current frame F to next frame G applies G F^-1 to the physical helper pair. Each generator used in this transition is charged as one full-row XOR. The final frame is identity.
+
+`EXPECTED.json` gives the frame action at each readout group and source call. At every boundary, readouts with the same covector are contiguous; when both covectors occur, both group orders are considered. The two covector classes require disjoint frame sets, and the target updates at one boundary commute, so interleaving the classes cannot shorten a frame path. A dynamic program over all six elements of GL(2,F2), the permitted frame sets for each action, and shortest generator paths finds the minimum transition cost for this fixed boundary-pair table: 10 full-row XORs. It does not minimize over alternative boundary pairs.
+
+## 3. Source path and projections
+
+Use the fixed source word
+
+```text
+0,1,0,1,2,3,4,2,4,3
+```
+
+Sources 0,1,2,4 use injection vector (1,0); source 3 uses (1,1). Each source therefore occurs twice in one fixed direction, so its complete contribution to the two helper rows is zero. This restores both helpers for every dirty incoming pair.
+
+For boundary t=0..10, let q_t in F2^5 be the XOR of source labels seen before that boundary. The (1,0) readout sees every source, so paired readouts at s,t contribute q_s+q_t. The (1,1) readout pairs with the injection vectors as
+
+```text
+(1,1) dot (1,0) = 1
+(1,1) dot (1,1) = 0
+```
+
+and therefore sees exactly sources 0,1,2,4. Its prefix is q_t^reg, the source-3-deleted path.
+
+Direct XOR of the eleven listed prefixes gives
+
+```text
+|D(q)| = 26
+|D(q^reg)| = 16
+D(q) union D(q^reg) = F2^5
+```
+
+The all-source projection misses exactly `10001`, `10010`, `10011`, `10101`, `10110`, and `10111`. All six occur as differences in the regular-source projection. `EXPECTED.json` records one strict pair s<t for each of the 31 nonzero masks and the readout covector used there.
+
+For output m, make two A_m calls at its certified boundaries using the same covector. The arbitrary incoming helper contribution appears in both calls and cancels in characteristic two. The remaining source contribution is exactly the boundary-difference mask. Since readout calls leave helpers unchanged and target rows are distinct, all 31 pairs can be interleaved with the fixed source word. Each target receives its requested map and nothing else.
+
+## 4. Lower bound and exact query count
+
+Every active source operator B_j must occur at least twice: one nonzero vector injection cannot restore an arbitrary dirty helper pair, and zero occurrences cannot produce the A_m B_j x_j term. Each nonzero output operator A_m needs at least two readouts: with all B_j=0, the aggregate readout covector on an arbitrary dirty helper pair must vanish, which a single nonzero covector cannot do. Therefore any schedule in this complete-call interface uses at least
+
+```text
+2*5 + 2*31 = 72
+```
+
+multiplication calls. The construction uses 10 source calls plus 62 readouts, meeting the bound. This is an exact lower bound only for the stated fixed-physical-port, two-row complete-call interface; no broader circuit lower bound is asserted.
+
+## 5. Full cost invoice
+
+The pinned one-row child prices in `research/universal-connector-boundary/CERTIFICATE.json` are
+
+```text
+B prices = (1,4,10,16,28)
+A_m price = 1 for all 31 outputs
+```
+
+Every B_j occurs twice, so the source-side invoice is 2*(1+4+10+16+28)=118 rank-one children. The 62 readouts cost 62, for 180 total. The pinned one-row `five_extra_output` schedule has ten source calls, 64 readouts and 182 children. Thus the two-row construction saves exactly two rank-one children and two complete calls relative to that schedule. PR #1770 at head `caae2d1a0b4497fbd5a7cd2d057d9a9b099f8873` reports the exact one-row weighted optimum 182 for these source/readout prices; that open PR is a comparator, not an imported dependency.
+
+The globally scheduled fixed-port frame charge is 10 full-row XORs, or 10L bitwise XORs, plus one additional L-bit dirty helper row. PR #1812 at head `e43abcde1c98c718f5b4d0b25cf4cd9c04200bd8` has a different two-root alphabet: B/A calls may choose either physical root, and its one-way transfer count is eight. Here every B/A call stays on physical row z0 while both shear directions implement the two projections. The contracts are not ordered without port-access and row-XOR prices. Independently conjugating each special B call and each nontrivial A readout would use 28 row XORs; frame persistence removes 18 of them for this fixed boundary table. The shortest-path proof is only for the certified pair choices. If P(L) denotes the value of a rank-one child and X(L) the value of a full-row XOR, the local arithmetic advantage over the pinned one-row optimum is 2P(L)-10X(L), with one additional helper row of storage. This break-even inequality leaves linear-operation constants and helper placement explicit. The package does not assert a finite-size win, supplier adoption, or a change to the accepted kappa.
+
+## 6. Bounded search and controls
+
+`verify.py` generates all 945 restricted-growth pair words and tests all 32 assignments of the two source directions. Across the full 30,240-candidate domain, it finds 175 two-projection full covers; this count is a bounded search result, not a universal impossibility statement. The selected witness is then checked by a literal physical-row replay whose seven basis symbols are the two arbitrary incoming dirty helpers and the five formal products B_j x_j.
+
+The verifier includes four negative controls: remove the second projection; make all source directions equal; corrupt one certified boundary pair; or omit a required frame-transition XOR. Each causes a mask failure or an invalid frame/helper state.

research/two-projection-connector-seed51a5/README.md

@@ -0,0 +1,48 @@
+# Fixed-port, two-projection, two-row five-source connector
+
+**Conditional recursive-interface construction; no selected-kappa change.** A second arbitrary dirty helper row lets a five-source universal connector use exactly two source calls per source and two output readouts per nonzero mask. Its 72 recursive map calls attain the elementary support floor, while the fixed single-row alphabet needs 74 calls. The construction pays 10 full-row XORs and one extra length-L helper row.
+
+The source word is
+
+```text
+B0 B1 B0 B1 B2 B3 B4 B2 B4 B3
+```
+
+Each source occurrence updates helper direction `[1,0]`, except source 3, which updates direction `[1,1]`. Output readouts use covector `[1,0]` for the all-source projection and `[1,1]` for the regular-source projection that ignores source 3. The all-source path has 26 prefix differences; the regular path has 16. Their union is all 32 masks of F2^5. The second projection supplies the six masks `10001`, `10010`, `10011`, `10101`, `10110`, and `10111` missing from the first.
+
+`EXPECTED.json` gives a boundary pair for every nonzero mask. `verify.py` independently enumerates the 945 canonical paired source words and all 32 direction assignments; 175 of the 30,240 candidates cover all masks using only the two stated readout projections.
+
+## Exact charged invoice
+
+The recursive map work is 10 B calls and 62 A readouts, 72 calls total. Under the child prices pinned in the current connector certificate, each B_j occurs twice at prices `[1, 4, 10, 16, 28]`, and each A_i is unit priced. This gives **180 rank-one children**. The current single-row `five_extra_output` certificate uses 10 source calls and 64 output readouts for 74 calls and **182 children**. The difference is exactly two rank-one children.
+
+The helper work is charged separately. Independently conjugating every nonidentity call would use 28 full-row XORs. A global-frame dynamic program over the six invertible two-row frames reuses the shears and reduces this to **10 full-row XORs** for the certified boundary table, or `10*L` bitwise XORs on length-L rows, plus one extra length-L dirty helper. `EXPECTED.json` records a shortest frame schedule for this fixed boundary table; it does not prove optimality over different readout boundary choices. There are no clean ancillas or data-dependent choices. Relative to the 182-child single-row schedule, the arithmetic part wins only when the actual value of these linear operations and helper storage fits below the two-child margin. In an exponent model they are lower-order linear work; no finite-size runtime advantage is claimed.
+
+The extended alphabet changes the fixed one-row restriction by adding a second dirty helper and paid transitions between two-row frames. Every inherited B_j and A_i call remains on physical helper row z0; the basis changes let those calls realize different logical injection/readout directions. There is no combined source query. The result is not tied to a selected-supplier occurrence and does not change the accepted kappa.
+
+## Reproduce
+
+From the repository root, using Python 3.10 or later and only the standard library:
+
+```sh
+python3 -I -O -B research/two-projection-connector-seed51a5/verify.py
+```
+
+Expected output:
+
+```text
+PASS_TWO_PROJECTION_CONNECTOR words=945 assignments=30240 full_covers=175 source_calls=10 readouts=62 calls=72 frame_xors=10 children=180 baseline_children=182 saved=2
+```
+
+The package manifest also provides the repository's registered Python 3.12 replay and source-pin check. `PROOF.md` gives the arbitrary-dirty-state argument and exact cost boundary.
+
+## Provenance and limits
+
+The fixed-alphabet predecessor is Ross Richardson's PR #943. Nearby open work includes PR #1531's charged DUO query, PR #1770's weighted one-row optimum, PR #1811's parity-hyperplane batch, and PR #1812's 72-call, eight-one-way-transfer construction with B/A port choice. This result fixes all B/A calls at physical row z0 and instead uses both paid row-shear directions in a persistent global frame. The contracts and resource vectors differ; no priority or cost-dominance claim is made for the general two-root batch.
+
+The accepted selected result remains the maintainer-reviewed conditional finite construction with kappa `836330098538459/500000000000000000`, complex-binding. This package is a local interface construction only. It does not show that the selected supplier can host the extra row or these frame changes, does not include them in the selected assembly, and claims no improved kappa.
+
+## Open next questions
+
+- Can different valid boundary pairs lower the 10-XOR frame schedule? The exact dynamic program minimizes frame changes only for the current 31 certified pairs; any improved schedule must retain the full dirty-state map and fit below the two-child margin.
+- Is there a source-pinned occurrence in the selected multiplier supplier where the extra dirty row and two readout projections are already available or can be hosted for less than the saved recursive-child cost? Without such an occurrence, the current result remains a conditional interface improvement.

research/two-projection-connector-seed51a5/SOURCES.json

@@ -0,0 +1,66 @@
+{
+  "schema_version": 1,
+  "base_commit": "0b1cccf86e2f5132ed286a26ef0a681a495740ea",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "06c96f5579bb67ed1b86d334e78fbed7da6945f1",
+      "sha256": "6686ad58f1fbdbc87134a78901b60fd53a20d3984355e91defbbebc9e9fa8075"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "ae6a99f28aa468649eb66a361e764d769363bf11",
+      "sha256": "10b9e340fd8e354a37a0c4813c90e5de1dd42044b5f6aca4a3fc5a42b685fa32"
+    },
+    {
+      "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"
+    },
+    {
+      "path": "docs/research/community-batch1099-review.md",
+      "usage": "provenance",
+      "git_blob": "6cb6ec061a071a06a2d18cd4dc3e9a2b05d28099",
+      "sha256": "7e76d2c38e5fce30587835b7251df1430488ae4dd372611ef69a3f03f476b6cb"
+    },
+    {
+      "path": "docs/research/community-batch1099-integration.json",
+      "usage": "provenance",
+      "git_blob": "9d60e86c0e494d17bec5e28eda41b275c9ede64e",
+      "sha256": "684c50d1ac69863e1fcc0a34bf76c54bac576f6bbde79b3c67d8432a495c8c1c"
+    },
+    {
+      "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": "research/universal-connector-boundary/NOTICE.md",
+      "usage": "input",
+      "git_blob": "d9afdf81f656278dab69239f0fd94924f97df87b",
+      "sha256": "1172648a1883827399d5103a9916deaa4314e4ee2c28653c183890f6bd5a7a17"
+    },
+    {
+      "path": "research/universal-connector-boundary/verify.py",
+      "usage": "input",
+      "git_blob": "de6483bb7ff51940dbbb76c18f91af4c907e07da",
+      "sha256": "e4fa4700f9e1ae6ca09c3c76ebc569e8361b89b699425a67839d999d8812e42d"
+    }
+  ]
+}