Price one connector reset at eleven five-source queries (exact 63, no κ)

research/one-way-connector-reset-batch/NOTICE

@@ -0,0 +1,15 @@
+A one-way connector reset makes the five-source batch exactly 63 queries
+Copyright 2026 Nick Petalas. Licensed under Apache-2.0.
+
+This contribution was produced by Nick Petalas.
+
+The connector contract, the five-source 945-pairing census, the restored exact
+74-query value and the four-source 38-query value are Ross Richardson's #934
+lineage as recorded in research/universal-connector-boundary/README.md. Those
+are cited premises; this package does not replay or audit them. The
+two-connector packages research/two-connector-transfer-boundary/ and its
+successors define the reset-free neighbouring interface and explicitly exclude
+connector resets. Cinna Davis's open #2249 and #3909 study larger source
+alphabets at the same connector, and are related but distinct extensions. The
+reflected Gray code is classical. No predecessor code is included in this
+package.

research/one-way-connector-reset-batch/PROOF.md

@@ -0,0 +1,159 @@
+# Proof: one reset makes the five-source connector batch exactly 63 queries
+
+Written proof with an exact finite certificate. No `kappa`, no supplier
+admission. Produced by Nick Petalas.
+
+## 1. Interface
+
+Use Ross Richardson's universal connector contract as recorded in
+`research/universal-connector-boundary/README.md` (PR #934 and the five-source
+boundary package). Sources `x_0,...,x_{n-1}`, one connector row `z`, output
+rows `y_i`, all over `F2`. All maps `B_j` and `A_i` are arbitrary `F2`-linear,
+possibly noncommuting and noninvertible; sources are read-only; the connector
+and the outputs are arbitrarily dirty. A *complete query* is either
+
+    B_j:  z   += B_j x_j          (source call)
+    A_i:  y_i += A_i z            (readout)
+
+and the batch is correct when `y_i` ends as
+`y_i + A_i (sum_{j in m_i} B_j x_j)` and every other row is restored.
+
+Write `b_j = B_j x_j`. Two cited facts from the predecessor:
+
+* **(P1) even incidence.** Restoration forces every `B_j` count even and every
+  `A_i` count even. The predecessor proves this by specializing to `L = 1`,
+  identity maps, independent source bits and an independent dirty connector
+  bit.
+* **(P2) exact restored five-source value.** The 945-canonical-word census
+  excludes ten source calls, so the restored minimum is `T(5) = 12`, and the
+  all-31-nonzero-mask batch costs exactly `74 = 12 + 2*31`. The four-source
+  case is `38 = 8 + 2*15` with `T(4) = 8`.
+
+Both are cited inputs. They are not replayed or re-audited here.
+
+## 2. The extended alphabet
+
+Add exactly one operation
+
+    Z:  z := 0                    (reset, one complete query)
+
+and change one boundary premise: **the connector is consumed**. Its exit value
+is unconstrained, so no restoration of `z` is owed. Every other clause of the
+contract is unchanged, including restoration of all other rows, read-only
+sources, complete fixed-port calls and unit query prices. A caller that still
+needs the old connector value must save and restore it, which is a separate
+charged obligation and is not used below.
+
+The reset is not free: it is one complete query in every count that follows.
+
+## 3. Upper bound: the Gray schedule
+
+Let `g_0,...,g_{2^n-1}` be the reflected Gray code of `F2^n`: `g_0 = 0`, every
+consecutive pair differs in one coordinate, and every vertex occurs once. The
+schedule is
+
+    Z;  then for k = 1..2^n-1:   B_{j_k}  (the coordinate flipping into g_k)
+                                A_{g_k}  (one readout of the row with mask g_k)
+
+After the reset, `z = sum_{j in q} b_j` where `q` is the current prefix, so the
+readout at `g_k` contributes exactly `A_{g_k} b_j` for `j in g_k`. Each row is
+read once, at its own vertex, and no `A_i z_0` term survives because `z_0` was
+destroyed by the reset. Row `i` therefore ends as
+`y_i + A_i (sum_{j in i} B_j x_j)`, and `z` is left dirty, which the one-way
+contract permits.
+
+Counts: `1` reset, `2^n - 1` source calls, `2^n - 1` readouts, hence
+
+    Q(n) = 2^(n+1) - 1.
+
+At `n = 5` this is `1 + 31 + 31 = 63`. `verify.py` replays this schedule for
+`n = 1..8` in a free symbol model and checks the three literal counts.
+
+## 4. Lower bound
+
+Let a legal schedule use `r` reset calls, `T` source calls and `R` readouts, so
+`Q = r + T + R`. Since `Z` sets `z := 0` and no operation recreates `z_0`, the
+coefficient of `z_0` in the connector is `1` before the first reset and `0`
+after it. Call a readout *clean* when that coefficient is `0`. Let `S` be the
+set of distinct nonzero clean single-readout values.
+
+*Clean values are prefixes.* A clean readout sees `sum_{j in q} b_j` for a
+prefix set `q` reached after the last reset. A walk of `T` steps visits at most
+`T + 1` vertices including `0`, so `|S| <= T`.
+
+*Every mask needs a readout.* Row `i` ends as a sum of the values it read; with
+no readout it cannot change, so `R >= 2^n - 1`.
+
+*Masks outside `S` need two readouts.* A readout with the `z_0` coefficient `1`
+leaves `A_i z_0` in row `i`, which the generic requirement forbids (row `i`
+must not depend on the dirty connector content). So a single readout realizes
+a mask only when it is clean and equals that mask, i.e. only for masks in `S`.
+Hence
+
+    R >= (2^n - 1) + #{ m != 0 : m not in S } >= 2(2^n - 1) - |S|
+      >= 2(2^n - 1) - T.
+
+**Case `r >= 1`.** `Q = r + T + R >= 1 + T + 2(2^n - 1) - T = 2^(n+1) - 1`.
+The `T` cancels: a longer walk buys no discount, because every extra prefix
+value is paid for by one extra source call.
+
+**Case `r = 0`.** There is no clean readout, so (P1)'s parity argument gives an
+even number of readouts per active row, hence `R >= 2(2^n - 1)`. Also `T >= 1`
+for every `n >= 1`, since a nonzero mask needs two distinct prefix values that
+differ by it. Therefore `Q >= 2^(n+1) - 1`. Equality needs `T = 1` and exactly
+two readouts per mask; for `n >= 2` one source call cannot supply the
+`2^n - 1 >= 3` distinct masks, so the inequality is strict.
+
+Combining both cases with Section 3:
+
+    exact optimum = 2^(n+1) - 1   for every n >= 1,
+
+attained by the Gray schedule. `verify.py` recomputes this optimum completely
+for `n = 2, 3` by enumerating every visited vertex set, its shortest walk and
+its cheapest readout assignment, and obtains `7` and `15`.
+
+## 5. What restoration costs
+
+The two contracts differ only in whether `z` must be restored, and in the one
+reset call. Their exact values are:
+
+| sources `n` | restored, cited | one-way, this package | saving |
+|---|---:|---:|---:|
+| 4 | 38 = 8 + 30 | 31 | 7 |
+| 5 | 74 = 12 + 62 | 63 | 11 |
+
+In both rows the saving is exactly `T(n) - 1`: the restored minimum source-call
+count minus the single reset. The `2(2^n - 1)` readout term is identical. So
+the restoration requirement costs the *pairing* structure, not a readout per
+mask: a naive comparison would predict a saving of `2^n - 1` (31 at five
+sources), and the exact answer is `T(n) - 1` (11), because the pairing contract
+can only afford a 12-call walk while single readouts need a 31-vertex walk.
+
+For general `n` the same comparison gives a lower bound of `2n - 1` on the
+saving, since (P1) forces `T(n) >= 2n`.
+
+## 6. The reset is essential at five sources
+
+Dropping restoration but keeping the reset forbidden is not enough to reach 63.
+Without a reset every readout is dirty, so every row needs an even read count
+and `R >= 62`; a row with mask `m` then needs two visited prefixes differing by
+`m`. A walk of `T` steps supplies at most `T + 1` vertices, and `|P| = 8` gives
+`C(8,2) = 28 < 31` pairs, so `|P| >= 9`.
+
+If `|P| = 9` the walk has at least 8 steps, and exactly 8 makes it a simple
+path. `verify.py` enumerates **all 70,846 simple 8-step paths from `0` in the
+5-cube** and finds maximum pairwise-difference coverage **28 of 32**; the
+predecessor's closed ten-call census reaches 31 with eleven vertices, which is
+outside this family. Hence `T >= 9`, and every reset-free five-source schedule
+costs at least `9 + 62 = 71 > 63`.
+
+## 7. Scope
+
+This is a scoped exact result in the abstract query alphabet at unit prices. It
+is not a `kappa` improvement, not a supplier admission, and not a claim about
+physical arity-four or arity-five source operators, nonuniform per-port
+tariffs, routing, or word-dependent storage. It does not assert that a caller
+can freely discard a shared connector: that is the changed premise, charged as
+one reset query, and a caller needing the old value pays a separate save and
+restore. The 74 and 38 values and the `T(5) = 12`, `T(4) = 8` counts are cited
+from the predecessor, not recomputed here.

research/one-way-connector-reset-batch/README.md

@@ -0,0 +1,116 @@
+# One reset makes the five-source connector batch exactly 63 queries
+
+**Scoped exact result with a finite certificate and a written lower bound; no
+new kappa.** Produced by Nick Petalas.
+
+The universal five-source dirty connector costs exactly **74 complete queries**
+for the batch of all 31 nonzero masks (Ross Richardson's #934 contract as
+recorded in `research/universal-connector-boundary/`). This package adds one
+operation and changes one boundary premise:
+
+    Z:  z := 0        one complete query, and the connector is consumed
+                      (its exit value is unconstrained).
+
+Under that alphabet the exact optimum drops to **63 = 2^6 - 1**:
+
+    1 reset  +  31 source calls  +  31 readouts.
+
+The 31 source calls are a reflected-Gray walk of the 5-cube; each readout sits
+at the vertex whose mask is its own output row, so every row is read exactly
+once. The matching lower bound is `2^(n+1) - 1` for **every** `n >= 1`, so the
+closed form is not a five-source accident. `verify.py` replays the schedule for
+`n = 1..8`, and recomputes the complete optimum for `n = 2, 3` from every
+visited vertex set.
+
+```sh
+python3.12 -B research/one-way-connector-reset-batch/verify.py
+```
+
+Expected:
+`PASS_ONE_WAY_CONNECTOR_RESET exact_n1..8=3,7,15,31,63,127,255,511 optimum5=63 restored5=74 saving5=11 reset_free5_floor=71 nine_point_coverage=28 paths=70846 controls=6`
+
+## What the number says
+
+The saving is **11**, not the 31 that a "one readout per mask" comparison
+suggests. The readout term `2(2^n - 1)` is the same under both contracts; what
+changes is the source word. Restoration can afford a 12-call paired walk,
+single readouts need a 31-vertex walk, and the difference is exactly
+`T(n) - 1`:
+
+| sources | restored (cited) | one-way (here) | saving |
+|---|---:|---:|---:|
+| 4 | 38 | 31 | 7 |
+| 5 | 74 | 63 | 11 |
+
+So connector restoration is worth exactly `T(n) - 1` queries at these arities,
+and at least `2n - 1` in general. The dominant term in both contracts is the
+`2^n - 1` readouts, which no boundary change in this alphabet removes.
+
+The reset is not decoration. Keeping the connector one-way but forbidding the
+reset still leaves every readout dirty, so every row needs an even read count
+and the cheapest design costs at least `9 + 62 = 71`: `verify.py` exhausts all
+70,846 simple eight-step paths from `0` in the 5-cube and finds pairwise
+coverage at most 28 of 32, which rules out a nine-vertex difference basis and
+forces a ninth source call. The reset, not the missing restoration, is what
+buys the last eight queries.
+
+## Interface and price ledger
+
+Unchanged from the predecessor: sources `x_j`, connector `z`, outputs `y_i`,
+arbitrary `F2`-linear possibly noncommuting maps `B_j`, `A_i`, read-only
+sources, arbitrary dirty `z` and `y_i`, complete fixed-port calls, unit query
+prices, all rows restored except the requested output sums. The single change
+is the exit contract for `z` plus the one reset call. A caller that needs the
+old connector value must save and restore it; that is a separate obligation and
+is not priced here, so this is not a claim that every caller can discard a
+shared connector for free.
+
+## Claim type and evidence
+
+Scoped written proof with an exact finite certificate:
+
+* `PROOF.md` proves `2^(n+1) - 1` in two cases (`r >= 1` and `r = 0`), with the
+  counting lemma that every extra prefix value is paid for by a source call.
+* `verify.py` replays the literal schedule in a free noncommutative symbol
+  model, checks the three counts, recomputes the complete optimum for `n = 2,3`,
+  runs the complete eight-step path census for the reset-free floor, and applies
+  six rejection controls.
+
+It is not a kappa improvement, not a supplier admission, and not a complete
+multiplication theorem. The 74 and 38 values and the restored source-call
+counts `T(5) = 12`, `T(4) = 8` are cited from the predecessor; this package does
+not replay or audit its 945-word census.
+
+## Related open work
+
+* `research/universal-connector-boundary/` (PR #934 lineage, five-source
+  boundary): supplies the contract, the 945-pairing census, the restored exact
+  74 and the four-source 38. Cited, not replayed.
+* PR #3909 (open): a five-source arity-four source event priced as one dispatch
+  plus four additions, whose schedules cost at least 149 units. That extension
+  enlarges the source alphabet; this one enlarges the connector contract. The
+  two results are complementary and neither implies the other.
+* PR #2249 (open): a high-arity six-source toggle floor with `f(6) = 16`. It
+  studies larger arities and larger alphabets; this package stays at unit
+  weight source calls and changes only the exit contract.
+* `research/two-connector-transfer-boundary/`: two connectors with a paid
+  transfer, explicitly excluding connector resets. This package analyzes the
+  excluded operation, at one connector.
+
+## Open next questions
+
+* **Does a save-and-restore wrapper keep the gain?** A caller that must return
+  the old connector value needs one admitted clean row plus copy and restore
+  calls. Price that wrapper exactly; the favourable region is narrow (below
+  74 - 63 = 11 units at five sources), and no such row is assumed here.
+* **Can a nonuniform tariff change the ranking?** The 63 count uses unit
+  prices. With `c_Z`, `c_B` and `c_A` arbitrary positive prices, does the Gray
+  schedule still dominate the paired design whenever `c_Z` is small, and what
+  is the exact crossover?
+* **What is the reset-free floor at general `n`?** At five sources the floor is
+  71 by a complete eight-step path census. The analogous minimum difference
+  basis size for `n >= 6` is open here, and the predecessor's six-source floor
+  is a different quantity.
+* **Does a bounded number of resets help a partial mask set?** For a sparse
+  set of requested masks, resetting between blocks may beat one long walk; the
+  exact tradeoff is not computed here.

research/one-way-connector-reset-batch/SOURCES.json

@@ -0,0 +1,18 @@
+{
+  "schema_version": 1,
+  "base_commit": "e54523517d0f03e58352e647c403a5af3e525a57",
+  "files": [
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "75d77b328ea02ded535e7f23aee5b1e55d0bb1a8",
+      "sha256": "154c3d30455d778fd3343b6b4851f0fa4665f0f7625b0adb3675e2bafbbf6bf1"
+    }
+  ]
+}