Census dynamic G20 helper captures (PR5586 B1): none pays for one helper or any pair

research/g20-dynamic-capture-census/PROOF.md

@@ -0,0 +1,96 @@
+# Dynamic captures on the PR5708 G20 word: model and argument
+
+## Word model
+
+The local word is `research/g20-conjugation-admission/WORD.json.gz` with the
+frames of its vendored G20 source. Wire i starts with the symbol x_i. A
+payload is a finite F2 sum of terms M x_i, M an exact 8x8 rational matrix
+(a product of frame reflections R_f = I - 2 P_f). `ADD d s f` adds the
+payload of s to d; `Q d s t k` is a paid query of rank k and multiplies by
+R_s R_t; `ZERO_Q` moves a zero payload for free; `ERASE`/`INIT` touch owned
+wires only. The replay checks every frame, rank and zero move and reproduces
+the published local paid profile {1:1281, 2:1338, 3:58, 4:57, 5:102, 6:10}.
+Helpers are the 415 retained non-main wires; their target ranks are the
+frame-dimension differences (413 rank 8, helpers 465 and 684 rank 4).
+
+## Captures
+
+Owning a set H of helpers debits sum over H of r_h^t. For h in H, h is
+*dead-forward* before event i when its content then reaches no retained
+output other than outputs of H (backward replay of the exact operators).
+In each maximal dead interval [a, b] that contains no read of h, writes into
+h are dropped and h is held zero, so its own queries in [a, b) become free
+`ZERO_Q` moves. Just before event b, h receives an arbitrary payload w
+(ERASE plus same-frame ADDs). Scalar costs of these changes are not charged,
+which can only favour a capture.
+
+## Exact kill condition
+
+A forward replay injects a fresh symbol u into h before each b. Since the
+operators act linearly, the true payload of every query is
+
+    p_q = rest_q + sum M_(q,s) (w_s + snap_s),
+
+where rest_q is the replayed payload with injected symbols removed and owned
+input symbols set to zero, snap_s is the replayed content of h just before
+the injection (owned inputs zeroed), and M_(q,s) is the coefficient of u_s.
+The replay checks that every such coefficient is a single matrix and that no
+injected symbol reaches a retained output outside H. A query is removed iff
+p_q = 0.
+
+*Single dependence.* If q depends on one injected symbol, it is removed iff
+w_s = M^-1 (rest_q + M snap_s): one exact value. Queries are grouped by that
+value; the best group of each epoch is the most a single injection removes.
+For one helper every query depends on one symbol, so the single-helper census
+is exact. On PR5708 every helper has two dead intervals (before its first
+read and after its last) and so one injection; the leading interval never
+contains a read of the helper.
+
+*Parity classes.* Let parity(p) be the F2 sum of the symbol masks over all
+matrices. It is F2-linear and parity(M p) = parity(p) for one invertible
+matrix M. If q depends on a set D of injected symbols and p_q = 0, then
+
+    parity(rest_q) + sum_(s in D) parity(snap_s) = sum_(s in D) parity(w_s).
+
+The left side is a label computed from the word; all removed queries with the
+same D share one label. Hence the removed mass of queries with dependence D
+is at most the heaviest label class.
+
+## Pairs
+
+Individual schedule (each helper keeps its own dead intervals): for pair
+(a, b) the gain is at most free(a) + free(b) + best(a) + best(b) + heaviest
+class of the shared queries - 8^t(a) - 8^t(b). The 5638 pairs where this is
+not positive are closed. When no single-dependence query is removed, the gain
+is at most free + heaviest class - debits, which is negative for every pair
+(checked). Otherwise w_a lies in the group values of a (or zero) and w_b is
+in the group values of b, zero, or forced by one shared query; symmetrically.
+All such candidates are evaluated exactly for the 392 remaining pairs; the
+best gain is -1.957.
+
+Joint schedule: a backward replay finds five pairs (h, p) where the content
+of h at some time reaches only the outputs of h and p. Owning both lengthens
+dead intervals. Each pair is reanalysed with joint deadness; four close by
+the class bound and the pair (297, 684) by exact enumeration (-1.968).
+
+## Joint token bound
+
+Under the individual schedule, a removed query satisfies
+parity(p_base) = sum over owned h it depends on of (e_h + b_h), where b_h
+collects the parities of w_h and of the dropped writes. So every removed
+base-word parity row lies in a d-dimensional space for d owned helpers. Give
+each eligible query ceil(4 r^t) copies of its row (2213 queries, 15544
+tokens) and greedily split them into N = 26 F2-independent sets. A
+d-dimensional space meets each set in at most d vectors, so the removed
+t-mass is at most 26 d / 4 = 6.5 d, plus at most one free own query per
+helper (rank at most 2, checked). A helper with a free own query of rank 1 or
+none therefore contributes at most -0.439; one with a free rank-2 query at
+most +0.556. The greedy N is an upper bound; the true minimum may be smaller.
+
+## Limits
+
+The joint token bound uses individual dead intervals; joint deadness is
+checked for pairs only. Sets of three or more helpers containing several
+helpers with a free rank-2 query are not decided. All decisions use
+double-precision moments with margins above 1e-3, except the exact neutral
+case of helper 684 (one H4 removed for one H4 target).

research/g20-dynamic-capture-census/README.md

@@ -0,0 +1,84 @@
+# Dynamic helper captures on the final G20 BIT word
+
+On the exact PR5708 G20 local word (conditional ordinary BIT saving
+0.003507719059749), no owned-helper capture of the PR5586 **B1** kind pays
+its target for one helper or for any pair of helpers, with an arbitrary
+injected payload at every epoch. Every retained helper has exactly **one
+live interval**, so the multi-epoch premise of B1 has no instance on this
+word. A joint parity-token bound limits larger owned sets. The complete
+search over sets of three or more helpers is left open below, with a
+concrete encoding. No new kappa or supplier admission is claimed.
+
+Claim type: finite exact census with a scoped linear-algebra argument.
+Base: canonical main `19fdb086ea96af9a9f87936a2b888e10af4ed810`.
+
+## Results at the B1 target C = 0.0037 (t = 1 - C)
+
+| Check | Result |
+|---|---|
+| Needed over the PR5708 invoice | +40.952 signed moment, +2.2751 per local word (18 calls) |
+| Debit of one owned full helper | 8^t = 7.9387 |
+| Single helper, arbitrary injection, all epochs (415 helpers) | none pays; best 0 (helper 684, H4 for H4); max removed rank mass 7 |
+| Live intervals per helper | exactly 1 for all 415 |
+| Pairs whose joint ownership lengthens a dead interval | 5, all lose (exact best -1.968) |
+| Pairs with a shared query, individual schedule | 6030: 5638 closed by the parity-class bound, 392 enumerated exactly; best -1.957 |
+| Joint token bound, any owned set | removed t-mass at most 26/4 = 6.5 per owned helper, plus its free own query |
+| Consequence | a set gains only through the 180 helpers with a free rank-2 own query (at most +0.556 each); reaching 0.0037 needs at least 5 of them, all compatible |
+
+Positive control: on the PR5667 word (the source of Ali Romman's PR5671,
+from Dugongue's PR5665 theorem) at C = 0.0035 the same single-helper census
+finds exactly the nine selected late-binding helpers of PR5671
+(223, 319, 331, 344, 371, 375, 484, 501, 551), each as a free own H1 plus one
+removed H7. No other helper is positive there.
+
+## Reproduce
+
+```sh
+python3.12 -B scripts/research_package.py --package research/g20-dynamic-capture-census
+python3.12 -I -W error -B research/g20-dynamic-capture-census/verify.py
+```
+
+Python 3.12 and the standard library suffice; one run takes under a
+minute. Expected final token: `PASS_G20_DYNAMIC_CAPTURE_CENSUS`. The
+verifier authenticates the pinned inputs in SOURCES.json, checks the PR5708
+local paid profile, recomputes every number above and compares RESULT.json
+in full. `--write` regenerates RESULT.json. [PROOF.md](PROOF.md) gives the
+model, the exactness argument and the precise scope.
+
+## Scope
+
+The word, its frames and its native contract are used as published. Captures
+own retained helpers, drop writes into a helper while it is dead-forward,
+and inject arbitrary payloads by ordinary same-frame scalar operations; the
+scalar fees of those injections are not charged, which only helps a capture.
+Paid frame conversions, added contacts, changed scalar order and changed
+words are outside this census. Native/ROW, compiler, ordinary backend,
+precision and tape premises of the source framework are unchanged and not
+replayed. This is an author check, not independent acceptance.
+
+## Open next questions
+
+- **Complete joint search for three or more helpers.** Only sets built
+  mostly from the 180 helpers with a free rank-2 own query can still gain,
+  at most +0.556 per helper by the token bound. Encode candidate injections
+  with their exact matrix-level kill conditions and solve the weighted
+  maximum consistent subset (ILP or MaxSAT) with the moment gain as
+  objective; check any witness with `capture.py`. Expected outcome is
+  negative, but it is not proved here. Volunteers are welcome.
+- **Changed words.** B1 needs helpers with several live intervals or larger
+  shared queries. Run `capture.py` on any new G20 successor word: a second
+  live interval or a positive single-helper bound is the signal.
+
+TASK.json records both questions.
+
+## Credit
+
+Dugongue proposed B1 in PR5586 and the deferred-input theorem in PR5665.
+Ali Romman supplied the nine-owned-relation method (PR5421), the static
+entry-capture capacity bound whose token argument is adapted here (PR5604),
+the PR5671 late-binding admission used as the control and the PR5679/PR5708
+words. Credit ai-nanachi's PR5512 G20 source and all native, controller,
+helper, ordinary and stock predecessors named in those packages. Nick
+Petalas's PR5983 covers a different (split) mechanism on the same word.
+Prepared for Matarener with substantial Anthropic Claude assistance
+(Claude Code). Apache-2.0.