From f06dabb7efc09edfa5efafeb9ebf60331790cdd7 Mon Sep 17 00:00:00 2001
From: Ali Romman <226877337+aliromman@users.noreply.github.com>
Date: Sun, 25 Oct 2026 19:26:03 -0500
Subject: [PATCH] Bound every coordinate caller of the seven-axis B/C suppliers

---
 .../.gitattributes                            |   1 +
 .../INPUTS.json                               |  51 ++++
 .../PROOF.md                                  | 254 +++++++++++++++
 .../README.md                                 | 108 +++++++
 .../RESULT.json                               | 199 ++++++++++++
 .../SOURCES.json                              |  60 ++++
 .../TASK.json                                 | 117 +++++++
 .../VERIFY.json                               |  34 +++
 .../inputs/B-PROFILE.json                     |  35 +++
 .../inputs/C-PROFILE.json                     |  60 ++++
 .../inputs/INTERFACE.md                       |  61 ++++
 .../inputs/NATIVE-AUDIT.md                    | 142 +++++++++
 .../inputs/SERIAL-BOUND.md                    |  94 ++++++
 .../inputs/SERIAL-README.md                   |  21 ++
 .../inputs/TYPED-PROVIDER.md                  | 164 ++++++++++
 .../verify.py                                 | 289 ++++++++++++++++++
 16 files changed, 1690 insertions(+)
 create mode 100644 research/complementary-caller-capacity-gate/.gitattributes
 create mode 100644 research/complementary-caller-capacity-gate/INPUTS.json
 create mode 100644 research/complementary-caller-capacity-gate/PROOF.md
 create mode 100644 research/complementary-caller-capacity-gate/README.md
 create mode 100644 research/complementary-caller-capacity-gate/RESULT.json
 create mode 100644 research/complementary-caller-capacity-gate/SOURCES.json
 create mode 100644 research/complementary-caller-capacity-gate/TASK.json
 create mode 100644 research/complementary-caller-capacity-gate/VERIFY.json
 create mode 100644 research/complementary-caller-capacity-gate/inputs/B-PROFILE.json
 create mode 100644 research/complementary-caller-capacity-gate/inputs/C-PROFILE.json
 create mode 100644 research/complementary-caller-capacity-gate/inputs/INTERFACE.md
 create mode 100644 research/complementary-caller-capacity-gate/inputs/NATIVE-AUDIT.md
 create mode 100644 research/complementary-caller-capacity-gate/inputs/SERIAL-BOUND.md
 create mode 100644 research/complementary-caller-capacity-gate/inputs/SERIAL-README.md
 create mode 100644 research/complementary-caller-capacity-gate/inputs/TYPED-PROVIDER.md
 create mode 100644 research/complementary-caller-capacity-gate/verify.py

diff --git a/research/complementary-caller-capacity-gate/.gitattributes b/research/complementary-caller-capacity-gate/.gitattributes
new file mode 100644
index 0000000000..50169fc516
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/.gitattributes
@@ -0,0 +1 @@
+inputs/* -text whitespace=cr-at-eol,-blank-at-eof
diff --git a/research/complementary-caller-capacity-gate/INPUTS.json b/research/complementary-caller-capacity-gate/INPUTS.json
new file mode 100644
index 0000000000..7ff50ba799
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/INPUTS.json
@@ -0,0 +1,51 @@
+[
+  {
+    "local": "inputs/B-PROFILE.json",
+    "path": "research/native-dual-suppliers/QUOTIENT153-ROUND3-ACTUAL-PROFILE.json",
+    "commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+    "git_blob": "0f04f7f6904a6fbd8ba5b4637babd1fb70766a1a",
+    "sha256": "c0ff4ea6bd3b8510f109203a90efba5d924edd9902641a96330f3bd1a7c2a571"
+  },
+  {
+    "local": "inputs/C-PROFILE.json",
+    "path": "research/native-dual-suppliers/INTERSECTION153-ROUND3-ACTUAL-PROFILE.json",
+    "commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+    "git_blob": "d01460798ff331e702e873957b4a7799345690b0",
+    "sha256": "0820837a5ddd25d81596eb3fb1f0a18d173f0958aa6ceab651fc71d64d24325c"
+  },
+  {
+    "local": "inputs/INTERFACE.md",
+    "path": "research/native-dual-suppliers/HETEROGENEOUS-CONTROLLER.md",
+    "commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+    "git_blob": "13713545701f29d5f4743a3602538cad982ac476",
+    "sha256": "c6231bd89629e6356d576d9e8c81f7b42a0b79ab66b0b4c95b8d94520016f011"
+  },
+  {
+    "local": "inputs/NATIVE-AUDIT.md",
+    "path": "research/kappa-round8-complement-audit-20261023/README.md",
+    "commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+    "git_blob": "e92aa3b5a831611c9aca7935752cea91e1bf1e22",
+    "sha256": "4a5a37fadb83dd291b9d977a84693423ba4b1107c261dbbb5ec35730e67ff625"
+  },
+  {
+    "local": "inputs/SERIAL-BOUND.md",
+    "path": "research/complementary-consumer-feasibility/PROOF.md",
+    "commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+    "git_blob": "836439b3fe7573834fb02c2a95716ac365162fb4",
+    "sha256": "a054291b524d264995112509f4d37df4284af49f0c1b589d79ac2d66cf9e2847"
+  },
+  {
+    "local": "inputs/SERIAL-README.md",
+    "path": "research/complementary-consumer-feasibility/README.md",
+    "commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+    "git_blob": "565b93c517327d4155598a1776cbb4569930a887",
+    "sha256": "d1caf689aa8a719a42b2e350e11b5c31cd9abbba11e8fe656c650c24e0c6462a"
+  },
+  {
+    "local": "inputs/TYPED-PROVIDER.md",
+    "path": "research/characteristic-gaussian-provider/typed-provider.md",
+    "commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+    "git_blob": "cc190c322d944eabd2a8fb36ad8d11923cb5c5ec",
+    "sha256": "dc1a21489807dc3553e4225b56534c4372ebafd72598eb673ef7c675f55fec21"
+  }
+]
diff --git a/research/complementary-caller-capacity-gate/PROOF.md b/research/complementary-caller-capacity-gate/PROOF.md
new file mode 100644
index 0000000000..41ef324bd6
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/PROOF.md
@@ -0,0 +1,254 @@
+# A sign-cut bound for complete complementary callers
+
+Prepared by Ali Romman with substantial OpenAI Codex assistance. Apache-2.0.
+
+## 1. Contract and claim
+
+Fix a finite set of coordinate axes. On axis a let Q_a be the usual lifted
+Gaussian at width f, and put J_a=Q_a^2. The Q_a commute, J_a^2=I, and f>=3.
+An ordinary operation is complex-linear and has a matrix on field indices whose entries are complex
+scalar combinations of products of the J_a. This grants all such operations
+for free. It includes arbitrary field mixing, COPY, retained observations,
+owned zero fields, CLEAR, and ordinary sector projectors. It does not grant
+an arbitrary address permutation, value conjugation or an odd Gaussian input gauge.
+
+A whole B or C call has 112 main pairs. There are 56 A pairs and 56 exceptional
+pairs of the stated type. In the common coordinate chart its main blocks are
+
+    A = D [[1,0],[Q^-1,1]],
+    B = D [[1,0],[1,Q]],
+    C = D [[Q,0],[1,1]].
+
+Here D is the product on seven distinct transverse axes, and Q is on a
+different central axis. A call can choose its axes, central axis, main fields
+and port placement. Different calls can reuse axes and fields. Inverses,
+transposes, inverse transposes and the source even-power corrections are
+allowed. Each call retains its exact paid profile and all 408 independent
+helper outputs. Helpers are separate from the caller's main computation;
+no helper input or output is a shared main resource. Native internal maps
+are part of the whole-call premise, not extra free caller operations.
+
+An additional query applies a product of coordinate Gaussians or their
+inverses to one field. Its charged rank r is the number of odd axes after
+even powers are removed. All these queries are charged, including idles
+and corrections. There is no upper bound on r. The caller can have any
+finite number of main inputs, fields, steps and calls. It is a linear
+straight-line program; its choices do not depend on the input values.
+
+The productive main outputs are independent full Gaussian jobs on distinct
+original arbitrary fields, on the declared coordinate axes. Their ranks
+r_i are the numbers of odd axes. Invertible ordinary input/output basis
+changes do not affect the proof. A projected component of a field is not
+credited as a full independent Gaussian job.
+
+Let L_B,L_C count the whole calls. Write P_X(t),H_X(t) for the sums of
+rank^t in the exact paid and helper profiles. For every 0<t<1, define
+
+    K(t) = 28 + 140*7^t + 84*8^t,
+    Delta_X(t) = P_X(t) - H_X(t) - K(t).
+
+**Theorem.** The complete target-minus-paid moment satisfies
+
+    F(t) <= -L_B*Delta_B(t) - L_C*Delta_C(t) < 0
+
+if at least one B or C call occurs. Both deltas are strictly positive.
+The result permits any main target ranks and any additional query ranks.
+It holds at each width f>=3. Thus this model has no positive complete
+recursive moment at any saving exponent 0<C<1, where t=1-C.
+It does not claim a universal obstruction for other address alphabets,
+helper sharing, native source changes or nonlinear callers.
+
+## 2. Faithful characters and rank distance
+
+The one-bit Gaussian is
+
+    (1/2) [[1+i,1-i],[1-i,1+i]].
+
+Its two eigenvalues are 1 and i. The f-fold address lift has eigenvalues
+i^k for 0<=k<=f. For f>=3 all four fourth roots occur. In each J_a sector,
+both signs of a chosen square root q_a of J_a therefore occur. Different
+coordinate axes are tensor factors, so all joint sign choices occur in
+every joint even-power sector. This uses tensor products on addresses,
+not tensor powers of the two-field A/B/C matrices.
+
+Fix one even-power sector and a base character q=(q_a). For a set S of
+axes, let q' negate q_a exactly on S. Every ordinary matrix is identical
+at q and q'. For any two field matrices define their rank distance by
+
+    d(M(q),M(q')) = rank(M(q)-M(q')).
+
+The telescoping identity for a product of matrices gives
+
+    d(G_n(q)...G_1(q), G_n(q')...G_1(q'))
+      <= sum_j d(G_j(q),G_j(q')).
+
+Each term is multiplied on its left and right by other matrices, which
+cannot increase its rank. Pad the finite computation to one field bank
+to include copies, zero fields and retained results. Restricting to the
+original input columns and productive output rows cannot increase rank.
+This proves the same inequality with arbitrary interleaving and feedback
+through previously computed linear values. It is not a one-snapshot bound.
+
+For independent diagonal Gaussian targets, the left side is exactly the
+number of target supports that meet S in odd cardinality. Their nonzero
+diagonal values change sign exactly in that case. Invertible ordinary
+boundary matrices preserve this rank. A rank-r additional query has rank
+distance one or zero under the same odd-intersection rule.
+
+## 3. Exact cut charge of a whole B/C call
+
+Let c indicate a central sign flip and e indicate an odd number of flips
+among the seven transverse axes. Then D changes to (-1)^e D. Direct
+subtraction of the two displayed pair matrices gives these ranks:
+
+| c | e | A pair | B pair | C pair |
+|---|---|---|---|---|
+| 0 | 0 | 0 | 0 | 0 |
+| 1 | 0 | 1 | 1 | 1 |
+| 0 | 1 | 2 | 2 | 2 |
+| 1 | 1 | 2 | 1 | 1 |
+
+For example, in the last row the B difference is
+D*[[2,0],[2,0]], while the A difference is 2D*I.
+These calculations hold for every nonzero complex q and D.
+Transposition preserves rank. Also
+
+    M(q)^-1 - M(q')^-1
+      = -M(q)^-1 (M(q)-M(q')) M(q')^-1.
+
+Both outside matrices are invertible, so inverse and inverse-transpose
+calls have exactly the same ranks. The source even-power corrections have
+the same values at both characters and preserve rank. The 56/56 direct
+sum and ordinary port permutations give a whole-call cut charge of 0,
+112,224,168 in the four table rows.
+
+Now flip each global axis independently with probability p, where
+0<p<1/2. Put
+
+    h_p(r) = (1-(1-2p)^r)/2.
+
+This is the probability of an odd number of flips on r distinct axes.
+The central flip and the transverse parity are independent within each
+call. Axis reuse by different calls does not change linearity of
+expectation. The expected whole-call charge is exactly
+
+    224*h_p(7) + 112*p - 168*p*h_p(7)
+      = 140*h_p(7) + 28*h_p(1) + 84*h_p(8).
+
+The verifier also obtains this polynomial by enumerating all 256 masks
+and their exact Bernoulli weights. For any complete caller, the rank
+distance inequality therefore gives
+
+    sum_i h_p(r_i)
+      <= (L_B+L_C)*(140*h_p(7)+28*h_p(1)+84*h_p(8))
+         + sum_extra_queries h_p(r).
+
+No serial topology, fixed number of main owners, disjoint stage axes or
+target/query rank cutoff is used here.
+
+## 4. From random cuts to every positive saving exponent
+
+For 0<t<1, the number
+
+    Z_t = integral_0^infinity (1-exp(-s))*s^(-t-1) ds
+
+is positive and finite. Near zero its integrand has order s^-t; near
+infinity it has order s^(-t-1). The substitution u=rs gives
+
+    r^t = (1/Z_t) integral_0^infinity (1-exp(-r*s))*s^(-t-1) ds.
+
+Set p=(1-exp(-s))/2. Then 1-exp(-r*s)=2*h_p(r).
+Integrate the preceding cut inequality against this positive measure.
+All sums have finitely many nonnegative terms. This gives
+
+    sum_i r_i^t <= (L_B+L_C)*K(t) + sum_extra_queries r^t.
+
+The exact extra-query moment cancels its charged cost. It cannot open a
+gap by using a higher rank or by feeding a later native call. Add the
+separate native helper targets and subtract the exact local paid profiles
+to obtain the asserted upper bound on F(t).
+
+This argument also applies to positive mixtures of the functions
+1-exp(-s*r), with a nonnegative linear term. It does not assert the
+whole-caller capacity inequality for every concave function. The bill
+comparison in the next section does hold for every nondecreasing concave
+g with g(0)=0; these are distinct statements.
+
+## 5. Exact complete bills and strict sign
+
+The frozen PR4703 profiles, audited in PR4712, are:
+
+| Type | Paid rank:count | Independent helper rank:count | Net rank mass |
+|---|---|---|---|
+| B | 1:1956, 2:450, 3:403, 4:127, 5:28, 8:8 | 3:2, 4:26, 6:7, 7:47, 8:326 | 1688 |
+| C | 1:2011, 2:445, 3:427, 4:112, 5:12, 7:8 | 3:26, 4:2, 6:6, 7:48, 8:326 | 1680 |
+
+After subtracting the capacity coefficients 1:28, 7:140, 8:84 and
+cancelling equal ranks, the exact delta coefficients are:
+
+| Type | Positive terms | Negative terms |
+|---|---|---|
+| B | 1:1928, 2:450, 3:401, 4:101, 5:28 | 6:7, 7:187, 8:402 |
+| C | 1:1983, 2:445, 3:401, 4:110, 5:12 | 6:6, 7:180, 8:410 |
+
+Remove 8*g(1) from the positive B terms. The remaining positive and
+negative rank masses are equal: 4567 for B and 4576 for C. Every positive
+rank is at most 5; every negative rank is at least 6. For a nondecreasing
+concave g with g(0)=0, the ratio g(r)/r is nonincreasing. Consequently
+
+    Delta_B(g) >= 8*g(1) + 4567*(g(5)/5-g(6)/6),
+    Delta_C(g) >=           4576*(g(5)/5-g(6)/6).
+
+For g(r)=r^t and 0<t<1, the common ratio gap is strictly positive.
+This proves the sign for the full open interval, without sampling
+exponents. In the linear limit t=1, the deltas are 8 and 0.
+
+As a quantitative example only, at C=9/2500=.0036 the exact interval
+checks give Delta_B>31.58147 and Delta_C>23.98603. These are deficits in
+the raw recursive moment per whole call, not kappa values. The checker
+uses integer powers to enclose each r^(-9/2500); decimal arithmetic only
+proposes the endpoints. Any finite native work or outer reserve that was
+granted free can only worsen the already negative bill in this model.
+
+## 6. What changes this conclusion
+
+PR4848 proves a serial ceiling on the same 224 owners and fresh stage
+axes. This proof removes those premises. Merely adding main owners,
+interleaving paid queries, reusing axes, changing port placement, using
+noncoordinate scalar role gauges, or packing ordinary even-power sectors
+does not evade this theorem while its contract holds. The scalar
+rank-distance and integral facts are classical; the exact application to
+the admitted 56/56 B/C endpoint and complete bill is the new result.
+
+The following changes require a new proof and bill: shared or productive
+helper feedback into the main computation; a joint native call with a
+different endpoint or paid profile; noncommuting address maps between
+calls; a target in another address chart; nonlinear operations; or a
+source resource with an odd input gauge whose preparation has a different
+contract. These are boundaries, not claims of feasible profitable callers.
+
+The eight-transverse-axis A interface has rank capacity 1904 in the linear
+limit, rather than 1680. The checker retains this positive scope control.
+No obstruction for the productive eight-axis P104 family follows. A
+query-only caller also attains equality, at any query rank, including ranks
+above eight. The theorem is not a universal lower bound for multiplication.
+
+## 7. Verification and inherited obligations
+
+The written proof quantifies over all callers in the stated model and all
+f>=3. The standard-library verifier authenticates frozen source bytes,
+checks 864 rational pair/orientation/sign cases, enumerates the cut
+polynomials, and checks 5952 character pairs in twelve mixed finite-field
+circuits. It verifies the bill cancellation, exact power intervals and
+four corruption controls. Those finite checks support the algebra; they
+are not substituted for the all-width or all-caller proof.
+
+The full native word, phases, helper ownership and compiler are inherited
+from the cited source and audit. They were not rerun here. No new native
+caller, formal proof-assistant theorem, complete multiplication algorithm,
+selected-frontier change or independent scientific acceptance is claimed.
+
+Credit Dugongue for PR4703 and the typed-provider work in PR5578/5586;
+Cao Yifan/intqwq for PR4712; Chris R/Clear1nsight for PR4848; Cinna Davis
+for PR4674 and the controller lineage; Ali Romman for PR5626's query-rank
+perspective; DaysSky, zxv, Jacob Alan Sussman and all retained source authors.
diff --git a/research/complementary-caller-capacity-gate/README.md b/research/complementary-caller-capacity-gate/README.md
new file mode 100644
index 0000000000..88ea270f75
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/README.md
@@ -0,0 +1,108 @@
+# A whole-caller obstruction for the actual seven-axis B/C suppliers
+
+**Scoped proof; no new kappa.** The unchanged B/C suppliers cannot give a
+positive complete recursive moment in the declared coordinate model, even
+with arbitrary main wiring, any number of independent inputs, field mixing,
+axis reuse, retained values and paid extra queries of any rank.
+
+The result extends the fixed-224-owner serial ceiling in
+[PR4848](https://github.com/CrocSwap/integer-mult-bounds/pull/4848).
+It gives a concrete expansion gate: adding owners, scalar role gauges or
+another schedule inside this model cannot improve kappa. A useful new
+construction must change the source, helper contract or permitted maps.
+
+## Result and scope
+
+For t=1-C, every whole B or C call contributes at most
+
+    K(t) = 28 + 140*7^t + 84*8^t
+
+to the independent main target moment after the exact extra-query moment
+is subtracted. The source paid bill minus its independent helper credit
+strictly exceeds K(t) for every 0<t<1. At C=.0036, the excess per call is
+greater than 31.58147 for B and 23.98603 for C. These are raw moment
+deficits, not kappa values. See [PROOF.md](PROOF.md) for all hypotheses
+and the proof for the entire interval.
+
+All calls and targets use one common coordinate chart. Ordinary maps are
+complex-linear field matrices in the scalar algebra of the coordinate
+Gaussian even powers. This includes noncoordinate scalar role mixing and
+ordinary sector projectors. It excludes general address maps, value
+conjugation and free odd input gauges. Each whole call retains its 408
+fresh independent helpers, separate from the main computation. The proof
+allows inverses, transposes, inverse transposes, different central axes
+between calls, and any target/query ranks. It holds at every width f>=3.
+
+The key step compares two sign characters in a fixed even-power sector.
+Rank distance is subadditive through arbitrary linear circuits. Averaging
+random sign cuts gives an exact whole-call polynomial. A positive integral
+then converts this cut bound into the rank^t moment for every 0<t<1.
+The two-character argument removes the rank cutoff in the initial claim.
+
+## Evidence and reproduction
+
+[RESULT.json](RESULT.json) records 864 exact rational pair/orientation/sign
+checks, all 256 source sign masks, 5952 character-pair comparisons in twelve
+mixed finite-field circuits, the source bill cancellation, and four rejected
+corruptions. The cutoff-free proof is written mathematics; finite circuit
+checks alone do not prove it. Integer-power inequalities certify the stated
+numerical deficits. Positive controls retain query-only equality and the
+larger capacity of an eight-transverse-axis A interface.
+
+```sh
+python3.12 -B scripts/research_package.py --package research/complementary-caller-capacity-gate
+```
+
+The registered replay runs normal and optimized Python with isolated imports
+and warnings as errors. Python 3.12 and its standard library suffice. Direct
+replay also works without Git:
+
+```sh
+python3.12 -I -W error -B research/complementary-caller-capacity-gate/verify.py
+```
+
+The direct checker authenticates the package-local frozen bytes in
+[INPUTS.json](INPUTS.json). [SOURCES.json](SOURCES.json) records canonical
+main `6cf7a683f447b9f1e2333791907fd92be5009a63`, exact Git objects and hashes.
+The native source word and its complete phase/ownership/compiler audit
+are inherited from PR4703/4712 and were not rerun here. No native caller,
+formal-kernel proof, selected result or independent scientific acceptance
+is claimed. The productive eight-axis P104 family is outside this result.
+
+## Coordination and prior work
+
+[Discussion5628](https://github.com/CrocSwap/integer-mult-bounds/discussions/5628)
+is the canonical claim and handoff. The current priorities, handoffs,
+paginated open PRs, Discussions and tracked local package notes were checked
+before this round. Code diffs, all closed historical PR bodies and private
+work were not searched exhaustively. No overlap search proves novelty.
+
+The exact B/C source and audit are
+[PR4703](https://github.com/CrocSwap/integer-mult-bounds/pull/4703) and
+[PR4712](https://github.com/CrocSwap/integer-mult-bounds/pull/4712).
+[PR4848](https://github.com/CrocSwap/integer-mult-bounds/pull/4848) gives the
+narrower serial result and credits the direct-price method of
+[PR4674](https://github.com/CrocSwap/integer-mult-bounds/pull/4674).
+[PR5578](https://github.com/CrocSwap/integer-mult-bounds/pull/5578) and
+[PR5586](https://github.com/CrocSwap/integer-mult-bounds/pull/5586) give the
+typed-provider work. [PR5626](https://github.com/CrocSwap/integer-mult-bounds/pull/5626)
+supplies the query-rank perspective. No emitter or source word was copied
+from that pending contribution.
+
+## Open next questions
+
+1. Can a shared native producer use helper information in the main computation
+   with a favorable full bill? Give one exact all-input joint endpoint and
+   independent helper census first. No such producer is supplied here.
+2. Can a map outside the declared complex-linear coordinate algebra reduce a
+   whole caller bill? Exhibit the exact failed sign-sector implication and
+   price preparation, restoration and every paid query. No profitable map
+   or caller of this kind is supplied here.
+
+## Credit
+
+Credit Dugongue, Cao Yifan/intqwq, Chris R/Clear1nsight, Cinna Davis, DaysSky,
+zxv, Jacob Alan Sussman and all retained native/controller/compiler authors.
+Classical rank-distance and integral identities are not claimed as new.
+Prepared by Ali Romman with substantial OpenAI Codex assistance. New work is
+Apache-2.0; frozen source notices are retained.
diff --git a/research/complementary-caller-capacity-gate/RESULT.json b/research/complementary-caller-capacity-gate/RESULT.json
new file mode 100644
index 0000000000..6be29a7ba0
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/RESULT.json
@@ -0,0 +1,199 @@
+{
+  "Gaussian_eigenvalue_multiplicities": {
+    "1": [
+      1,
+      1,
+      0,
+      0
+    ],
+    "10": [
+      256,
+      272,
+      256,
+      240
+    ],
+    "11": [
+      496,
+      528,
+      528,
+      496
+    ],
+    "12": [
+      992,
+      1024,
+      1056,
+      1024
+    ],
+    "13": [
+      2016,
+      2016,
+      2080,
+      2080
+    ],
+    "14": [
+      4096,
+      4032,
+      4096,
+      4160
+    ],
+    "15": [
+      8256,
+      8128,
+      8128,
+      8256
+    ],
+    "16": [
+      16512,
+      16384,
+      16256,
+      16384
+    ],
+    "2": [
+      1,
+      2,
+      1,
+      0
+    ],
+    "3": [
+      1,
+      3,
+      3,
+      1
+    ],
+    "4": [
+      2,
+      4,
+      6,
+      4
+    ],
+    "5": [
+      6,
+      6,
+      10,
+      10
+    ],
+    "6": [
+      16,
+      12,
+      16,
+      20
+    ],
+    "7": [
+      36,
+      28,
+      28,
+      36
+    ],
+    "8": [
+      72,
+      64,
+      56,
+      64
+    ],
+    "9": [
+      136,
+      136,
+      120,
+      120
+    ]
+  },
+  "bills": {
+    "B": {
+      "bill_minus_capacity": {
+        "1": 1928,
+        "2": 450,
+        "3": 401,
+        "4": 101,
+        "5": 28,
+        "6": -7,
+        "7": -187,
+        "8": -402
+      },
+      "gap_at_C_9_over_2500": {
+        "lower": "3947684195111129/125000000000000",
+        "upper": "15790736780449087/500000000000000"
+      },
+      "hinge_margins_1_to_16": [
+        "2312",
+        "2696",
+        "2630",
+        "2163",
+        "1595",
+        "999",
+        "410",
+        "8",
+        "8",
+        "8",
+        "8",
+        "8",
+        "8",
+        "8",
+        "8",
+        "8"
+      ],
+      "linear_gap": 8,
+      "separated_mass": 4567
+    },
+    "C": {
+      "bill_minus_capacity": {
+        "1": 1983,
+        "2": 445,
+        "3": 401,
+        "4": 110,
+        "5": 12,
+        "6": -6,
+        "7": -180,
+        "8": -410
+      },
+      "gap_at_C_9_over_2500": {
+        "lower": "2398603550203623/100000000000000",
+        "upper": "11993017751022691/500000000000000"
+      },
+      "hinge_margins_1_to_16": [
+        "2355",
+        "2727",
+        "2654",
+        "2180",
+        "1596",
+        "1000",
+        "410",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0",
+        "0"
+      ],
+      "linear_gap": 0,
+      "separated_mass": 4576
+    }
+  },
+  "capacity_polynomial_in_p": [
+    "0",
+    "1680",
+    "-10584",
+    "38416",
+    "-86240",
+    "122304",
+    "-106624",
+    "51968",
+    "-10752"
+  ],
+  "graph_checks": {
+    "character_pair_checks": 5952,
+    "circuits": 12,
+    "steps_each": 36
+  },
+  "main_capacity": {
+    "1": 28,
+    "7": 140,
+    "8": 84
+  },
+  "pair_rank_cases": 864,
+  "rejected_controls": 4,
+  "scope": "Coordinate Gaussian callers; ordinary even-power algebra; separate fresh helpers; every f>=3 and 0<C<1. No new kappa.",
+  "status": "PASS_COMPLEMENTARY_CALLER_CAPACITY_GATE"
+}
diff --git a/research/complementary-caller-capacity-gate/SOURCES.json b/research/complementary-caller-capacity-gate/SOURCES.json
new file mode 100644
index 0000000000..0c3846ced6
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/SOURCES.json
@@ -0,0 +1,60 @@
+{
+  "schema_version": 1,
+  "base_commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "fc3d4ba105e1f097d0d7d051a308281e86ab1446",
+      "sha256": "66974efdced4083c00025f97d95d83909a226cdf801edb9301c195c6641f6903"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    },
+    {
+      "path": "research/native-dual-suppliers/QUOTIENT153-ROUND3-ACTUAL-PROFILE.json",
+      "git_blob": "0f04f7f6904a6fbd8ba5b4637babd1fb70766a1a",
+      "sha256": "c0ff4ea6bd3b8510f109203a90efba5d924edd9902641a96330f3bd1a7c2a571",
+      "usage": "provenance"
+    },
+    {
+      "path": "research/native-dual-suppliers/INTERSECTION153-ROUND3-ACTUAL-PROFILE.json",
+      "git_blob": "d01460798ff331e702e873957b4a7799345690b0",
+      "sha256": "0820837a5ddd25d81596eb3fb1f0a18d173f0958aa6ceab651fc71d64d24325c",
+      "usage": "provenance"
+    },
+    {
+      "path": "research/native-dual-suppliers/HETEROGENEOUS-CONTROLLER.md",
+      "git_blob": "13713545701f29d5f4743a3602538cad982ac476",
+      "sha256": "c6231bd89629e6356d576d9e8c81f7b42a0b79ab66b0b4c95b8d94520016f011",
+      "usage": "provenance"
+    },
+    {
+      "path": "research/kappa-round8-complement-audit-20261023/README.md",
+      "git_blob": "e92aa3b5a831611c9aca7935752cea91e1bf1e22",
+      "sha256": "4a5a37fadb83dd291b9d977a84693423ba4b1107c261dbbb5ec35730e67ff625",
+      "usage": "provenance"
+    },
+    {
+      "path": "research/complementary-consumer-feasibility/PROOF.md",
+      "git_blob": "836439b3fe7573834fb02c2a95716ac365162fb4",
+      "sha256": "a054291b524d264995112509f4d37df4284af49f0c1b589d79ac2d66cf9e2847",
+      "usage": "provenance"
+    },
+    {
+      "path": "research/complementary-consumer-feasibility/README.md",
+      "git_blob": "565b93c517327d4155598a1776cbb4569930a887",
+      "sha256": "d1caf689aa8a719a42b2e350e11b5c31cd9abbba11e8fe656c650c24e0c6462a",
+      "usage": "provenance"
+    },
+    {
+      "path": "research/characteristic-gaussian-provider/typed-provider.md",
+      "git_blob": "cc190c322d944eabd2a8fb36ad8d11923cb5c5ec",
+      "sha256": "dc1a21489807dc3553e4225b56534c4372ebafd72598eb673ef7c675f55fec21",
+      "usage": "provenance"
+    }
+  ]
+}
diff --git a/research/complementary-caller-capacity-gate/TASK.json b/research/complementary-caller-capacity-gate/TASK.json
new file mode 100644
index 0000000000..796b5cfc2d
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/TASK.json
@@ -0,0 +1,117 @@
+{
+  "schema_version": 1,
+  "task_id": "formal-interface-lemma",
+  "priority_revision": 7,
+  "base_commit": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+  "original_card": {
+    "id": "formal-interface-lemma",
+    "question": "Can one uncovered interface implication be formalized with exact caller and certificate bindings?",
+    "starting_points": [
+      "docs/research/research-family-status.md",
+      "certificates/selected-result.json",
+      "research/gate-operand-parity-lean/README.md",
+      "research/staged544-certified-endpoint/README.md",
+      "research/unconditional-batched-crt/README.md"
+    ],
+    "methods": [
+      "Formalize a missing boundary lemma identified by the selected review.",
+      "Audit a formal theorem-to-certificate binding independently."
+    ],
+    "acceptance_gate": "State the exact formalized proposition and remaining assumptions; avoid duplicate arithmetic formalizations already present.",
+    "first_step": {
+      "command": [
+        "python3",
+        "-B",
+        "scripts/research_baseline.py"
+      ],
+      "expected": "PASS_RESEARCH_BASELINE_BINDINGS_ONLY",
+      "inspect": "Inventory the gate-operand parity lemma (#3807) and certified endpoint arithmetic (#3857). Neither is a full multiplication proof. For #4100, audit the compact-switch statement and its hypotheses before formalizing it.",
+      "scope": "Source-binding orientation only; no scientific replay, theorem acceptance or supplier admission. Budget any heavy replay separately."
+    },
+    "first_experiment": "Write one missing statement with quantified hypotheses, actual caller and existing coverage. A compact-switch lemma is a candidate only after its mathematical contract is reviewed. Establish a bounded proof plan before a separately budgeted proof-assistant build; do not rerun large Lean jobs as orientation.",
+    "bottleneck_link": "A missing interface proof can reduce the conditional gap even if it does not change kappa.",
+    "allowed_variations": [
+      "Narrow to one formal lemma or one theorem-to-certificate binding."
+    ],
+    "scope_change_triggers": [
+      "Formalizing already-covered arithmetic and claiming the full multiplication theorem."
+    ],
+    "overlap_terms": [
+      "hyperplane end",
+      "formal interface",
+      "Lean binding",
+      "3807",
+      "3857",
+      "4100",
+      "gate-operand-parity-lean",
+      "staged544-certified-endpoint",
+      "unconditional-batched-crt"
+    ],
+    "existing_checks": [
+      {
+        "scope": "PR #3807: scoped gate-operand parity formalization.",
+        "evidence": "research/gate-operand-parity-lean/README.md",
+        "remaining": "Exact theorem-to-caller binding and genuinely uncovered interface lemmas.",
+        "status": "author-checked",
+        "source_commit": "4c3530f42a6abcc48e7a6bcffd6c901911dc8269",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "PR #3857: certified real-power moment/endpoint arithmetic.",
+        "evidence": "research/staged544-certified-endpoint/README.md",
+        "remaining": "Uniform algorithmic implications, not another endpoint digit.",
+        "status": "author-checked",
+        "source_commit": "ef4315b8caa605e47a2515004845eb2d2ed71a86",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      },
+      {
+        "scope": "PR #4100: compact-switch formalization proposed as future validation.",
+        "evidence": "research/unconditional-batched-crt/README.md",
+        "remaining": "Audit the statement and assumptions before a formal proof campaign.",
+        "status": "author-checked",
+        "source_commit": "337d04939571a637aeab54a0f58f54fde811663a",
+        "selected_record_sha256": "bb2eaa58647b353f88d0aec2eafb9d30df1be53589231b23e12ceef3e4bad129"
+      }
+    ]
+  },
+  "scope_status": "changed",
+  "actual_scope": "Prove a whole-caller capacity and complete-moment obstruction for the exact seven-axis B/C suppliers under the ordinary even-power coordinate alphabet.",
+  "scope_change_reason": "The user asked for ten useful contributions. The live handoff and PR4848 leave arbitrary-owner, nonserial callers open. The task picker suggested unrelated diagnostics. This handoff-led override gives a written interface proof and exact checks, not a Lean theorem. The initial per-axis plan was strengthened to a two-character rank-distance proof, which removes every target/query rank cutoff.",
+  "bottleneck_link": "This rules out attempts to improve kappa through arbitrary main wiring, role mixing, axis reuse or extra coordinate queries using the unchanged B/C whole calls. It states which source or address contract must change before another construction can help.",
+  "budget_minutes": 90,
+  "stop_rule": "Stop after the all-caller sign proof, exact source bill, independent finite controls and publication checks pass. Do not emit another caller inside a proved negative scope.",
+  "outcome": "negative-result",
+  "evidence": "PROOF.md gives the quantified proof. RESULT.json and verify.py bind the frozen source and check rank identities, cut polynomials, complete bills and exact power intervals.",
+  "author": "Ali Romman",
+  "ai_assistance": "Substantial OpenAI Codex assistance in proof development, implementation, verification and publication.",
+  "open_questions": [
+    {
+      "question": "Can a shared native producer use helper information in the main computation with a favorable complete bill?",
+      "why_it_matters": "Separate helpers are a premise of this obstruction. A real shared endpoint could change the capacity per paid call.",
+      "first_step": "Give one exact all-input joint endpoint and its full independent helper census before emitting a caller.",
+      "blocked_by": "No source-bound shared producer with a profitable complete moment is provided here."
+    },
+    {
+      "question": "Can an explicit address map outside the even-power coordinate algebra reduce a whole caller bill?",
+      "why_it_matters": "Such a map can invalidate the two-character comparison, but its preparation and restoration must be priced.",
+      "first_step": "Exhibit one concrete map and the exact sign-sector implication it breaks, then bind a complete source-compatible word.",
+      "blocked_by": "No useful fully priced noncommuting caller map is established."
+    }
+  ],
+  "coordination": {
+    "discussion": "https://github.com/CrocSwap/integer-mult-bounds/discussions/5628",
+    "base": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+    "prior_scope": "PR4848 / Discussion4853: serial calls on 224 fixed owners; this result removes that restriction. PR5617 concerns P104 stages. PR5626 supplies the query-rank perspective.",
+    "overlap_coverage": "Live paginated open PR bodies and Discussions plus tracked local package notes; not all code diffs, closed historical bodies or private work.",
+    "final_refresh": {
+      "canonical_main": "6cf7a683f447b9f1e2333791907fd92be5009a63",
+      "priority_revision": 7,
+      "open_prs": 325,
+      "open_prs_fetched_at": "2026-10-26T00:23:45.046411+00:00",
+      "discussion_records": 4904,
+      "discussions_fetched_at": "2026-10-26T00:24:47.534749+00:00",
+      "complete_pagination": true,
+      "finding": "No matching active B/C caller claim was found. PR5627 changes P104 helpers; PR5629 changes BIT partial-helper continuation. Both are outside this B/C scope."
+    }
+  }
+}
diff --git a/research/complementary-caller-capacity-gate/VERIFY.json b/research/complementary-caller-capacity-gate/VERIFY.json
new file mode 100644
index 0000000000..911ef3534b
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/VERIFY.json
@@ -0,0 +1,34 @@
+{
+  "schema_version": 1,
+  "status": "ready",
+  "python": "3.12",
+  "requirements": [],
+  "inputs": [],
+  "commands": [
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Authenticate source bytes and bills; check pair/sign ranks, cut polynomials, finite mixed graphs, faithful eigenspaces, exact power bounds, positive scope controls and four corruptions."
+    },
+    {
+      "argv": [
+        "{python}",
+        "-I",
+        "-O",
+        "-W",
+        "error",
+        "-B",
+        "{package}/verify.py"
+      ],
+      "timeout_seconds": 120,
+      "checks": "Replay with Python assertions disabled; compare the exact same frozen result."
+    }
+  ]
+}
diff --git a/research/complementary-caller-capacity-gate/inputs/B-PROFILE.json b/research/complementary-caller-capacity-gate/inputs/B-PROFILE.json
new file mode 100644
index 0000000000..0f04f7f690
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/inputs/B-PROFILE.json
@@ -0,0 +1,35 @@
+{
+  "status": "PASS_Q153_SHARED_MAPS_FORMAL_ENDPOINTS_ALL_WARP_PHASES",
+  "paid": {
+    "1": 1956,
+    "2": 450,
+    "3": 403,
+    "4": 127,
+    "5": 28,
+    "8": 8
+  },
+  "helpers": {
+    "8": 326,
+    "4": 26,
+    "7": 47,
+    "6": 7,
+    "3": 2
+  },
+  "local_deficit": 1688,
+  "new_warp_outputs": [],
+  "formal": {
+    "backward": {
+      "rows": 632,
+      "terms": 744,
+      "nonempty_words": 0
+    },
+    "forward": {
+      "rows": 632,
+      "terms": 744,
+      "nonempty_words": 0
+    }
+  },
+  "payload_sha256": "aac6822eeb412a8690791d0755d2a7d2ff4da3198260e199b75499c8d9924f39",
+  "warp_classes": 180,
+  "warp_phase_seconds": 8.98399999999674
+}
\ No newline at end of file
diff --git a/research/complementary-caller-capacity-gate/inputs/C-PROFILE.json b/research/complementary-caller-capacity-gate/inputs/C-PROFILE.json
new file mode 100644
index 0000000000..d01460798f
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/inputs/C-PROFILE.json
@@ -0,0 +1,60 @@
+{
+  "status": "PASS_H153_SHARED_MAPS_FORMAL_ENDPOINTS_ALL_WARP_PHASES",
+  "paid": {
+    "1": 2011,
+    "2": 445,
+    "3": 427,
+    "4": 112,
+    "5": 12,
+    "7": 8
+  },
+  "helpers": {
+    "8": 326,
+    "3": 26,
+    "7": 48,
+    "6": 6,
+    "4": 2
+  },
+  "local_deficit": 1680,
+  "new_warp_outputs": [
+    {
+      "operator": 2,
+      "input": 189,
+      "old_output": 1087,
+      "new_output": 1943
+    },
+    {
+      "operator": 3,
+      "input": 192,
+      "old_output": 1087,
+      "new_output": 1943
+    },
+    {
+      "operator": 4,
+      "input": 192,
+      "old_output": 1087,
+      "new_output": 1943
+    },
+    {
+      "operator": 29,
+      "input": 192,
+      "old_output": 1087,
+      "new_output": 1943
+    }
+  ],
+  "formal": {
+    "backward": {
+      "rows": 632,
+      "terms": 744,
+      "nonempty_words": 0
+    },
+    "forward": {
+      "rows": 632,
+      "terms": 744,
+      "nonempty_words": 0
+    }
+  },
+  "payload_sha256": "7f137c4b95db519d04ad2336ef1a146fbc953124e95940d10b572a63ab958c87",
+  "warp_classes": 180,
+  "warp_phase_seconds": 14.297000000020489
+}
\ No newline at end of file
diff --git a/research/complementary-caller-capacity-gate/inputs/INTERFACE.md b/research/complementary-caller-capacity-gate/inputs/INTERFACE.md
new file mode 100644
index 0000000000..1371354570
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/inputs/INTERFACE.md
@@ -0,0 +1,61 @@
+# Heterogeneous seven-axis suppliers with exact port transport
+
+Prepared for Dugongue with substantial OpenAI Codex assistance. Apache-2.0.
+
+## Physical interface
+
+Consider two independently admitted local words with 112 independent main pairs and 408 independent helper fields. Their main endpoints, after explicit monomial wrappers, are direct sums of seven-axis primitives with a common central Q:
+
+    A = diag(D,D) S_y(Q^-1),
+    B = diag(1,Q) A,
+    C = A diag(Q,1).
+
+Here D acts on seven fresh coordinate axes, Q on a separate central axis, and Q² is an explicit monomial. Each B-provider call has 56 A and 56 B ports. Each C-provider call has 56 A and 56 C ports. Their logical words, paid profiles and helper profiles remain separately authenticated; equal counts of main types do not identify the underlying helper inputs.
+
+Backward interfaces are the actual inverse transposes. To compare them with the retained source controller, explicitly apply input-Y Q², output-Y Q^-2 and output D² on both fields. The resulting source-convention backward A is diag(D,D) S_x(-Q), backward B has its extra Q^-1 on output Y, and backward C has its extra Q^-1 on input X. The extra phases and even powers are retained as monomial wrappers. These corrections do not add recursive Gaussian calls.
+
+## Arbitrary placement of the 56 exceptional ports
+
+Let sigma be any permutation of the 112 main pairs. Apply the corresponding permutation to both input banks X_i,Y_i, execute the local word, then apply the inverse permutation to both main output banks. Leave helper banks untouched. The main endpoint is the conjugate direct sum, so any chosen 56 ports can carry the exceptional B or C type. The paid profile and all 408 independent helper endpoint operators are unchanged.
+
+This conclusion uses the admitted direct-sum endpoint: each helper output depends only on its own arbitrary input, and no helper input contributes to a main output. Therefore main-only pair permutations introduce no disguised helper identification, sharing, loss of arbitrariness or changed input ABI. These zero cross-block facts are verified by the free-group-algebra endpoint certificate. No per-occurrence inconsistent warp map is chosen.
+
+The pair permutation is an actual native operation. Decompose the permutation of 224 banks into at most 223 transpositions. Each transposition is the literal reversible scalar sequence x+=y; y-=x; x+=y; y=-y. It swaps the two fields exactly, preserves every independent input and uses no overwrite/CLEAR on borrowed data. One constant guard bit covers intermediate sums. Input plus inverse output use at most 446 transpositions, hence at most 1,784 scalar bank passes. At at most 16 native operations per complex-record scalar pass this is 28,544 V, leaving an additional allowance of 30,000 V including loop/index bookkeeping. Pointer relabeling may be cheaper but is not required. An owned-temporary cycle-copy implementation is also possible on ordinary RAM, but is unnecessary for the stricter reversible-scalar protocol.
+
+In particular one may use two fixed groups of 56 global ports and independently choose at each LOCAL which group receives the exceptional type. This is a genuine new degree of freedom beyond keeping the same exceptional port class at every stage. A computed assignment still needs its complete chronological incidence check.
+
+## Exact row-gauge consumption
+
+At each controller row use a central gauge Q^a, retaining the full integer exponent and accounting for parity only when pricing Gaussian rank. For a logical ADD with coefficient epsilon Q^k, the physical coefficient is epsilon Q^(k+a_target-a_source). An odd exponent requires one rank-one Gaussian call; an even exponent is an explicit monomial. A temporary COPY/transform/ADD/CLEAR implementation preserves the source and pays that Gaussian exactly once. It uses only owned temporary erasure.
+
+For an A-type LOCAL, input row parities must agree; the two outputs keep that common parity. For B, input parities agree and physical Y flips at the output. For C, input parities are opposite and both output parities equal the input Y parity; equivalently C has an input-X flip followed by A. The same parity rules hold in the backward source convention after the stated monomial wrappers. The X/Y identities refer to physical banks, not to whichever row is the shear source in that orientation.
+
+The controller's scalar RIGHT boundary program runs first, then its physical events, then its scalar LEFT boundary program. Carry the gauges through both boundary programs and price every crossed-parity ADD. Signed swaps carry their gauges with the swapped rows. An optimizer that ignores these boundary programs does not establish a usable diagonal target.
+
+## Exact whole invoice
+
+Let n_B and n_C be the numbers of the two provider calls, with n_B+n_C=p+2 in the retained p-pair controller. The helper targets are the multiset sum n_B H_B+n_C H_C, with a fresh independent copy of every helper at every call. The local Gaussian paid jobs are n_B P_B+n_C P_C. Add each actual seven-axis IDLE job, each actual rank-one query/ADD/gauge-correction job, and every additional explicitly emitted recursive child. Do not also include the old thin-query bill if those queries were replaced by the actual gauged jobs; that would double-count.
+
+For a final diagonal row with retained Laurent monomial Q^m product_s D_s^(e_s), its actual central rank is (m+a_final) modulo two, not a_final by itself. Its total target rank is
+
+    7 sum_s e_s + ((m+a_final) mod 2),
+
+for the retained 0/1 fresh-slot exponents. Initial gauges are frozen. All even powers, signs and inverse D orientations belong to explicit monomial normalizers. The complete formal Laurent identity must be replayed using the emitted gauged controller, not merely priced from a mask.
+
+The exact whole rank-mass surplus is sum(rank*target_count)-sum(rank*paid_count) for this rebuilt invoice. A positive rank-mass surplus is only an initial screen. A strictly positive complete moment at a specified exponent, the mirror/critical majorant, finite uniform compiler, precision and native outer assembly are required before claiming a new kappa.
+
+## Spectator and coordinate embedding
+
+A B-provider's ninth local coordinate is a spectator on the main typed endpoint but may be active in independent rank-nine helper jobs. It must be embedded as a genuine extra coordinate chosen outside the central axis and current seven-axis block; another stage's fresh coordinate suffices because p>=2. The complete global address space has rank 1+7(p+2), so this extra coordinate exists. Main output identity on that coordinate is an actual typed-interface fact, not a reason to discard its helper action. The borrowed coordinate labels addresses; it is not borrowed storage and does not identify two independent helper fields.
+
+A C-provider whose complete admitted word lives in an eight-plane may use only central plus seven local coordinates; its ninth identity spectator remains explicit. Every whole-job normalizer is formed on its actual active coordinates. No block-eight diagonal credit is inferred from a helper-only padded spectator.
+
+## Local native allowance
+
+For the frozen source words, each orientation contains 17,453 scalar events, 240 native warp events, 448 inherited adapter markers and at most 3,195 paid Gaussian jobs. All scalar numerator/denominator magnitudes are at most 8. Allow two exact nine-axis monomial normalizers per paid child, the native warp monomials, all explicit main wrappers, the backward-convention corrections and both helper whole-job normalizers. Fewer than 9,000 nine-axis lifted monomial operations suffice per local call. This is a conservative count, not a practical runtime estimate.
+
+A lifted fixed nine-axis monomial is a binary 9×9 block map and a Z4 quadratic phase on nine f-bit blocks, with arbitrary identity spectators. Its address is formed with at most 81 block XORs and fixed shifts/masks. Compute each phase using at most 45 block parity/Hamming-weight-mod-4 functions; a parity chunk table on max(1,floor(f/16)) bits gives at most 31 chunks per f-bit block. Including the table setup, scatter/gather, phase multiplication, loop/index operations and fixed metadata, 10,000 V native operations per such map is a deliberately loose eventual bound. Tables are prepared by explicit recurrences and cost O(V), not an oracle. Thus fewer than 9e7 V operations cover these monomials; 64 operations per scalar event, the bank permutations and a further million-operation metadata reserve leave the nonrecursive LOCAL allowance below 10^8 V. Gaussian child work is charged separately in the paid profile. This bound concerns the local primitive, not the entire p-stage controller or its larger main whole-job normalizers.
+
+All statements hold at each digit-column width f by the retained exact free-group-algebra evaluation theorem and blockwise tensorization of address-operator identities. They do not tensor the field-level 2×2 matrices. The full native construction remains source-bound in its inherited Gaussian, compiler and analytic premises. This note establishes a sufficient heterogeneous-consumer and exact accounting framework; it does not assert an unobserved profitable provider/gauge schedule.
+
+Credit the actual B/C supplier constructions and source owners; DaysSky, Cinna Davis, Cao Yifan, the retained controller authors, Dugongue's native Word RAM and frame-interface work, zxv, Jacob Alan Sussman and all original notices. The useful new mechanism is per-call physical port transport together with an honest heterogeneous profile, rather than repricing a changed endpoint as the old common supplier.
diff --git a/research/complementary-caller-capacity-gate/inputs/NATIVE-AUDIT.md b/research/complementary-caller-capacity-gate/inputs/NATIVE-AUDIT.md
new file mode 100644
index 0000000000..e92aa3b5a8
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/inputs/NATIVE-AUDIT.md
@@ -0,0 +1,142 @@
+# Independent admission audit of PR4703's complementary native suppliers
+
+Status: independent scalar/frame/ownership checks and the full exact phase replay
+passed. This package claims no new multiplication bound or profitable controller.
+Prepared by intqwq with substantial OpenAI Codex assistance; Apache-2.0.
+
+The audited source is [PR4703](https://github.com/CrocSwap/integer-mult-bounds/pull/4703),
+exact head `4cc96829fad977aecf0018b26beb067cfd2689a5`, by Dugongue.
+All 54 package files, including its 13 retained interpreter/Clifford files, are copied
+byte-for-byte under `upstream/`. `SOURCES.json` pins every original Git blob, SHA-256
+and byte count. Upstream notices and attribution remain intact. This audit adds an
+independent evaluator and receipt; it does not claim authorship of the suppliers.
+
+## What is admitted
+
+Both words implement a valid local supplier on 632 arbitrary independent persistent
+inputs: 224 main fields and 408 helper fields. The owned temporary's entry is also
+treated as arbitrary and must be cleared at return. `independent.py` imports no
+upstream evaluator or Clifford implementation. It executes the exact rational scalar
+word over the free group algebra, checks every chronological frame contact, each
+paid width and all 72 shared native maps on every occurrence, and compares every
+final input coefficient in both orientations. The result has 632 rows, 744 terms
+and no nonempty operator words. The retained scalar records match the original
+word exactly. Both meaningful mathematical corruption controls are rejected.
+
+For each helper, the entrance is a proper subspace of its exit. Its output depends
+only on its own arbitrary input after the physical endpoint transforms. Its rank
+is computed from that actual nested pair. No helper input is initialized or
+identified with another provider call's helper.
+
+The exact phase-aware upstream replay is separate evidence: `replay.py` invokes
+the original verifier with `-I -O -B` in its authenticated source directory,
+places its temporary regeneration copies under `.scratch/`, and checks that the
+original source bytes remain unchanged. The original wrapper launches assertion-
+enabled child evaluators for both orientations. Its success requires regenerated
+word, warp-phase, main-normalizer and paid/helper-phase mathematical payloads to
+match exactly, including absolute phases. `REPLAY.json` and the two log files
+record the successful result. This package adds no Lean formalization.
+
+## Complete local profiles and changed interface
+
+| Provider | Paid jobs | Independent helper jobs | Paid minus helper rank mass |
+| --- | --- | --- | --- |
+| B quotient | 1:1956, 2:450, 3:403, 4:127, 5:28, 8:8 | 3:2, 4:26, 6:7, 7:47, 8:326 | 1688 |
+| C restriction | 1:2011, 2:445, 3:427, 4:112, 5:12, 7:8 | 3:26, 4:2, 6:6, 7:48, 8:326 | 1680 |
+
+All owned centers are included. The C supplier includes its four required rank-one
+warp repairs at operators 2, 3, 4 and 29. The special ports agree exactly: each
+provider has 56 ordinary A ports and the same 56 exceptional B or C ports.
+
+Writing D for a seven-axis Gaussian and Q for an independent central one-axis
+Gaussian, the forward interfaces are
+
+    A = diag(D,D) Sy(Q^-1),
+    B = diag(1,Q) A,
+    C = A diag(Q,1).
+
+Backward interfaces are inverse transposes, with the explicitly described even
+Gaussian powers and signs normalized by monomial operations. They cannot be
+substituted for the previous common eight-axis main contract. The strict local
+C improvement compares with the older C restriction, whose productive profile
+and typed contract agree; it does not establish an improvement over the enclosing
+controller of PR4610.
+
+For completeness, the local difference claimed upstream is
+
+    -36 + 28*2^t + 4*3^t - 8*4^t < 0,  0 <= t < 1.
+
+Its supplied calculus proof is valid: for x=2^t and a=log_2(3), one has
+1<=x<2 and 1<a<2. The second derivative of the displayed function of x is
+strictly below -8, its derivative at 2 is 6a-4>2, and its value at 2 is zero.
+Thus it is increasing on [1,2] and negative below 2. This is a local cost lemma.
+
+## Admission and recurrence boundaries
+
+The finite free-group identity implies an all-width identity upon evaluating
+its consistently shared generators at the lifted native operators. Each address-
+operator block identity tensors separately. Tensor powers of field-level sums
+are not assumed. The separate exact Clifford lowering checks the actual
+normalizers and gives standard Gaussian whole jobs.
+
+The written native construction has an eventual fixed O(V) allowance. Our
+independent event meter finds 17,453 scalar events and 240 native warps per
+orientation, with scalar numerators/denominators at most 8. Counting two monomial
+normalizers per paid child, all warp/main/backward/helper wrappers gives fewer
+than 9,000 fixed nine-axis monomial operations. The stated local 10^8 V allowance
+therefore has a concrete finite-operation basis, including bank permutations.
+The detailed fixed-width arithmetic, parity tables, precision and guard handling
+still rely on the retained Word RAM/complex-Gaussian model and written native
+implementation argument. This audit does not produce a new finite-state
+compiler or outer transfer theorem, or import the older smaller scalar allowance.
+
+For a heterogeneous retained p-controller, let n_B+n_C=p+2. Its local contribution
+is precisely
+
+    P_local(t) = n_B sum_r P_B[r] r^t + n_C sum_r P_C[r] r^t,
+    T_helpers(t) = n_B sum_r H_B[r] r^t + n_C sum_r H_C[r] r^t.
+
+Each invocation owns a distinct set of all 408 helper channels. Additional paid
+terms include every actual rank-seven IDLE job, crossed-gauge scalar ADD, query
+and retag call, and any other explicitly emitted Gaussian. The old thin-query
+bill is replaced when queries change; it must not be counted twice. A choice
+of provider is a whole-call choice. Its exceptional 56-port subset may be moved
+by actual input/output bank permutations with finite native cost.
+
+The complete main targets must come from the diagonalized chronological word
+RIGHT, physical events, LEFT, including both scalar boundary programs. For an
+actual diagonal row with fresh-block exponents e_s and central exponent m, its
+changed productive rank is
+
+    7 sum_s e_s + ((m + a_out - a_in) mod 2).
+
+This is valid only after all physical gauge corrections and signed swaps are
+emitted and the resulting matrix is diagonal on the same independent channels.
+The initial gauge theorem changes the productive request honestly; it does not
+make a Gaussian input adapter free for an unchanged request. These conditional
+formulae do not supply a profitable mixed recurrence, spectral-radius estimate,
+or positive whole target-minus-paid moment. The present suppliers consequently
+cannot yet fund a new recursive phase adapter or a larger kappa.
+
+## Reproduction and dependencies
+
+From this directory using standard-library Python 3.12 or later:
+
+    python -I -B independent.py
+    python -I -B replay.py
+    python -I -B check_bundle.py
+
+The independent check takes a few seconds. The exact phase regeneration takes
+several minutes. Replay needs writable `.scratch/` and no network, Git object,
+solver, Lean installation or external repository path. `capture.py` is only a
+source-import aid and requires Git plus the pinned commit object; it is not
+needed for a clean-checkout audit replay. Original compressed bytes are pinned,
+while regeneration compares decompressed mathematical payloads.
+
+## Open next questions
+
+The missing construction is a profitable complete consumer of the actual B/C
+ports. Such a consumer must provide its chronological arbitrary-input operator,
+all independent helper channels and whole physical invoice. It must then satisfy
+the mirror/critical majorant, finite compiler reserve, precision and native outer
+assembly requirements. No further phase enumeration is part of this audit.
diff --git a/research/complementary-caller-capacity-gate/inputs/SERIAL-BOUND.md b/research/complementary-caller-capacity-gate/inputs/SERIAL-BOUND.md
new file mode 100644
index 0000000000..836439b3fe
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/inputs/SERIAL-BOUND.md
@@ -0,0 +1,94 @@
+# Complementary cancellation and its complete serial budget
+
+Chris R / Clear1nsight, with substantial OpenAI Codex assistance. Apache-2.0.
+
+## Sources and obligation
+
+PR4703 at 4cc96829fad977aecf0018b26beb067cfd2689a5 supplies actual complementary B/C native interfaces. PR4712 at b75a27bf07f1584b20babfddf887493981cd5949 independently audits the endpoints, frames, phases, helper ownership and refreshed local profiles. The unchanged audit and relevant inputs are retained byte for byte from canonical main 624de9dc66858af0945e5f8a0942488d62280d43. This package consumes those conditional interface facts; it does not replay the native scientific suite.
+
+The older PR4674 at 84cf25a580db9ed2b4b1371c40689a035711364e supplies the direct-price normalization method for the earlier B supplier. Its method is credited, not claimed as new. The new scope is an explicit complementary two-call cancellation on the refreshed B/C suppliers, and a screen of their serial fixed-owner consumers. PR4712's 120-head query and dirty-helper failures are different models and are not repeated.
+
+## Actual two-call word
+
+Use a shared central Gaussian Q and two disjoint seven-axis Gaussian blocks D1,D2. They commute because they act on disjoint address axes; the field matrices below are not tensor-powered. Let L(c)=[[1,0],[c,1]]. At stage s:
+
+    A_s = D_s [[1,0],[Q^-1,1]],
+    B_s = D_s [[1,0],[1,Q]],
+    C_s = D_s [[Q,0],[1,1]].
+
+The whole first invocation is the C provider and the whole second is the B provider. Use the same 56 exceptional ports in both. Each call has its own 408 independent helper inputs. Every main input remains arbitrary. On exceptional pairs the actual chronological word C1, B2, L(-2) gives
+
+    L(-2) B2 C1 = diag(D2 D1 Q,D2 D1 Q).
+
+On the 56 ordinary pairs the chronological word A1,A2,L(-2Q^-1) gives
+
+    L(-2Q^-1) A2 A1 = diag(D2 D1,D2 D1).
+
+The second terminal is a genuine rank-one query on each pair, implemented with the source contract's owned temporary, Q^-1 child, scalar multiply/add and owned clear. It cannot be replaced by L(-2). All monomial source wrappers and actual inverse-Gaussian normalizers are inherited. The helper fields are untouched by these main-only terminals and each returns its original independent Gaussian job exactly once. No helper is credited as a recovered main job.
+
+For any matrix W=T B2 C1, the actual raw dual is
+
+    W^-T=T^-T B2^-T C1^-T.
+
+The execution order is C1^-T, B2^-T, T^-T, the same chronological order with every gate replaced by its inverse transpose. Explicitly
+
+    B_s^-T=D_s^-1 [[1,-Q^-1],[0,Q^-1]],
+    C_s^-T=D_s^-1 [[Q^-1,-Q^-1],[0,1]],
+    A_s^-T=D_s^-1 [[1,-Q^-1],[0,1]],
+    L(c)^-T=[[1,-c],[0,1]].
+
+These expressions use symmetric canonical D_s,Q and retain their inverse powers; they do not identify Q with Q^-1. The verifier computes the inverse transpose algebraically and checks both complete endpoints over rational Laurent polynomials in D1,D2,Q without finite-order assumptions.
+
+This is a fully specified typed consumer with paid query children. It is not a newly emitted 1040-field native trace. Physical validity remains conditional on the audited supplier/normalizer/owned-temporary interface; no claim of new absolute-phase native replay or compiler admission follows.
+
+## Complete recursive bill and finite work
+
+The audited net local rank masses are B=1688 and C=1680. Add 56 rank-one terminal jobs. The new main jobs are 112 rank14 and112 rank15, rank mass3248. All816 helpers occur once in both the moment and ownership census. Thus the complete rank-mass deficit is
+
+    1688+1680+56-3248=176.
+
+The full paid and target histograms appear in RESULT.json. There are1040 independent persistent inputs:224 main and816 helpers. One owned query temporary can be reused serially; its clean entry/exit is not productive credit. The whole word inherits two local finite allowances each less than10^8 V under PR4703's native model, plus112 terminal additions,56 owned query COPY/clear sequences, their coefficient work and monomial normalization. Address permutations, storage, precision and the outer compiler remain separate finite obligations. Those costs are granted free only in the optimistic rejection screen below; their exact finite native constants are not needed to reject a negative recursive moment. No recursive price is invented for finite scalar work.
+
+## Refreshed direct-price lemma
+
+Let t=1-C and P_B,H_B,P_C,H_C be the authenticated current profiles. Define
+
+    g_J(C)=P_J(t)-H_J(t)-224*7^t-112.
+
+The direct primitives of either actual A/B or A/C interface cost224 rank-seven jobs and112 rank-one jobs, with helper jobs paid separately. B's exceptional output scalar shear and C's exceptional input scalar shear give their direct implementations. This is the existing PR4674 comparison extended to the current C profile.
+
+At C=0, g_B=8 and g_C=0. Normalize g_J/7^t. In its derivative, every signed-rank term is nonnegative except the negative rank-six helper term. The rank-seven term is constant. The rank-one term alone contributes at least (P_J[1]-112)/7 * log7; the rank-six term has magnitude at most H_J[6]*log(7/6). Since log7>1 and log(7/6)<1, the derivative is strictly greater than
+
+    B: (1956-112)/7-7 =1795/7 >0,
+    C: (2011-112)/7-6 =1857/7 >0.
+
+All other signs are checked against the authenticated profiles. Therefore for0<=C<1:
+
+    g_B(C)>=8*7^-C,
+    g_C(C)>=0,
+
+and both are strict relative to their starting normalized value for C>0. This proves the domain, not a numerical sample or monotonicity extrapolation. It also explains why the C local improvement does not supply a positive primitive discount at positive saving.
+
+## Scoped serial ceiling
+
+Fix n>=2 whole invocations on the same224 main owners, one shared Q, and n fresh disjoint seven-axis blocks. The only other productive fields are the independent408 helpers per invocation, preserved as their audited outputs. Require every completed main Gaussian job to act within these7n+1 axes. Allow arbitrary main permutations and scalar boundary programs, but no extra productive inputs, helper repurposing or uncharged rank outside that domain. Any additional recursive cleanup is charged; grant all cleanup and finite work free for this upper bound.
+
+Each main target has rank at most7n+1. Thus with n_B B invocations and n_C C invocations, n_B+n_C=n, the complete target-minus-paid moment has upper bound
+
+    M(C)<=224*(7n+1)^t -n*(224*7^t+112)-8*n_B*7^-C.
+
+For0<t<1, strict subadditivity and n^t<=n give
+
+    (7n+1)^t < (7n)^t+1 <= n*7^t+1.
+
+Consequently M(C)<224-112n-8*n_B*7^-C<=0. At C=0 the exact same optimistic mass bound is
+
+    M(0)<=224-112n-8*n_B.
+
+The best case n=2, n_B=0 only ties zero at C=0 and is strictly negative at every positive saving. A B/C pair loses at least8 rank units even if every main field is optimistically awarded rank15 and all cleanup is free. The actual cancellation word loses176 rank units. All B/B, B/C, C/C serial two-call choices are therefore screened without a search.
+
+This statement is confined to the declared serial whole-call fixed224-owner domain. It does not exclude a controller with more independent main owners, interleaved extra productive jobs, changed helper ownership, different common/transverse geometry, or genuinely shared producer work. A new controller must identify which premise changes and price that change. More digits of the #4610 fixed root or more serial calls do not reopen this screen.
+
+## Expansion decision and next question
+
+Stop this serial consumer family. The next useful constructive question must alter the ownership or incidence contract enough to exceed the target cap, or change the native paid profile to restore a local primitive discount. A feasible first test is one actual shared producer/cancellation word across a scalar contact with a source-disjoint target census. Its complete optimistic bill must be favorable before native emission, compiler reserve and outer transfer. No such word is established here. No new kappa is claimed.
diff --git a/research/complementary-caller-capacity-gate/inputs/SERIAL-README.md b/research/complementary-caller-capacity-gate/inputs/SERIAL-README.md
new file mode 100644
index 0000000000..565b93c517
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/inputs/SERIAL-README.md
@@ -0,0 +1,21 @@
+# Complementary B/C cancellation loses its complete serial bill
+
+A two-call typed consumer of PR4703 is exact on every arbitrary main input: match its56 exceptional ports, run C then B on disjoint seven-axis blocks sharing Q, and subtract twice X from Y. This gives two rank15 jobs per exceptional pair. The remaining56 ordinary pairs need an actual rank-one query each and give rank14 jobs. With all816 independent helper outputs retained once, the complete recursive rank-mass deficit is176.
+
+The optimistic screen is stronger than this witness. Every serial n>=2 whole-call consumer on the same224 main owners, shared Q and n disjoint seven-axis blocks, with main target ranks at most7n+1 and only the source helpers as additional productive fields, has nonpositive moment at C=0 and strictly negative moment throughout0<C<1, even granting free cleanup and finite work. This is a scoped stop result, not a universal controller obstruction or a new kappa.
+
+[PROOF.md](PROOF.md) specifies the chronological word, actual raw inverse transpose, complete bill, all-exponent proof and family-expansion decision. [RESULT.json](RESULT.json) contains exact profiles and checks. The refreshed native facts are inherited from PR4712's independent audit of PR4703; this package does not repeat that native/phase audit. PR4674's direct-price proof method is credited. This is a typed-interface construction and analytic screen, not a freshly emitted complete native trace or admitted multiplier.
+
+Run from any exported copy, using standard-library Python3.12 or later:
+
+```sh
+python3 -I -O -B research/complementary-consumer-feasibility/verify.py
+```
+
+The new evaluator authenticates source bytes, checks exact Laurent endpoints and gatewise inverse transposes, counts every helper once, and checks symbolic derivative sign premises for the entire declared interval. It rejects a wrong cancellation coefficient, omitted ordinary Q correction, forward word substituted for raw dual, source corruption and type-sensitive receipt corruption. No Lean, new full native replay, precision execution, compiler or outer admission is claimed. The selected record and #4610 comparison remain unchanged.
+
+## Open next questions
+
+Stop enlarging the losing serial model. Reopen only with a concrete change to target ownership, shared producer work or native paid profile; identify an actual scalar contact where a paid job disappears and verify that it does not return in restoration. Price the optimistic whole bill first. A separate physically valid witness, positive complete moment and funded kappa transfer remain distinct milestones.
+
+Credit Dugongue (#4703), Cao Yifan / intqwq (#4610/#4712), Cinna Davis (#4674 and retained controller lineage), zxv, Jacob Alan Sussman, DaysSky and every retained source notice. Prepared by Chris R / Clear1nsight with substantial OpenAI Codex assistance, as a delegated construction study. Apache-2.0. No independent human review is claimed.
diff --git a/research/complementary-caller-capacity-gate/inputs/TYPED-PROVIDER.md b/research/complementary-caller-capacity-gate/inputs/TYPED-PROVIDER.md
new file mode 100644
index 0000000000..cc190c322d
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/inputs/TYPED-PROVIDER.md
@@ -0,0 +1,164 @@
+# Typed Gaussian providers, subspace gauges and sector-multiplexed queries
+
+Dugongue, with substantial OpenAI Codex assistance. Informal mathematics based only on local source and proof-tree scans. No numerical experiment, solver, web search or Lean check was used. The constructions below have complete all-input operator proofs on their stated domains; they do not assert an unproved profitable provider or a larger numerical κ.
+
+## Sources and actual starting contract
+
+The actual local sources are `research/native-dual-suppliers/HETEROGENEOUS-CONTROLLER.md`, `FREE-ENDPOINT-GAUGES.md`, `DUAL-PROVIDER.md` and `ROUND3-IMPROVEMENT.md`; the scalar event definition in `research/kappa-rebuild/bit/complex_controller_factor.py` was read as text and was not executed. The preceding mathematical continuation supplies `boundary.md` and `consumer.md`. The linked symplectic balanced-coevaluation and mode-support notes motivate reciprocal-dual and invariant-subspace bookkeeping; no fresh formal verification is inferred from those sources.
+
+The admitted B and C local words have 112 independent main pairs, 408 independent helper fields, and respectively 56 A plus 56 B or C ports. Their exact main types are
+
+    A = D [[1,0],[Q^(-1),1]],
+    B = D [[1,0],[1,Q]],
+    C = D [[Q,0],[1,1]],
+
+where D acts on seven fresh axes and Q on the common central axis. Helpers and paid Gaussian jobs retain their individually stated profiles. Arbitrary main-pair permutations place the exceptional ports but do not identify helper inputs. Backward calls use the actual inverse-transpose endpoints with their even-power monomial corrections.
+
+Credit Cao Yifan for the retained native round-three word, DaysSky for the quotient construction, Cinna Davis and the controller lineage, Nick Petalas and Ryanson Jonathan for endpoint analysis, Dugongue for transported/repaired interfaces, zxv and Jacob Alan Sussman for compiler foundations, and all retained Gaussian/Clifford/source08 contributors. Ordinary rank factorization, projector decomposition, nullity and elementary matrix identities are classical. The new applications here are the precisely stated fusion, projection-gauge and sector-query interfaces.
+
+## T1. Complete exceptional-port extraction and two-call fusion
+
+Let S_y(t)=[[1,0],[t,1]], and suppress the common commuting D factor for a moment.
+
+**Theorem.** Exceptional B and C ports have the exact ordinary-boundary extractions
+
+    S_y(−1) B = D diag(1,Q),
+    C S_y(−1) = D diag(Q,1).
+
+For two calls on the same pair, with arbitrary commuting fresh factors D_1,D_2,
+
+    C_2 B_1 = D_2 D_1 Q S_y(2Q^(-1)),
+    S_y(−1) B_2 C_1 = D_2 D_1 Q S_y(Q^(-1)).
+
+**Proof.** In the first identity subtract the first output row of B from its second. In the second replace the first input contribution in C's second row by its difference with the second input. Both are the stated elementary shear and give the displayed diagonals on arbitrary independent inputs.
+
+For the two-call products multiply the two explicit matrices:
+
+    [[Q,0],[1,1]] [[1,0],[1,Q]] = [[Q,0],[2,Q]],
+    [[1,0],[1,Q]] [[Q,0],[1,1]] = [[Q,0],[1+Q,Q]].
+
+Factor out the common Q; in the second product the remaining shear is S_y(1+Q^(-1)), whose ordinary S_y(1) factor is removed on the left. Restore the commuting D factors. ∎
+
+The direct B extraction is inherited predecessor work, including the PR4660 extraction discussion; it is not claimed anew. The combined formulas supply explicit homogeneous-shear fusion rules. The ordinary A-A pair is D_2D_1 S_y(2Q^(-1)), and scalar diagonal conjugation normalizes its factor 2 without Gaussian work.
+
+The common Q in the exceptional two-call formula is the existing central coordinate. Repeating the construction produces powers of that same Q, whose even powers are ordinary monomials. It does not create one fresh Gaussian rank per fused block. Likewise the free extraction on 56 ports does not diagonalize the other 56 A ports. A full caller must retain these exact facts when adding targets and costs.
+
+## T2. A Gaussian gauge on an ordinary role subspace
+
+Work over a field K of characteristic not 2 and let V be the data space. A scalar role projector P is an idempotent n by n matrix over K. It acts only on the n role indices, and therefore commutes with a common Gaussian Q on V. Define
+
+    G_P(Q) = I + (Q−I)P.
+
+**Theorem.** G_P(Q) is invertible, with inverse G_P(Q^(-1)). It is ordinary-conjugate to Q on rank(P) role fields and identity on the other fields. It can be applied with rank(P) charged Gaussian jobs and explicit ordinary boundaries.
+
+**Proof.** The role space is the direct sum im(P) ⊕ ker(P): x=Px+(I−P)x, and the intersection is zero. Choose a basis in each summand and combine them into an ordinary scalar basis matrix U. In that basis P is diag(I_r,0), so G_P(Q) is diag(QI_r,I). The asserted inverse and construction follow. Alternatively, multiply the two displayed polynomial expressions in P and use P²=P. ∎
+
+This is a changed gauge representation, not a claim that Q on an arbitrary role subspace is free. The basis maps and all Gaussian requests are specified. For a fixed finite template the ordinary maps have fixed coefficient data and actual finite field-pass cost.
+
+## T3. Coordinate-free rank tariff for an ordinary boundary
+
+Let M be an invertible scalar role matrix, with an input projector P and output projector R. Put
+
+    F = G_R(Q) M G_P(Q)^(-1),
+    E = R M − M P.
+
+**Theorem.** There is an explicit all-input boundary construction for F using rank(E) charged Q or Q^(-1) jobs, ordinary linear operations and O(n) owned field buffers returned to zero. If E=0, F=M and no Gaussian correction is needed.
+
+**Proof.** Choose ordinary bases diagonalizing P on inputs and R on outputs. In those bases write M in four blocks M_00,M_01,M_10,M_11, according to the zero/one projector sectors. The physical boundary has ordinary diagonal blocks and crossed blocks M_01Q^(-1),M_10Q. The transformed E has crossed blocks −M_01 and M_10 and zero diagonal blocks; their input and output supports are disjoint, so
+
+    rank(E)=rank(M_01)+rank(M_10).
+
+Rank-factor each crossed scalar block. Form its inner scalar combinations in owned temporary fields from one unchanged input snapshot, query each combination once, and distribute through the outer rank factor. Accumulate both direct and crossed terms in an owned output bank, swap it into the main bank after the last read, and clear the old bank and temporaries. This produces exactly F on every independent input and preserves unrelated fields. All Gaussian calls are counted. If E=0 the intertwining identity RM=MP gives G_R M=M G_P, hence F=M. ∎
+
+This extends the row-bit boundary tariff to arbitrary scalar role subspaces. It does not extend it to an arbitrary matrix whose entries are noncommuting address operators.
+
+## T4. Composition and reciprocal-dual compatibility
+
+**Theorem.** For scalar M_1,M_2 and projectors P_0,P_1,P_2, define
+
+    E_1=P_1M_1−M_1P_0,
+    E_2=P_2M_2−M_2P_1.
+
+Then the whole-boundary defect obeys
+
+    P_2M_2M_1−M_2M_1P_0 = E_2M_1+M_2E_1,
+
+so its rank is at most rank(E_1)+rank(E_2). For invertible M, the reciprocal-dual defect is
+
+    R^T M^(-T) − M^(-T) P^T
+      = M^(-T) (RM−MP)^T M^(-T),
+
+and has exactly the same rank.
+
+**Proof.** Expand the first identity; the two terms containing M_2P_1M_1 cancel. Rank is subadditive and cannot increase under multiplication. For the second identity transpose RM−MP and multiply by M^(-T) on both sides. Invertible left/right factors preserve rank. The dual gauge is G_(P^T)(Q^(-T)), so T3 applies to the actual reciprocal-dual operator at that same tariff. ∎
+
+The global defect can have lower rank than the sum of local defects, including exact cancellation. This justifies compressing a completed ordinary boundary as one matrix rather than pricing a chosen ADD factorization as though its separate corrections could never share.
+
+## T5. Zero-correction endpoint gauges inside actual multiplicity spaces
+
+Assume a complete reference word satisfies
+
+    L M R_0 = T,
+
+where L and R_0 are ordinary invertible scalar boundaries and T is the actual independent-output operator. Assume each target block of T commutes with the common Q. Suppose the internal entrance and exit gauges are G_A(Q) and G_B(Q), and there is a projector P such that
+
+    R_0^(-1) A R_0 = P = L B L^(-1),
+    PT=TP.
+
+**Theorem.** The gauged interior has the exact same independent target under the same ordinary boundary maps:
+
+    L G_B(Q) M G_A(Q)^(-1) R_0 = T.
+
+No Gaussian correction at those two boundaries is needed.
+
+**Proof.** The first projector identity gives G_A(Q)^(-1)R_0=R_0G_P(Q)^(-1). The second gives L G_B(Q)=G_P(Q)L. Therefore the left side is G_P(Q) T G_P(Q)^(-1). Since P commutes with T and the actual target blocks commute with the common Q, this equals T. All input fields remain arbitrary and independent because the complete endpoint is exactly the original T. ∎
+
+For a scalar projector and T=diag(T_i), its commutator has entries P_ij(T_j−T_i). Thus a sufficient source of such projectors is an actual multiplicity block where the operators T_i are exactly identical. Equal Gaussian rank alone is not equality of these operators. Address-dependent normalizers must be included explicitly before applying the scalar statement.
+
+The theorem is a constructive admission criterion. This note has not supplied A,B satisfying it for a profitable complementary-provider schedule, so no free boundary in the current provider is asserted merely from the existence of this criterion.
+
+## T6. Sector-multiplexed Gaussian queries
+
+Suppose Q²=J and J is an ordinary involution, J²=I. Define E_+=(I+J)/2 and E_-=(I−J)/2. These are complementary ordinary projectors commuting with Q. Let A_+,A_- be scalar role matrices, with ranks r_+,r_-, and let
+
+    A=A_+E_+ + A_-E_-.
+
+**Theorem.** The vector contribution A Q x can be computed using
+
+    max(r_+,r_-)
+
+charged Gaussian jobs, explicit ordinary operations and cleared owned storage.
+
+**Proof.** Choose rank factorizations A_σ=U_σV_σ. Pad each inner dimension with zero rows/columns to r=max(r_+,r_-). Put
+
+    U=U_+E_+ +U_-E_-,
+    V=V_+E_+ +V_-E_-.
+
+Scalar role matrices commute with the sector projectors. Since E_+E_-=0 and E_++E_-=I, UV=A. Form the r temporary fields Vx, apply Q once to each, and spread by U. Because Q commutes with all entries of U,V, the result is A Q x. Each temporary packs disjoint projected components, whose dimensions sum to the original data-space dimension; it does not pack two independent full data fields into one without accounting for information. Clear the owned storage after accumulation. ∎
+
+For the actual lifted central Gaussian Q_f, Q_f² is the explicit translation that flips the selected bit in every digit column. E_± are therefore finite combinations of two ordinary monomial maps, uniformly in the lift width. The theorem has a concrete ordinary implementation and does not require a width-dependent spectral decomposition.
+
+## T7. A complete strict query-sharing example
+
+**Theorem.** Let Q be unitary with Q²=J as above. The invertible two-field map
+
+    x ↦ x + (1/4)(Q+Q^(-1))x,
+    y ↦ y + (1/4)(Q−Q^(-1))y
+
+has an implementation using one Q job, plus ordinary operations and cleared owned storage. Its inverse norm is at most 2 in Euclidean norm.
+
+**Proof.** Since Q^(-1)=QJ,
+
+    Q+Q^(-1)=2QE_+,
+    Q−Q^(-1)=2QE_-.
+
+Form z=E_+x+E_-y in an owned temporary, query Qz once, and return x+(1/2)E_+Qz and y+(1/2)E_-Qz. Orthogonality of the complementary sectors proves the two displayed outputs. The block-diagonal perturbation of identity has norm at most 1/2, so its Neumann inverse has norm at most 2. This norm argument establishes invertibility, not an unpriced inverse algorithm. The one-query forward construction is already explicit. ∎
+
+The literal four-term implementation uses four Q or Q^(-1) calls; merely factoring the two odd expressions separately uses two. Sector multiplexing reduces that explicit tariff to one while preserving the full stated all-input map. These outputs are not declared canonical independent Gaussian targets. To improve κ this pattern must occur inside a completed provider whose original independent endpoint remains unchanged.
+
+## Exact contribution and κ status
+
+T1 supplies exact fusion normal forms for the actual typed B/C operators. T2–T5 provide role-subspace gauge admission and complete boundary tariffs, including duals. T6–T7 give a concrete way to share Gaussian queries across ordinary involution sectors, with a strict full-map example.
+
+A higher κ still requires a particular complete supplier whose actual paid profile is decreased by one of these replacements while preserving its independent target operators and uniform compiler premises. No such profitable B/C instance was established in this note. The constructions are positive, fully stated tools for that task; they are not a claim that the complex-only quotient headline has already satisfied the missing controller contract.
+
diff --git a/research/complementary-caller-capacity-gate/verify.py b/research/complementary-caller-capacity-gate/verify.py
new file mode 100644
index 0000000000..1be1039fb6
--- /dev/null
+++ b/research/complementary-caller-capacity-gate/verify.py
@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+"""Check the source bill, sign-cut capacity and exact finite controls."""
+import hashlib
+import itertools
+import json
+import math
+from decimal import Decimal, localcontext
+from fractions import Fraction as F
+from pathlib import Path
+from random import Random
+
+ROOT = Path(__file__).resolve().parent
+
+
+def require(test, message):
+    if not test:
+        raise ValueError(message)
+
+
+def rank(rows, modulus=None):
+    a = [[F(x) if modulus is None else x % modulus for x in row] for row in rows]
+    pivot = 0
+    for col in range(len(a[0]) if a else 0):
+        found = next((i for i in range(pivot, len(a)) if a[i][col]), None)
+        if found is None:
+            continue
+        a[pivot], a[found] = a[found], a[pivot]
+        inverse = 1 / a[pivot][col] if modulus is None else pow(a[pivot][col], -1, modulus)
+        a[pivot] = [x * inverse for x in a[pivot]]
+        if modulus:
+            a[pivot] = [x % modulus for x in a[pivot]]
+        for i in range(pivot + 1, len(a)):
+            factor = a[i][col]
+            a[i] = [x - factor * y for x, y in zip(a[i], a[pivot])]
+            if modulus:
+                a[i] = [x % modulus for x in a[i]]
+        pivot += 1
+        if pivot == len(a):
+            break
+    return pivot
+
+
+def transpose(a):
+    return [list(row) for row in zip(*a)]
+
+
+def inverse2(a):
+    det = a[0][0] * a[1][1] - a[0][1] * a[1][0]
+    require(det != 0, "singular source pair")
+    return [[a[1][1] / det, -a[0][1] / det], [-a[1][0] / det, a[0][0] / det]]
+
+
+def pair(kind, q, d):
+    if kind == "A":
+        a = [[F(1), F(0)], [1 / q, F(1)]]
+    elif kind == "B":
+        a = [[F(1), F(0)], [F(1), q]]
+    else:
+        require(kind == "C", "unknown pair")
+        a = [[q, F(0)], [F(1), F(1)]]
+    return [[d * x for x in row] for row in a]
+
+
+def orient(a, inverse, dual):
+    if inverse:
+        a = inverse2(a)
+    return transpose(a) if dual else a
+
+
+def difference_rank(a, b, modulus=None):
+    return rank([[x - y for x, y in zip(u, v)] for u, v in zip(a, b)], modulus)
+
+
+def cut_rank(kind, central_flip, transverse_flip):
+    if not transverse_flip:
+        return int(central_flip)
+    return 1 if central_flip and kind != "A" else 2
+
+
+def check_pairs():
+    count = 0
+    for kind, q, d, inv, dual, c, e in itertools.product(
+        "ABC", [F(1), F(-1), F(2), F(-2), F(1, 2), F(2, 3)],
+        [F(1), F(-1), F(2, 3)], [False, True], [False, True], range(2), range(2)
+    ):
+        a = orient(pair(kind, q, d), inv, dual)
+        b = orient(pair(kind, (-1) ** c * q, (-1) ** e * d), inv, dual)
+        require(difference_rank(a, b) == cut_rank(kind, c, e), "pair sign rank")
+        count += 1
+    return count
+
+
+def odd_poly(r, size):
+    return [F(0)] + [F(-math.comb(r, j) * (-2) ** j, 2) for j in range(1, r + 1)] + [F(0)] * (size - r - 1)
+
+
+def capacity_poly(d, exceptional=True):
+    """Enumerate every mask, then collect its Bernoulli probability."""
+    result = [F(0)] * (d + 2)
+    for mask in range(1 << (d + 1)):
+        c = mask & 1
+        e = (mask >> 1).bit_count() & 1
+        value = 56 * (cut_rank("A", c, e) + cut_rank("B" if exceptional else "A", c, e))
+        weight = mask.bit_count()
+        for j in range(d + 2 - weight):
+            result[weight + j] += value * math.comb(d + 1 - weight, j) * (-1) ** j
+    return result
+
+
+def check_cut_polynomials():
+    for d in range(1, 11):
+        actual = capacity_poly(d)
+        expected = [F(0)] * (d + 2)
+        for r, n in [(1, 28), (d, 140), (d + 1, 84)]:
+            expected = [x + n * y for x, y in zip(expected, odd_poly(r, d + 2))]
+        require(actual == expected, "whole-call cut polynomial")
+        require(actual[1] == 112 * (2 * d + 1), "linear capacity")
+    require(capacity_poly(8, False)[1] == 1904, "eight-axis positive control")
+    return [str(x) for x in capacity_poly(7)]
+
+
+def check_graphs():
+    """Check all character pairs for mixed circuits over the field of size 5."""
+    rng = Random(5628)
+    axes, fields, circuits, steps = 5, 8, 12, 36
+    comparisons = 0
+    for _ in range(circuits):
+        roots = [rng.choice([1, 2]) for _ in range(axes)]
+        values = [[q * (-1 if mask >> j & 1 else 1) % 5 for j, q in enumerate(roots)] for mask in range(1 << axes)]
+        states = [[[int(i == j) for j in range(fields)] for i in range(fields)] for _ in values]
+        budget = [0] * len(values)
+        for _ in range(steps):
+            event = rng.randrange(4)
+            x, y = rng.sample(range(fields), 2)
+            if event == 0:
+                scalar = rng.choice([1, 2, 3, 4])
+                for a in states:
+                    a[x] = [(u + scalar * v) % 5 for u, v in zip(a[x], a[y])]
+            elif event == 1:
+                for a in states:
+                    a[x] = a[y][:]
+            elif event == 2:
+                subset = rng.randrange(1, 1 << axes)
+                for mask, a in enumerate(states):
+                    scalar = math.prod(q for j, q in enumerate(values[mask]) if subset >> j & 1) % 5
+                    a[x] = [scalar * u % 5 for u in a[x]]
+                for cut in range(len(budget)):
+                    budget[cut] += (subset & cut).bit_count() & 1
+            else:
+                kind = rng.choice("ABC")
+                central = rng.randrange(axes)
+                subset = rng.randrange(1 << axes) & ~(1 << central)
+                inv, dual = rng.choice([False, True]), rng.choice([False, True])
+                for mask, a in enumerate(states):
+                    q = F(values[mask][central])
+                    d = F(math.prod(v for j, v in enumerate(values[mask]) if subset >> j & 1))
+                    block = orient(pair(kind, q, d), inv, dual)
+                    block = [[v.numerator * pow(v.denominator, -1, 5) % 5 for v in row] for row in block]
+                    u, v = a[x], a[y]
+                    a[x] = [(block[0][0] * k + block[0][1] * l) % 5 for k, l in zip(u, v)]
+                    a[y] = [(block[1][0] * k + block[1][1] * l) % 5 for k, l in zip(u, v)]
+                for cut in range(len(budget)):
+                    budget[cut] += cut_rank(kind, cut >> central & 1, (cut & subset).bit_count() & 1)
+        for x in range(len(values)):
+            for y in range(x):
+                require(difference_rank(states[x], states[y], 5) <= budget[x ^ y], "whole-graph cut bound")
+                comparisons += 1
+    for r in [1, 2, 7, 8, 11]:
+        require(sum(mask.bit_count() & 1 for mask in range(1 << r)) == 1 << (r - 1), "query-only positive control")
+    return {"circuits": circuits, "steps_each": steps, "character_pair_checks": comparisons}
+
+
+def check_faithfulness():
+    # These integer pairs are twice the one-bit Gaussian matrix.
+    numerator = [[(1, 1), (1, -1)], [(1, -1), (1, 1)]]
+    for vector, eigenvalue in [([1, 1], (1, 0)), ([1, -1], (0, 1))]:
+        output = [tuple(sum(entry[k] * scalar for entry, scalar in zip(row, vector)) for k in range(2)) for row in numerator]
+        require(output == [tuple(2 * scalar * v for v in eigenvalue) for scalar in vector], "base Gaussian eigenvector")
+    multiplicities = {}
+    for width in range(1, 17):
+        counts = [sum(math.comb(width, k) for k in range(width + 1) if k % 4 == j) for j in range(4)]
+        require(all(counts) == (width >= 3), "faithful width")
+        multiplicities[str(width)] = counts
+    return multiplicities
+
+
+def load_profiles():
+    for item in json.loads((ROOT / "INPUTS.json").read_text()):
+        data = (ROOT / item["local"]).read_bytes()
+        require(hashlib.sha256(data).hexdigest() == item["sha256"], "source SHA256")
+        blob = hashlib.sha1(b"blob " + str(len(data)).encode() + b"\0" + data).hexdigest()
+        require(blob == item["git_blob"], "source Git blob")
+    profiles = {}
+    expected = {
+        "B": ({1: 1956, 2: 450, 3: 403, 4: 127, 5: 28, 8: 8}, {3: 2, 4: 26, 6: 7, 7: 47, 8: 326}, 1688),
+        "C": ({1: 2011, 2: 445, 3: 427, 4: 112, 5: 12, 7: 8}, {3: 26, 4: 2, 6: 6, 7: 48, 8: 326}, 1680),
+    }
+    for kind in "BC":
+        source = json.loads((ROOT / "inputs" / (kind + "-PROFILE.json")).read_text())
+        paid, helpers = ({int(r): n for r, n in source[key].items()} for key in ["paid", "helpers"])
+        net = sum(r * n for r, n in paid.items()) - sum(r * n for r, n in helpers.items())
+        require((paid, helpers, net) == expected[kind], "source profile")
+        require(sum(helpers.values()) == 408 and source["local_deficit"] == net, "source helper census")
+        profiles[kind] = (paid, helpers)
+    return profiles
+
+
+def power_intervals():
+    # Decimal proposes endpoints. Integer powers prove both strict bounds.
+    scale, numerator, denominator = 10 ** 15, 9, 2500
+    bounds = {}
+    with localcontext() as ctx:
+        ctx.prec = 60
+        for r in range(1, 9):
+            w = int(Decimal(scale) * Decimal(r) ** (-Decimal(numerator) / denominator))
+            target = scale ** denominator
+            require(w ** denominator * r ** numerator <= target < (w + 1) ** denominator * r ** numerator, "power interval")
+            bounds[r] = (F(r * w, scale), F(r * (w + 1), scale))
+    return bounds
+
+
+def check_bills(profiles):
+    results = {}
+    bounds = power_intervals()
+    for kind, (paid, helpers) in profiles.items():
+        cap = {1: 28, 7: 140, 8: 84}
+        coefficients = {r: paid.get(r, 0) - helpers.get(r, 0) - cap.get(r, 0) for r in range(1, 9)}
+        extra = 8 if kind == "B" else 0
+        low = {r: n for r, n in coefficients.items() if n > 0}
+        low[1] -= extra
+        high = {r: -n for r, n in coefficients.items() if n < 0}
+        mass = sum(r * n for r, n in low.items())
+        require(mass == sum(r * n for r, n in high.items()) == (4567 if kind == "B" else 4576), "separated mass")
+        require(max(low) == 5 and min(high) == 6, "separated support")
+        hinge_margins = []
+        for k in range(1, 17):
+            g = lambda r: F(min(r, k))
+            actual = sum(n * g(r) for r, n in coefficients.items())
+            lower = extra * g(1) + mass * (g(5) / 5 - g(6) / 6)
+            require(actual >= lower >= 0, "concave hinge tariff")
+            hinge_margins.append(str(actual))
+        lower = sum(n * bounds[r][0 if n >= 0 else 1] for r, n in coefficients.items())
+        upper = sum(n * bounds[r][1 if n >= 0 else 0] for r, n in coefficients.items())
+        require(lower > (F(3158147, 100000) if kind == "B" else F(2398603, 100000)), "strict exact moment gap")
+        results[kind] = {"bill_minus_capacity": coefficients, "linear_gap": extra, "separated_mass": mass,
+                         "hinge_margins_1_to_16": hinge_margins,
+                         "gap_at_C_9_over_2500": {"lower": str(lower), "upper": str(upper)}}
+    return results
+
+
+def controls(profiles):
+    failures = 0
+    paid, helpers = profiles["B"]
+    changed = {"B": (dict(paid), dict(helpers))}
+    changed["B"][0][1] -= 8
+    tests = [
+        (lambda: require(capacity_poly(7)[1] == 1904, "wrong transverse dimension")),
+        (lambda: require(difference_rank(pair("B", F(1), F(1)), pair("B", F(1), F(-1))) == cut_rank("B", 1, 1), "omitted central flip")),
+        (lambda: check_bills(changed)),
+        (lambda: require(all(sum(math.comb(2, k) for k in range(3) if k % 4 == j) for j in range(4)), "unfaithful width")),
+    ]
+    for test in tests:
+        try:
+            test()
+        except ValueError:
+            failures += 1
+    require(failures == len(tests), "corruption controls")
+    return failures
+
+
+def main():
+    profiles = load_profiles()
+    result = {
+        "status": "PASS_COMPLEMENTARY_CALLER_CAPACITY_GATE",
+        "pair_rank_cases": check_pairs(), "capacity_polynomial_in_p": check_cut_polynomials(),
+        "graph_checks": check_graphs(), "Gaussian_eigenvalue_multiplicities": check_faithfulness(),
+        "bills": check_bills(profiles), "rejected_controls": controls(profiles),
+        "main_capacity": {"1": 28, "7": 140, "8": 84},
+        "scope": "Coordinate Gaussian callers; ordinary even-power algebra; separate fresh helpers; every f>=3 and 0<C<1. No new kappa.",
+    }
+    encoded = json.dumps(result, indent=2, sort_keys=True) + "\n"
+    expected = ROOT / "RESULT.json"
+    require(expected.read_text() == encoded, "frozen result")
+    print(result["status"])
+    print("RESULT_SHA256", hashlib.sha256(encoded.encode()).hexdigest())
+
+
+if __name__ == "__main__":
+    main()