From e3ee7434a79a088ac00b134a13f7320ac3358563 Mon Sep 17 00:00:00 2001
From: zxv <zxv@zxv>
Date: Tue, 27 Oct 2026 23:19:14 -0400
Subject: [PATCH 1/3] Align current CI navigation with selected PR6030

---
 docs/ci-verification.md         | 19 ++++++++++++++++++-
 docs/research/current-status.md |  2 +-
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/docs/ci-verification.md b/docs/ci-verification.md
index 006bf5a3d5..63ba3e9aa8 100644
--- a/docs/ci-verification.md
+++ b/docs/ci-verification.md
@@ -1,6 +1,23 @@
 # CI verification
 
-## Current selected-family replay: #5599
+## Current selected-family replay: #6030
+
+The [selected record](../certificates/selected-result.json) binds conditional
+κ = 0.003125804 to the [proof review](research/pr-intake-evidence/pr6030-audit/PROOF-REVIEW.md),
+[validation receipts](research/pr-intake-evidence/pr6030-audit/VALIDATION.json),
+and [explicit source closure](../certificates/frontier6030-source.json).
+`make frontier6030-verify` follows that source-bound selected replay. The review
+separates retained normal primary macOS/Linux evidence from fresh independent
+word/invoice/native, original caller, adapted caller and optimized primary checks.
+Consult its receipts for exact commands, source heads and limits; the #5599
+checkpoint below retains its own historical replay details.
+
+The five inherited framework assumptions remain. Neither the full uniform word
+nor a complete rounded multiplier is materialized. A source/metadata check is
+not an operator replay or a formal theorem proof. Routine research submissions
+do not need to rerun this selected-family replay.
+
+## Historical selected-family replay: #5599
 
 The [selected record](../certificates/selected-result.json) binds conditional
 κ = 0.00310045 to the [proof review](research/pr-intake-evidence/pr5599-completion/PROOF-REVIEW.md)
diff --git a/docs/research/current-status.md b/docs/research/current-status.md
index a84ac12213..c49a245adc 100644
--- a/docs/research/current-status.md
+++ b/docs/research/current-status.md
@@ -1,6 +1,6 @@
 # Current reviewed status
 
-Selected conditional κ: **0.003125804 = 781451/250000000**, DreamingOfClouds'
+Selected conditional κ: **0.003125804** = 781451/250000000, DreamingOfClouds'
 PR6030 on the cumulative P104 construction. The complete caller counts 13,444
 productive fields and 66,834 paid calls. The saving is about 0.81775% above the
 preceding selected PR5599 claim 0.00310045.

From b7fe9f64259fb5b358598138505bc29eb1264f0e Mon Sep 17 00:00:00 2001
From: zxv <zxv@zxv>
Date: Tue, 27 Oct 2026 23:47:00 -0400
Subject: [PATCH 2/3] Construct six-source depth-two unsigned connectors in
 every characteristic at least eight

---
 .../CERTIFICATE.json                          | 324 ++++++++++++++++++
 research/connector-six-source-lift/README.md  | 207 +++++++++++
 .../connector-six-source-lift/SOURCES.json    |  36 ++
 research/connector-six-source-lift/TASK.json  |  74 ++++
 .../connector-six-source-lift/VERIFY.json     |  34 ++
 research/connector-six-source-lift/verify.py  | 191 +++++++++++
 6 files changed, 866 insertions(+)
 create mode 100644 research/connector-six-source-lift/CERTIFICATE.json
 create mode 100644 research/connector-six-source-lift/README.md
 create mode 100644 research/connector-six-source-lift/SOURCES.json
 create mode 100644 research/connector-six-source-lift/TASK.json
 create mode 100644 research/connector-six-source-lift/VERIFY.json
 create mode 100644 research/connector-six-source-lift/verify.py

diff --git a/research/connector-six-source-lift/CERTIFICATE.json b/research/connector-six-source-lift/CERTIFICATE.json
new file mode 100644
index 0000000000..c68cb74947
--- /dev/null
+++ b/research/connector-six-source-lift/CERTIFICATE.json
@@ -0,0 +1,324 @@
+{
+  "base_count": 9,
+  "walk": [
+    4,
+    2,
+    5,
+    1,
+    3,
+    0,
+    1,
+    5,
+    3,
+    0,
+    2,
+    4,
+    3,
+    2,
+    5,
+    4,
+    1,
+    0,
+    2,
+    3,
+    5,
+    0,
+    4,
+    1,
+    1,
+    2,
+    3,
+    5,
+    1,
+    4,
+    0,
+    4,
+    2,
+    0,
+    5,
+    1,
+    3,
+    0,
+    3,
+    4,
+    2,
+    5,
+    0,
+    4,
+    2,
+    5,
+    3,
+    1,
+    0,
+    4,
+    5,
+    3,
+    1,
+    2
+  ],
+  "cut": [
+    4,
+    4,
+    4,
+    4,
+    5,
+    4
+  ],
+  "sources": 6,
+  "depth": 2,
+  "minimum_characteristic": 8,
+  "readouts": {
+    "1": [
+      6,
+      49
+    ],
+    "2": [
+      7,
+      48
+    ],
+    "3": [
+      7,
+      49
+    ],
+    "4": [
+      20,
+      35
+    ],
+    "5": [
+      11,
+      45
+    ],
+    "6": [
+      19,
+      37
+    ],
+    "7": [
+      19,
+      38
+    ],
+    "8": [
+      13,
+      42
+    ],
+    "9": [
+      13,
+      43
+    ],
+    "10": [
+      17,
+      39
+    ],
+    "11": [
+      18,
+      39
+    ],
+    "12": [
+      14,
+      42
+    ],
+    "13": [
+      14,
+      43
+    ],
+    "14": [
+      20,
+      37
+    ],
+    "15": [
+      19,
+      39
+    ],
+    "16": [
+      0,
+      1
+    ],
+    "17": [
+      6,
+      50
+    ],
+    "18": [
+      24,
+      32
+    ],
+    "19": [
+      7,
+      50
+    ],
+    "20": [
+      0,
+      2
+    ],
+    "21": [
+      12,
+      45
+    ],
+    "22": [
+      24,
+      33
+    ],
+    "23": [
+      24,
+      34
+    ],
+    "24": [
+      16,
+      40
+    ],
+    "25": [
+      13,
+      44
+    ],
+    "26": [
+      17,
+      40
+    ],
+    "27": [
+      18,
+      40
+    ],
+    "28": [
+      16,
+      41
+    ],
+    "29": [
+      13,
+      45
+    ],
+    "30": [
+      17,
+      41
+    ],
+    "31": [
+      18,
+      41
+    ],
+    "32": [
+      8,
+      47
+    ],
+    "33": [
+      10,
+      46
+    ],
+    "34": [
+      8,
+      48
+    ],
+    "35": [
+      8,
+      49
+    ],
+    "36": [
+      21,
+      35
+    ],
+    "37": [
+      11,
+      46
+    ],
+    "38": [
+      21,
+      36
+    ],
+    "39": [
+      22,
+      36
+    ],
+    "40": [
+      9,
+      47
+    ],
+    "41": [
+      10,
+      47
+    ],
+    "42": [
+      9,
+      48
+    ],
+    "43": [
+      9,
+      49
+    ],
+    "44": [
+      15,
+      42
+    ],
+    "45": [
+      11,
+      47
+    ],
+    "46": [
+      21,
+      37
+    ],
+    "47": [
+      11,
+      48
+    ],
+    "48": [
+      3,
+      53
+    ],
+    "49": [
+      6,
+      51
+    ],
+    "50": [
+      4,
+      53
+    ],
+    "51": [
+      7,
+      51
+    ],
+    "52": [
+      0,
+      3
+    ],
+    "53": [
+      12,
+      46
+    ],
+    "54": [
+      0,
+      4
+    ],
+    "55": [
+      23,
+      36
+    ],
+    "56": [
+      5,
+      52
+    ],
+    "57": [
+      6,
+      52
+    ],
+    "58": [
+      5,
+      53
+    ],
+    "59": [
+      6,
+      53
+    ],
+    "60": [
+      16,
+      42
+    ],
+    "61": [
+      12,
+      47
+    ],
+    "62": [
+      0,
+      5
+    ],
+    "63": [
+      0,
+      6
+    ]
+  }
+}
diff --git a/research/connector-six-source-lift/README.md b/research/connector-six-source-lift/README.md
new file mode 100644
index 0000000000..05521f0cee
--- /dev/null
+++ b/research/connector-six-source-lift/README.md
@@ -0,0 +1,207 @@
+# Unsigned connectors attain the call floor on at least 3c−1 sources
+
+For every ring characteristic $c\geq8$, an explicit six-source depth-two block gives
+
+$$
+N(c)\geq2c+2\lfloor c/2\rfloor.
+$$
+
+This is $3c$ sources when $c$ is even, and $3c-1$ when $c$ is odd. It improves
+[Nick Petalas](https://github.com/petalas)'s
+[PR #6035](https://github.com/CrocSwap/integer-mult-bounds/pull/6035) bound
+$N(c)\geq\lfloor5c/2\rfloor$ in this range and answers its first open question:
+a depth-two block can serve six sources. Its smaller-characteristic results
+are unchanged. This is a finite exact certificate plus a uniform lifting proof,
+not a new supplier, physical consumer, multiplication theorem or $\kappa$.
+
+## Interface and full call floor
+
+Retain the unsigned complete-call interface of
+[PR #4231](https://github.com/CrocSwap/integer-mult-bounds/pull/4231) and
+[PR #4248](https://github.com/CrocSwap/integer-mult-bounds/pull/4248).
+There are $k$ immutable source rows, one arbitrary dirty borrowed connector
+$z$, and a distinct arbitrary dirty output $y_m$ for every nonzero binary mask.
+The maps $A_m$ and $B_j$ are arbitrary and need not commute or be invertible.
+The only operations are
+
+$$
+B_j:\ z\leftarrow z+B_jx_j,
+\qquad
+A_m:\ y_m\leftarrow y_m+A_mz.
+$$
+
+Every source and output operator is called exactly $c$ times in a floor word.
+The complete count is
+
+$$
+c\bigl(k+2^k-1\bigr).
+$$
+
+Indeed each source-call count must be a positive multiple of $c$ for universal
+connector restoration; each output-call count must be a positive multiple of
+$c$ to cancel arbitrary connector dirt. No operator can be absent, because its
+required source column or output is nonzero for some allowed map. These are
+complete calls, with no free scaling, copies, signs, extra connectors, source
+mutation or output feedback.
+
+Let $q_t$ be the vector of source-event counts modulo $c$ after $t$ source
+steps. Reading output $m$ at $c$ boundaries implements its required sum exactly
+when the corresponding prefix vectors sum to $m$ modulo $c$. The coefficient
+of its initial connector dirt is $c$, hence zero. Each initial output is retained.
+Integer coefficients act centrally through the characteristic; this argument
+does not commute $A_m$ past $B_j$.
+
+## Six-source certificate
+
+The 54-event base word uses each label exactly nine times:
+
+```text
+4 2 5 1 3 0 1 5 3 0 2 4 3 2 5 4 1 0
+2 3 5 0 4 1 1 2 3 5 1 4 0 4 2 0 5 1
+3 0 3 4 2 5 0 4 2 5 3 1 0 4 5 3 1 2
+```
+
+Its cut vector is $(4,4,4,4,5,4)$. Write $n_t(j)$ for the number of label-$j$
+events before boundary $t$. Define the integer lifted prefix by
+$L_t(j)=n_t(j)$ before that coordinate passes its cut, and
+$L_t(j)=n_t(j)-9$ afterward.
+
+**Finite proof core.** Every one of the 63 nonzero binary six-vectors is an
+integer sum of two lifted prefixes. [CERTIFICATE.json](CERTIFICATE.json) gives
+one exact boundary pair per mask; replay independently regenerates the complete
+pair table and compares it. There is no numerical approximation or search
+completeness assumption in this finite identity.
+
+## Uniform lift to every characteristic c ≥ 8
+
+Replace the first event past the cut of coordinate $j$ by a run of $c-8$ copies
+of label $j$. At $c=8$ the event is deleted. Every source now occurs
+
+$$
+9-1+(c-8)=c
+$$
+
+times. Let $\tau(t)$ be the boundary after the expanded image of the first $t$
+base events. Before coordinate $j$ passes its cut, its new count is still
+$n_t(j)$. Afterward its new count is
+
+$$
+n_t(j)-1+(c-8)=n_t(j)+c-9.
+$$
+
+Therefore $q_{\tau(t)}$ is $L_t$ reduced modulo $c$, coordinate by coordinate.
+Every certified integer pair still sums to its mask modulo $c$. Pad its two
+readouts with $c-2$ copies of the zero boundary. All outputs use exactly $c$
+reads, and the connector returns to its arbitrary initial value because all
+six sources are added $c$ times. This proves the six-source block for every
+$c\geq8$, independently of the bounded characteristic checks. ∎
+
+The construction needs the nonnegative run length $c-8$. It proves no
+exclusion for characteristics five, six or seven.
+
+## Concatenation and the density-three bound
+
+Concatenate $\lfloor c/2\rfloor$ such blocks on disjoint six-source sets. Each
+block returns to zero modulo $c$, so a prefix inside one block has zero source
+coefficients in every other block. Split an arbitrary global mask by blocks
+and use its two local certified prefixes in each nonzero block.
+
+For odd $c$, append the two-source depth-one block from #4248,
+
+```text
+a b a^(c-1) b^(c-1).
+```
+
+It has the required three nonzero binary prefixes. The total readout depth is
+at most $c$. Pad unused readouts at the global zero boundary and sort their
+boundary indices; repeated reads at a boundary are allowed. This constructs
+all masks on
+
+$$
+6\lfloor c/2\rfloor+2\bigl(c-2\lfloor c/2\rfloor\bigr)
+=2c+2\lfloor c/2\rfloor
+$$
+
+sources at the full call floor. Deleting source events and restricting to masks
+that omit those sources gives every smaller source count, exactly as in #4248.
+This rederives the needed concatenation and deletion implications rather than
+assuming a favorable count itself is a word. ∎
+
+| Characteristic $c$ | #6035 lower bound | This construction |
+|---:|---:|---:|
+| 8 | 20 | **24** |
+| 9 | 22 | **26** |
+| 10 | 25 | **30** |
+| 11 | 27 | **32** |
+| 12 | 30 | **36** |
+
+These are attaining lower bounds, not exact values of $N(c)$ or an improvement
+to the existing upper bounds.
+
+## Evidence and reproduction
+
+```
+python3.12 -B scripts/research_package.py --package research/connector-six-source-lift
+python3.12 -B scripts/check_research_commit.py --package research/connector-six-source-lift
+```
+
+The standard-library replay authenticates the predecessor sources, regenerates
+all 63 integer identities, and recovers the credited five-source positive control.
+It checks every expanded boundary and mask for $8\leq c\leq40$, executes complete
+arbitrary-dirty symbolic connector words on six sources at $c=8,9,10,11$ and
+on twelve sources at $c=8$, and separately replays noncommuting two-by-two
+matrix maps over those prime and composite characteristic rings. Every source,
+readout, restoration coefficient and complete call count is checked.
+
+The maximal concatenated construction has exponentially many outputs, so replay
+does not materialize it. It verifies its exact block decomposition and selected
+complete masks for $8\leq c\leq20$; the written concatenation proof covers every
+mask. Missing calls, changed labels, corrupted readouts and exceeded depth/run
+budgets are rejected. Normal and optimized replays write no package files.
+
+Discovery used a small C++ annealer; the verifier neither imports it nor trusts
+its objective. Base-nine and base-ten words were found. Bounded base-six and
+base-eight searches failed; they are search failures, not impossibility results.
+Only the stronger base-nine witness is retained. The finite certificate and
+uniform proof are reproducible without discovery logs or a compiler.
+
+Main was refreshed at 721c03822c421b7f7fcbb2598993b947c4d88419, priority revision
+8, on 2026-10-28 UTC. The navigation repair from
+[PR #6050](https://github.com/CrocSwap/integer-mult-bounds/pull/6050) is included.
+No selected replay was run. The optional full-history preflight is unavailable
+in this shallow checkout; all source pins are at its reachable base. No
+full-history or independent human/formal-kernel pass is claimed.
+
+## Significance for researchers
+
+Six sources per two reads improve the uniform characteristic-dependent
+connector construction beyond the five-source block. This answers a concrete
+architectural open question while preserving the dirty interface and every
+complete abstract call. It does not price native calls, input admission,
+coefficient preparation, dispatch, hosting, movement or the physical consumer.
+Those costs remain necessary before inferring any supplier or exponent gain.
+
+## Open next questions
+
+Can a six-source depth-two block work in characteristic five, six or seven?
+Start with one bounded exact search or a proved obstruction; this lift does not
+cover those cases, and the failed discovery runs exclude nothing.
+
+Can seven sources fit depth two, or can an odd-depth block remove the one-source
+loss for odd characteristics? First find an exact integer-lift template, then
+check a complete dirty word. No such template is supplied here.
+
+Does one actual physical consumer benefit from this characteristic-dependent
+batch after every complete operation is paid? Pin a source/consumer contract
+and derive its full invoice before implementing larger batches.
+
+## Credit
+
+Prepared by [zxv](https://github.com/zxv) with substantial OpenAI Codex assistance.
+[Nick Petalas](https://github.com/petalas)'s #6035 supplies the five-source
+integer-lift method and six-source open question; #4248 supplies the depth-block,
+concatenation and deletion framework. The #4231 interface and floor and the
+[PR #943](https://github.com/CrocSwap/integer-mult-bounds/pull/943) connector
+lineage retain their predecessor credit. No predecessor method is claimed as
+new: the contribution is the six-source exact template and its stronger uniform
+attaining bound. Apache-2.0.
diff --git a/research/connector-six-source-lift/SOURCES.json b/research/connector-six-source-lift/SOURCES.json
new file mode 100644
index 0000000000..410ca7dc16
--- /dev/null
+++ b/research/connector-six-source-lift/SOURCES.json
@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "e3ee7434a79a088ac00b134a13f7320ac3358563",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "d59b5035e7b4cbaa9d688a1d32dd0d6eb79c466a",
+      "sha256": "9b8d0eea95b3bf0dfcb7938a732a6439b87a2685dec2a5ab9e525b3b34debbfa"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "research/connector-depth-blocks/README.md",
+      "usage": "input",
+      "git_blob": "5d5b4a5b96e05f3818ff454d4dfdc5dc2959f6b4",
+      "sha256": "0ce59767f249b24d65d7d14b466115858d82c0bbfaaa8eab46b7406f4e975331"
+    },
+    {
+      "path": "research/connector-five-halves-growth/README.md",
+      "usage": "input",
+      "git_blob": "ede2725b4b49c8fe587f077d731432437a3fdb3d",
+      "sha256": "623f08f27f74ed050d19d5fb518c842512ac6eb54c07701aa94d018eda01cb6f"
+    },
+    {
+      "path": "research/connector-five-halves-growth/CERTIFICATE.json",
+      "usage": "input",
+      "git_blob": "75bf7f0666ab2ccecd15ad6a8f8a0578b36cd3f0",
+      "sha256": "21efc7e9f2167250a9fdc1589dac8964cfe3a71115d38b9df362b01807f82c2a"
+    }
+  ]
+}
diff --git a/research/connector-six-source-lift/TASK.json b/research/connector-six-source-lift/TASK.json
new file mode 100644
index 0000000000..8349c43a21
--- /dev/null
+++ b/research/connector-six-source-lift/TASK.json
@@ -0,0 +1,74 @@
+{
+  "schema_version": 1,
+  "task_id": "connector-alphabet-change",
+  "priority_revision": 8,
+  "base_commit": "e3ee7434a79a088ac00b134a13f7320ac3358563",
+  "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": "Six-source depth-two integer-lift block for every characteristic c>=8, giving N(c)>=2c+2 floor(c/2).",
+  "scope_change_reason": "The operation alphabet stays fixed; this answers PR6035 open question 1 about a six-source block and improves its uniform floor construction. It is an explicitly labelled source-count side result, not a new native operation.",
+  "bottleneck_link": "Changes the characteristic-dependent abstract connector floor domain; a complete physical consumer and bill remain required for kappa.",
+  "budget_minutes": 15,
+  "stop_rule": "Stop after the exact six-source template, uniform lift proof, complete dirty boundaries and bounded composition checks; no optimality or physical expansion.",
+  "outcome": "completed",
+  "evidence": "CERTIFICATE.json all 63 exact readout pairs; README.md proof; verify.py exact block/full-word/matrix checks.",
+  "author": "zxv (https://github.com/zxv), with substantial OpenAI Codex assistance",
+  "ai_assistance": "Substantial OpenAI Codex assistance; annealing discovered the finite witness, which replay checks exactly without trusting search.",
+  "open_questions": [
+    {
+      "question": "Does a six-source depth-two block exist for c=5,6,7?",
+      "why_it_matters": "Would lower the threshold of the uniform density-three construction.",
+      "first_step": "Use the displayed word as a starting point for a separately bounded exact search.",
+      "blocked_by": "The c>=8 lift does not cover those characteristics; failed searches are not exclusions."
+    },
+    {
+      "question": "Can depth two support seven sources, or can an odd-depth block remove the one-source odd-c loss?",
+      "why_it_matters": "Would improve the asymptotic density or remainder.",
+      "first_step": "Find an exact integer-lift template before implementing its consumer.",
+      "blocked_by": "No such template supplied."
+    },
+    {
+      "question": "Does a physical consumer benefit after paying all connector operations?",
+      "why_it_matters": "Abstract call counts alone cannot improve kappa.",
+      "first_step": "Pin one source/consumer interface and charge complete implementations.",
+      "blocked_by": "No physical caller is instantiated."
+    }
+  ]
+}
diff --git a/research/connector-six-source-lift/VERIFY.json b/research/connector-six-source-lift/VERIFY.json
new file mode 100644
index 0000000000..4f2af851dc
--- /dev/null
+++ b/research/connector-six-source-lift/VERIFY.json
@@ -0,0 +1,34 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [
+    "research/connector-depth-blocks/README.md",
+    "research/connector-five-halves-growth/README.md",
+    "research/connector-five-halves-growth/CERTIFICATE.json"
+  ],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "All 63 integer mask identities, c=8..40 lift transfers, complete dirty words, noncommuting matrices, composition and failure controls."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Same exact proof-relevant checks with assertions disabled."
+    }
+  ]
+}
diff --git a/research/connector-six-source-lift/verify.py b/research/connector-six-source-lift/verify.py
new file mode 100644
index 0000000000..8255fe3e5e
--- /dev/null
+++ b/research/connector-six-source-lift/verify.py
@@ -0,0 +1,191 @@
+"""Six-source integer lift and complete dirty connector endpoints. Apache-2.0."""
+from collections import Counter
+from itertools import combinations_with_replacement
+from pathlib import Path
+from random import Random
+import hashlib
+import json
+
+HERE=Path(__file__).resolve().parent
+ROOT=HERE.parents[1]
+
+
+def need(ok,msg):
+    if not ok:raise ValueError(msg)
+
+
+def lifted(w,cut,b):
+    k=len(cut);cnt=[0]*k;out=[tuple(cnt)]
+    need(Counter(w)==Counter({j:b for j in range(k)}),'balanced template')
+    need(all(0<=a<b for a in cut),'cuts')
+    for j in w:
+        cnt[j]+=1
+        out.append(tuple(x if x<=cut[i] else x-b for i,x in enumerate(cnt)))
+    need(out[-1]==(0,)*k,'restored lift')
+    return out
+
+
+def witnesses(lp):
+    k=len(lp[0]);found={}
+    for t,u in combinations_with_replacement(range(len(lp)),2):
+        v=tuple(x+y for x,y in zip(lp[t],lp[u]))
+        if all(x in(0,1) for x in v) and any(v):
+            found.setdefault(sum(x<<j for j,x in enumerate(v)),[t,u])
+    need(set(found)==set(range(1,1<<k)),'complete binary-mask cover')
+    return found
+
+
+def expand(w,cut,b,c):
+    need(c>=b-1,'nonnegative expanded run')
+    seen=[0]*len(cut);out=[];tau=[0]
+    for j in w:
+        seen[j]+=1
+        out.extend([j]*(c-b+1 if seen[j]==cut[j]+1 else 1))
+        tau.append(len(out))
+    return out,tau
+
+
+def prefixes(w,k,c):
+    cnt=[0]*k;out=[tuple(cnt)]
+    for j in w:
+        cnt[j]=(cnt[j]+1)%c;out.append(tuple(cnt))
+    return out
+
+
+def reads_for_block(cert,c):
+    w,tau=expand(cert['walk'],cert['cut'],cert['base_count'],c)
+    reads={int(m):[tau[t] for t in pair]+[0]*(c-2)
+           for m,pair in cert['readouts'].items()}
+    return w,reads
+
+
+def simulate(w,reads,k,c):
+    need(Counter(w)==Counter({j:c for j in range(k)}),'balanced physical source calls')
+    need(set(reads)==set(range(1,1<<k)),'all outputs')
+    at=[[] for _ in range(len(w)+1)]
+    for m,ts in reads.items():
+        need(len(ts)==c and all(0<=t<=len(w) for t in ts),'readout count/range')
+        for t in ts:at[t].append(m)
+    z=[1]+[0]*k
+    out={m:[1]+[0]*(k+1) for m in reads}
+    for t,bucket in enumerate(at):
+        for m in bucket:
+            for j,x in enumerate(z):out[m][j+1]=(out[m][j+1]+x)%c
+        if t<len(w):z[w[t]+1]=(z[w[t]+1]+1)%c
+    need(z==[1]+[0]*k,'connector arbitrary dirt restored')
+    for m,row in out.items():
+        need(row==[1,0]+[(m>>j)&1 for j in range(k)],'complete dirty output')
+    need(len(w)+sum(map(len,reads.values()))==c*(k+(1<<k)-1),'full call floor')
+    return len(w)+sum(map(len,reads.values()))
+
+
+def compose(cert,c,blocks=None,odd=None):
+    if blocks is None:blocks=c//2
+    if odd is None:odd=c%2
+    need(2*blocks+odd<=c,'depth budget')
+    base,tau=expand(cert['walk'],cert['cut'],cert['base_count'],c)
+    w=[];parts=[]
+    for b in range(blocks):
+        off=len(w);w.extend(j+6*b for j in base)
+        parts.append((6*b,6,{int(m):[off+tau[t] for t in pair]
+                              for m,pair in cert['readouts'].items()}))
+    if odd:
+        off=len(w);j=6*blocks
+        w.extend([j,j+1]+[j]*(c-1)+[j+1]*(c-1))
+        parts.append((j,2,{1:[off+1],3:[off+2],2:[off+c+1]}))
+    return w,parts,6*blocks+2*odd
+
+
+def read_mask(m,parts,c):
+    out=[]
+    for j,k,table in parts:
+        local=(m>>j)&((1<<k)-1)
+        if local:out.extend(table[local])
+    need(len(out)<=c,'available readouts')
+    return sorted(out+[0]*(c-len(out)))
+
+
+def mv(a,x,c):return tuple(sum(u*v for u,v in zip(row,x))%c for row in a)
+def plus(a,b,c):return tuple((x+y)%c for x,y in zip(a,b))
+
+
+def matrix_control(w,reads,k,c):
+    rng=Random(6035+c)
+    mat=lambda:tuple(tuple(rng.randrange(c) for _ in range(2)) for _ in range(2))
+    vec=lambda:tuple(rng.randrange(c) for _ in range(2))
+    bs=[mat() for _ in range(k)];xs=[vec() for _ in range(k)]
+    aa={m:mat() for m in reads};ys={m:vec() for m in reads};initial=ys.copy()
+    z=vec();dirty=z;at=[[] for _ in range(len(w)+1)]
+    for m,ts in reads.items():
+        for t in ts:at[t].append(m)
+    for t,bucket in enumerate(at):
+        for m in bucket:ys[m]=plus(ys[m],mv(aa[m],z,c),c)
+        if t<len(w):j=w[t];z=plus(z,mv(bs[j],xs[j],c),c)
+    need(z==dirty,'matrix dirty connector')
+    for m in reads:
+        expected=initial[m]
+        for j in range(k):
+            if (m>>j)&1:expected=plus(expected,mv(aa[m],mv(bs[j],xs[j],c),c),c)
+        need(ys[m]==expected,'noncommuting matrix endpoint')
+
+
+def rejected(fn):
+    try:fn()
+    except ValueError:return
+    raise ValueError('negative control accepted')
+
+
+def main():
+    pins=json.loads((HERE/'SOURCES.json').read_text())
+    for row in pins['files']:
+        if row['usage']=='input':
+            need(hashlib.sha256((ROOT/row['path']).read_bytes()).hexdigest()==row['sha256'],'source bytes')
+    cert=json.loads((HERE/'CERTIFICATE.json').read_text())
+    need((cert['base_count'],cert['sources'],cert['depth'],cert['minimum_characteristic'])==(9,6,2,8),'claim data')
+    lp=lifted(cert['walk'],cert['cut'],9)
+    found=witnesses(lp)
+    need(found=={int(m):pair for m,pair in cert['readouts'].items()},'canonical integer witnesses')
+    old=json.loads((ROOT/'research/connector-five-halves-growth/CERTIFICATE.json').read_text())
+    need(len(witnesses(lifted(old['template_walk'],old['template_cut'],6)))==31,'credited five-source positive control')
+    expanded=0;literal_calls=0
+    for c in range(8,41):
+        w,tau=expand(cert['walk'],cert['cut'],9,c)
+        need(Counter(w)==Counter({j:c for j in range(6)}),'expanded counts')
+        qs=prefixes(w,6,c)
+        for t,v in enumerate(lp):need(qs[tau[t]]==tuple(x%c for x in v),'integer-lift transfer')
+        for m,pair in found.items():
+            v=tuple((qs[tau[pair[0]]][j]+qs[tau[pair[1]]][j])%c for j in range(6))
+            need(v==tuple((m>>j)&1 for j in range(6)),'expanded mask')
+        expanded+=1
+    for c in (8,9,10,11):
+        w,rs=reads_for_block(cert,c);literal_calls+=simulate(w,rs,6,c)
+        matrix_control(w,rs,6,c)
+    w,parts,k=compose(cert,8,blocks=2,odd=0)
+    literal_calls+=simulate(w,{m:read_mask(m,parts,8) for m in range(1,1<<k)},k,8)
+    sampled=0;rng=Random(6054)
+    for c in range(8,21):
+        w,parts,k=compose(cert,c)
+        need(k==2*c+2*(c//2),'source bound')
+        qs=prefixes(w,k,c)
+        masks=[1<<j for j in range(k)]+[(1<<k)-1]
+        masks.extend(rng.randrange(1,1<<k) for _ in range(64))
+        for m in masks:
+            ts=read_mask(m,parts,c)
+            got=tuple(sum(qs[t][j] for t in ts)%c for j in range(k))
+            need(got==tuple((m>>j)&1 for j in range(k)),'composed mask')
+            sampled+=1
+    rejected(lambda:expand(cert['walk'],cert['cut'],9,7))
+    rejected(lambda:compose(cert,8,blocks=5,odd=0))
+    bad=cert['walk'].copy();bad[0]=bad[1]
+    rejected(lambda:lifted(bad,cert['cut'],9))
+    w,rs=reads_for_block(cert,8);bad={m:t[:] for m,t in rs.items()};bad[1].pop()
+    rejected(lambda:simulate(w,bad,6,8))
+    bad={m:t[:] for m,t in rs.items()};bad[1][0]=(bad[1][0]+1)%(len(w)+1)
+    rejected(lambda:simulate(w,bad,6,8))
+    print(json.dumps(dict(status='PASS_SIX_SOURCE_CONNECTOR_LIFT',integer_masks=len(found),
+                         expanded_characteristics=expanded,literal_calls_checked=literal_calls,
+                         composed_masks_checked=sampled,minimum_characteristic=8,
+                         scope='uniform abstract connector construction; no new kappa'),sort_keys=True))
+
+
+if __name__=='__main__':main()

From f92bd41f60564175bd68f944e9d6450da8965734 Mon Sep 17 00:00:00 2001
From: zxv <zxv@zxv>
Date: Tue, 27 Oct 2026 23:49:51 -0400
Subject: [PATCH 3/3] Check that connector matrix controls include noncommuting
 maps

---
 research/connector-six-source-lift/verify.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/research/connector-six-source-lift/verify.py b/research/connector-six-source-lift/verify.py
index 8255fe3e5e..e5fca84206 100644
--- a/research/connector-six-source-lift/verify.py
+++ b/research/connector-six-source-lift/verify.py
@@ -115,6 +115,9 @@ def matrix_control(w,reads,k,c):
     vec=lambda:tuple(rng.randrange(c) for _ in range(2))
     bs=[mat() for _ in range(k)];xs=[vec() for _ in range(k)]
     aa={m:mat() for m in reads};ys={m:vec() for m in reads};initial=ys.copy()
+    need(any(mv(a,mv(b,e,c),c)!=mv(b,mv(a,e,c),c)
+             for a in aa.values() for b in bs for e in ((1,0),(0,1))),
+         'matrix fixture really has noncommuting maps')
     z=vec();dirty=z;at=[[] for _ in range(len(w)+1)]
     for m,ts in reads.items():
         for t in ts:at[t].append(m)