Reach the unsigned connector floor for k ≤ 2c in every characteristic; 9 ≤ N(4) ≤ 21 (no new κ)

research/connector-depth-blocks/CERTIFICATE.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 1,
+  "characteristic": 4,
+  "readout_rule": "four unsigned A_m readouts at walk boundaries t1<=t2<=t3<=t4, lexicographically first multiset whose prefix-count sum mod 4 equals the binary mask of m",
+  "floor_walks": {
+    "9": [4, 2, 6, 4, 0, 8, 1, 7, 3, 2, 5, 2, 1, 7, 4, 3, 0, 2, 5, 8, 6, 5, 6, 4, 8, 3, 1, 0, 5, 7, 8, 7, 0, 3, 6, 1]
+  }
+}

research/connector-depth-blocks/README.md

@@ -0,0 +1,195 @@
+# Unsigned connector: depth blocks reach the floor for k ≤ 2c
+
+Take the unsigned dirty connector over a ring of characteristic c ≥ 2, with k
+immutable sources and all 2^k − 1 nonzero binary-mask outputs. Every legal word
+needs at least c(k + 2^k − 1) complete calls
+([#4231](https://github.com/CrocSwap/integer-mult-bounds/pull/4231)). Let N(c)
+be the largest k at which that floor is attained. This package shows:
+
+- **Theorem A** (proof, checked for c ≤ 7): N(c) ≥ 2c for every c ≥ 2.
+  Concatenated two-source blocks give the floor word. This improves #4231's
+  run walk, which reaches k ≤ c.
+- **Lemma C** (proof, exhaustive control at k = 3): a block whose masks are
+  all single prefixes has at most two sources. Beating 2c with blocks needs a
+  depth-d block with more than 2d sources.
+- **Characteristic four** (finite certificate plus proof): an explicit
+  36-event walk attains the floor of 2,080 calls at k = 9. With the deletion
+  lemma and a counting bound, **9 ≤ N(4) ≤ 21**. This answers part of
+  #4231's open question 1, which asked where the c = 4 floor first fails.
+- **Counting** (proof): N(c) is below the first k with
+  C(ck + c − 1, c) < 2^k − 1. That k is 7, 14, 22, 30, 38, 47, 56, 65 for
+  c = 2..9.
+
+At c = 2, Theorem A is sharp: #943 shows that five sources fail. At c = 3 it
+gives n ≤ 6, the range proved in
+[#4232](https://github.com/CrocSwap/integer-mult-bounds/pull/4232). At c = 4
+the nine-source walk shows that blocks are not optimal.
+
+The claims are a scoped proof plus a finite certificate. There is no new κ, no
+selected-frontier change and no multiplication theorem.
+
+## 1. Interface and prefix criterion
+
+The interface is #4231's. R is a nonzero unital ring of characteristic c. The
+rows are k read-only sources x_j, outputs y_m for m = 1, …, 2^k − 1 and one
+borrowed dirty connector z. For arbitrary R-linear maps B_j and A_m, the word
+must implement
+
+```text
+y_m += sum_(j: bit_j(m)=1) A_m B_j x_j,   x_j and z unchanged.
+```
+
+The only calls are `B_j: z += B_j x_j` and `A_m: y_m += A_m z`. Signed calls,
+extra connectors, scaling, frame changes and free copies are not admitted.
+
+#4231 proves the floor: B_j and A_m each occur a positive multiple of c times.
+A floor word therefore has a source walk w of length ck that uses each source
+exactly c times. Let q_t ∈ (Z/c)^k count source events modulo c after t steps.
+If A_m reads at boundaries t_1 ≤ … ≤ t_c, output m receives
+A_m(c·z0 + Σ_j (Σ_i q_(t_i))_j B_j x_j). Since c·z0 = 0, the word is correct
+exactly when
+
+```text
+q_(t_1) + ... + q_(t_c) = m   in (Z/c)^k     for every nonzero mask m.
+```
+
+z is restored because each B_j x_j is added c times. This is the c-fold form of
+#4232's triple criterion. Integer coefficients act through Z/c, the prime
+subring of R, so no commutation of A_m with B_j is used.
+
+## 2. Theorem A: N(c) ≥ 2c
+
+Say a walk on source set S has **depth d** if every nonzero S-mask is a sum of
+at most d prefixes q_t.
+
+**Concatenation.** Let P and P′ be walks on disjoint source sets, each source
+used c times, with depths d and d′, where d + d′ ≤ c. In PP′, the prefix at a
+boundary inside P′ is (0, q′) because P returns to zero modulo c. A mask
+(m, m′) is the sum of the prefixes for m in P and for m′ in P′. The
+remaining readouts go to boundary 0, which has prefix zero. So PP′ has
+depth d + d′, and by induction blocks with total depth at most c give a floor
+walk.
+
+**Blocks of depth one.** For sources a and b, take
+
+```text
+a b a^(c-1) b^(c-1)
+```
+
+Its prefixes include (1,0) after one step, (1,1) after two and (0,1) after
+c + 1. The one-source block a^c has prefix 1 after one step. Pair the k sources
+into ⌈k/2⌉ ≤ c blocks. Each mask then reads once at one boundary in every block
+where it is nonzero, and at boundary 0 for the remaining readouts.
+
+The verifier builds this word for all 54 pairs (c, k) with 2 ≤ c ≤ 7 and
+k ≤ 2c. It simulates each with generic coefficients and checks that every
+operator is called exactly c times. At (c, k) = (3, 7), four blocks are needed
+and the construction is rejected.
+
+## 3. Lemma C: depth-one blocks carry at most two sources
+
+In a walk that uses source j exactly c times, coordinate j of q_t is 0 before
+its first event and after its last. It is 1 between its first and second
+events, and lies in {2, …, c − 1} between its second and last. A prefix is
+binary exactly when no coordinate is in that middle stage. Its support is
+{j : first_j ≤ t < second_j}. That set changes only at the 2k first and second
+events, so there are at most 2k distinct nonzero binary prefixes. Since
+2^k − 1 > 2k for k ≥ 3, a depth-one walk has at most two sources.
+
+As a control, the verifier enumerates all 90, 1,680 and 34,650 three-source
+walks for c = 2, 3 and 4. None has depth one.
+
+Under concatenation, a block of depth d therefore adds more than 2 sources per
+unit depth only if it has more than 2d sources. The nine-source c = 4 walk
+below has depth 4, so it is such a block.
+
+## 4. Characteristic four: 9 ≤ N(4) ≤ 21
+
+[CERTIFICATE.json](CERTIFICATE.json) gives the walk
+
+```text
+4 2 6 4 0 8 1 7 3 2 5 2 1 7 4 3 0 2 5 8 6 5 6 4 8 3 1 0 5 7 8 7 0 3 6 1
+```
+
+Each of the nine sources occurs four times. The verifier regenerates, for each
+of the 511 masks, the lexicographically first boundary multiset of size four
+that sums to it. It then builds the literal 2,080-call word, simulates it with
+generic coefficients, and runs it on random singular, noncommuting 2×2
+matrices over Z/4.
+
+**Deletion lemma.** This is #4232's lemma; its proof does not use c = 3.
+Delete the c events of source j from a floor walk. Each old boundary maps to a
+new boundary with the same counts on the other sources, so every mask with bit
+j zero keeps its readouts. The attaining set is therefore an initial segment
+{1, …, N(c)}. The verifier checks all nine deletions of the certified walk.
+
+**Counting.** Boundaries 0 and ck both have prefix zero, so the readouts of a
+mask are a multiset of size c drawn from ck boundary indices. There are
+C(ck + c − 1, c) such multisets. For c = 4, C(87, 4) = 2,225,895 ≥ 2,097,151
+at k = 21, but C(91, 4) = 2,672,670 < 4,194,303 at k = 22. With the deletion
+lemma, every k ≥ 22 fails. At c = 3 the threshold is 14, as in #4232. The
+verifier checks the table for c ≤ 9 and that failure persists up to k = 200.
+
+## 5. Search notes (local only, not proofs)
+
+The nine-source walk came from simulated annealing over restored 36-event
+walks. These are search failures, not exclusions:
+
+- Eight annealing runs over 40-event walks did not reach all 1,023 masks at
+  k = 10.
+- No depth-two five-source block at c = 4 was found; the best run covered 28 of
+  31 masks.
+- No depth-three seven-source block was found; the best run covered 125 of 127.
+
+Depth-two blocks on four sources and depth-three blocks on six exist at c = 4.
+They reach only eight sources by concatenation. The search programs and logs
+are not committed.
+
+## 6. Reproduction
+
+From the repository root:
+
+```sh
+~/git/integer-mult-bounds/.venv/bin/python3.12 -W error -B research/connector-depth-blocks/verify.py
+~/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/connector-depth-blocks
+~/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/connector-depth-blocks --check-source-history
+```
+
+Expected marker:
+`PASS_CONNECTOR_DEPTH_BLOCKS blocks_k<=2c c4_attained_k<=9 c4_counting_excludes_k>=22`.
+The verifier uses only the standard library and takes about 3 s. It prints a
+receipt hash bound to all six package files. Six mutation controls must be
+rejected: a dropped call, a doubled readout, a relabelled source call, the
+c = 4 word read in characteristic eight, the sorted run walk at k = 9, and the
+block construction at (c, k) = (3, 7).
+
+## 7. Limitations
+
+The result covers only the unsigned, immutable-source, complete-call interface
+of #4231. Theorem A is proved for every c; the word check runs for c ≤ 7.
+Fixed call prices must include their full implementation. Input admission,
+coefficient preparation, dispatch and physical costs are additional and
+unknown. No consumer is instantiated. The exact value of N(4) and the growth
+of N(c) remain open. Proof-kernel checks and independent human review are not
+claimed.
+
+## Open next questions
+
+These are recorded with first steps in [TASK.json](TASK.json).
+
+1. What is N(4) exactly, within 9 ≤ N(4) ≤ 21? Every ten-source floor walk
+   restricts to a nine-source one, so an insertion search over nine-source
+   floor walks is a natural first step.
+2. How does N(c) grow? Theorem A gives 2c and counting gives O(c log c). A
+   depth-d block with more than 2d sources, valid for every large c, would
+   improve the constant.
+3. Does any concrete consumer use a characteristic-c batch of more than c
+   sources at a favourable complete invoice?
+
+## Credit
+
+Produced by Nick Petalas. The interface, the floor c(k + 2^k − 1) and the k ≤ c
+run walk are #4231's. The prefix criterion, deletion lemma and counting
+argument extend #4232's F3 versions. The connector interface and prefix-boundary
+readout criterion come from Ross Richardson's
+[#943](../universal-connector-boundary/README.md). Apache-2.0.

research/connector-depth-blocks/SOURCES.json

@@ -0,0 +1,18 @@
+{
+  "schema_version": 1,
+  "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "b1fea0c94436b236cc2b7d41a7be032811b94c81",
+      "sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "64bfc5af6709ed9811171e0a2108f05e1219cb65",
+      "sha256": "352a6184713b8843d96fd2c2071eb7aeaa655906b7c51d45ad444912666c8a96"
+    }
+  ]
+}

research/connector-depth-blocks/TASK.json

@@ -0,0 +1,86 @@
+{
+  "schema_version": 1,
+  "task_id": "connector-alphabet-change",
+  "priority_revision": 7,
+  "base_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244",
+  "original_card": {
+    "id": "connector-alphabet-change",
+    "question": "Does one explicit extension of the connector alphabet offer a favorable completed budget?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "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. A scoped local result may be retained without a complete supplier. Expanding it into further construction rounds requires the family-level budget and obligation gate in research-family-status.md; an optimistic passing relaxation alone is not acceptance.",
+    "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.",
+      "Extending a source-count census without naming a supplier/interface decision it could change; audit #2973 pruning concerns before relying on the affected predecessor exclusions."
+    ],
+    "overlap_terms": [
+      "universal connector",
+      "source-toggle",
+      "connector alphabet"
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "For the unsigned dirty connector over a ring of characteristic c (k immutable sources, all 2^k-1 nonzero binary-mask outputs, calls B_j: z += B_j x_j and A_m: y_m += A_m z), decide for which k the per-operator floor c(k+2^k-1) is attained. Answers part of PR4231 open question 1 (characteristic four) and gives a construction for every c.",
+  "scope_change_reason": "Keeps the PR4231 alphabet and increases the source count, which the card lists as a scope-change trigger. PR4231 left the characteristic-four threshold open; the floor is the premise any larger-batch consumer of that alphabet would rely on.",
+  "bottleneck_link": "Bounds the batch size at which a characteristic-c connector consumer can pay exactly c calls per operator. No physical consumer, admission or transfer is supplied, so no kappa change follows.",
+  "budget_minutes": 60,
+  "stop_rule": "Stop after the block construction for k<=2c, one explicit characteristic-four walk beyond 2c, the deletion lemma and the counting exclusion. Local-search failures are reported only as search failures.",
+  "outcome": "completed",
+  "evidence": "CERTIFICATE.json gives a 36-event characteristic-four walk on nine sources. verify.py builds the block words for all 2<=c<=7, k<=2c, regenerates every readout of the nine-source walk, simulates literal words with generic noncommuting coefficients and dense random matrices over Z/4, checks nine deletions, an exhaustive depth-one census at k=3, counting thresholds for c<=9 and six rejection controls.",
+  "author": "Nick Petalas",
+  "ai_assistance": "Independent human and formal proof-kernel review are unclaimed.",
+  "open_questions": [
+    {
+      "question": "What is the exact characteristic-four threshold N(4), now known to satisfy 9 <= N(4) <= 21?",
+      "why_it_matters": "It is the largest batch on which the characteristic-four connector pays exactly four calls per operator.",
+      "first_step": "By the deletion lemma every ten-source floor walk restricts to a nine-source one: enumerate four-event insertions into canonical nine-source floor walks, or sharpen the counting bound by excluding boundary multisets whose sum cannot be binary.",
+      "blocked_by": "Simulated annealing over 40-event walks did not reach full coverage in the local runs; no exclusion beyond counting is proved."
+    },
+    {
+      "question": "How does N(c) grow with c? The block construction gives N(c) >= 2c and counting gives N(c) = O(c log c).",
+      "why_it_matters": "A linear gap in the constant changes how large a batch can stay at the floor in high characteristic.",
+      "first_step": "Find blocks of depth d carrying more than 2d sources (a depth-two block on five sources at c=4 would already give ten); Lemma C shows depth one carries at most two.",
+      "blocked_by": "Local search for a depth-two five-source block at c=4 reached 28 of 31 masks; a depth-three seven-source block reached 125 of 127."
+    },
+    {
+      "question": "Does any concrete consumer use a characteristic-c batch of more than c sources at a favorable complete invoice?",
+      "why_it_matters": "The abstract call counts change no recursive supplier or kappa by themselves.",
+      "first_step": "Identify an immutable-source, unobserved-output caller with coefficients of characteristic c and price every primitive, admission and dispatch.",
+      "blocked_by": "No selected-supplier consumer is instantiated."
+    }
+  ],
+  "predecessor_handoff": {
+    "pr": "https://github.com/CrocSwap/integer-mult-bounds/pull/4231",
+    "head": "8a956cbc80dc55697fd3e214812ce567b5eca48f",
+    "author": "Nick Petalas",
+    "usage": "Interface, lower bound c(k+2^k-1) and the k<=c run walk; open question 1 is answered in part here. No executable dependency."
+  },
+  "coordination": {
+    "claim": "https://github.com/CrocSwap/integer-mult-bounds/discussions/1166#discussioncomment-19081028",
+    "upstream_commit": "12fa8c5c844be21bfefb38a19503fbd867a11244",
+    "overlap_scope": "100 live open PR titles, 80 recent account PRs, last 30 handoff comments, find_overlap helper over 349 open PRs and 2996 discussion records, merged README grep for characteristic-four connector terms. PR4231 (five sources, every c), PR4232 (F3, every n) and PR4225 (F3, five sources) are the related packages. Closed work and arbitrary diffs are incompletely covered.",
+    "family_decision": "Local interface result; stop. No construction round is justified without a consumer."
+  }
+}

research/connector-depth-blocks/VERIFY.json

@@ -0,0 +1,32 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "Block words for all 54 cases 2<=c<=7, k<=2c with generic coefficients; exhaustive depth-one census at k=3 for c=2,3,4; the characteristic-four nine-source walk with generic and dense matrix simulation; nine deletion checks; counting thresholds for c<=9; six rejection controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-O",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 60,
+      "checks": "Repeat every check under optimized Python; checks use explicit exceptions."
+    }
+  ]
+}