Exclude the 31-leaf target with a chronological connector rank bound

research/coupled31-chronology/COMMUTING.md

@@ -0,0 +1,90 @@
+# Commuting full calls need at least half as many thin maps as leaves
+
+Retain the paired-star contract in PROOF.md. Suppose all full-call projectors
+commute, including projectors from different stages. Thin maps can still be
+arbitrary and can have any rank.
+
+**Theorem.** A successful word needs at least `ceil(g/2)` thin maps.
+This count is sharp when their ranks are unrestricted.
+
+## Proof
+
+For g>=2, each full projector commutes with every other full-stage support E_k.
+For a different star edge k, this forces its off-diagonal block B to zero.
+The remaining A projectors commute. Commuting idempotents have a common
+eigenbasis over the base field, since each minimal polynomial divides
+`x(x-1)`. Use this same basis on the core and all leaves.
+
+Fix one coordinate in that basis. Exactly one half of each stage acts on
+this coordinate. Read these g active stage events in chronological order.
+The pure stage prefix is diagonal. Its entries are monomials in the
+independent D_j. The e coefficient of the whole word, after removal of
+its pure stage product, is exactly
+
+```text
+sum_i prefix_i^(-1) R_i prefix_i.
+```
+
+This calculation is in the Laurent polynomial ring. The original polynomial
+ring embeds in it, so an exact equality here proves the original endpoint.
+
+For the entry from leaf j to the core, the full query in stage j contributes
+one monomial. Its exponent records which other stage events precede j.
+The D_j exponent cancels because both endpoints receive D_j together.
+A thin map can cancel this term only if it occurs immediately before or
+after event j in the induced active-event sequence. Every other gap has a
+different monomial in the independent stage variables. There is no other
+full query in this matrix entry.
+
+One thin map lies in one gap of this sequence. It can therefore cancel the
+required entry for at most the two neighboring events. The target has zero
+in every such off-diagonal entry. All g events need a cancellation, which
+gives `2m>=g`. Cross-coordinate entries in thin maps cannot alter this
+argument: diagonal conjugation preserves each matrix entry separately.
+
+For g=1, no thin map would leave the full query sum T_1, which is not I.
+Thus at least one thin map is required in that case too.
+
+This excludes five thin maps at both 13 and 31 leaves, regardless of their
+ranks or the number of coupled ports. Those targets need noncommuting full
+projectors, a changed stage frame, or a different endpoint contract.
+
+## A complete construction at the count bound
+
+Choose the same coordinate half projection A in every stage and B=0.
+Run both halves of stage 1, then both of stage 2, and continue in order.
+After each odd-numbered stage j, insert one thin map. If j<g, it contains
+both directions between the core and leaves j and j+1, with identity blocks
+and no other entries. If j=g, use only leaf j. For even g, also put identity
+on the core diagonal of the first thin map.
+
+The map between stages j and j+1 cancels both full-query off-diagonal terms
+in the normalized Laurent sum. The last singleton cancels its own terms.
+The diagonal full-query sum is I when g is odd. When g is even, it lacks
+the core identity, which the first thin map supplies. The resulting sum is
+exactly I. The pure stage product is the required diagonal product. Thus
+the complete endpoint is correct for every g>=1 and every q>=1.
+
+Every thin map has rank 2d=4q, including the even-g correction and singleton.
+There are `ceil(g/2)` maps. They are not asserted to have square zero.
+An arbitrary rank decomposition gives the stated rank-one query tariff;
+native transport and frame costs are separate. The complete recursive price
+loses for g>=3. This is a sharp map-count construction, not a profitable caller.
+
+## Exact replay
+
+WORD31.json contains all matrices and their order for g=31,q=2. The checker
+first checks projectors, ranks, resolutions and each prescribed query.
+It then collects every Laurent monomial in every matrix entry. Exactly the
+128 diagonal identity terms remain. There is no truncation of stage degree.
+
+A separate literal interpreter evaluates the dual-number word on a Cartesian
+grid of three distinct F4 values per stage. Each stage occurs twice, so its
+degree is at most two. Polynomial interpolation makes this a complete check
+for the small fixtures, including the retained noncommuting eight-field word.
+The control `D^2+D` shows why the two binary values alone would be insufficient.
+Deleted and moved thin queries fail the long endpoint check.
+
+The count argument and sharp construction are part of the present research.
+Credit the retained star contract and source lineage in PROOF.md. Ali Romman
+with substantial OpenAI Codex assistance; no subagents. Apache-2.0.

research/coupled31-chronology/COST.md

@@ -0,0 +1,123 @@
+# Complete tariff consequences and unpriced obligations
+
+The source is PR5599 at `09dd0965711ca7eeb169057a420abab1c9052137`.
+Its exact local paid and independent-helper histograms are retained in
+`sources/p104-result.json`. Their net rank mass is 1720 per full call.
+This section includes every term of the declared recursive star tariff.
+It does not assign zero cost to a missing physical implementation.
+
+## 1. The entire recursive profile
+
+Let g be the number of leaves, q the number of coupled ports per binary
+block, and R the total thin matrix rank per block. Scale to 104 native ports.
+The signed target-minus-paid moment at exponent t is
+
+```text
+M(g,R/q;t) = 208 H_(8g+1) + 208g H_9
+            + 2g helpers - 2g paid - 104(R/q) H_1,
+H_r = r^t.
+```
+
+The first term is the core target. The second term is every leaf target.
+Every full call retains the complete paid profile and independent helpers.
+Every thin rank unit costs one rank-one query. The proof permits a favorable
+fractional block count when it derives a lower bound; actual constructions
+must use integer blocks or provide the missing mixed block contract.
+
+The linear margin is `96g+208-104(R/q)`. This formula is a complete recursive
+tariff for this declared algebraic comparison. Native frame realization and
+nonrecursive obligations remain distinct.
+
+## 2. A uniform ceiling for one or two coupled ports
+
+The chronological theorem gives
+
+```text
+R/q >= 4 + (2/q) ceil((g-2)/3).
+```
+
+For q<=2, this is at least `4+(g-2)/3`. Define
+
+```text
+C(t) = 208*9^t + 2 sum helpers_r*r^t - 2 sum paid_r*r^t.
+```
+
+For all g>=3, the moment therefore satisfies
+
+```text
+M <= 208(8g+1)^t + g(C(t)-104/3) - 1040/3.                     (1)
+```
+
+Take saving `alpha=8/3125=.00256`, so `t=3117/3125`. The function
+`y -> y^t` is concave on positive y. Its tangent at `8*32+1=257` bounds
+the right side of (1) by `s*g+c`, where
+
+```text
+s = 1664*t*257^(t-1) + C(t) - 104/3,
+c = 208*257^(t-1)*(1+256*alpha) - 1040/3.
+```
+
+Exact integer-power intervals give `s<0` and `c<-7`. The interval endpoints
+are in RESULT.json. Thus **every integer leaf count g>=3 loses at .00256**
+for q<=2, even in the favorable fractional relaxation.
+
+After equal ranks are cancelled, positive terms have rank at least eight
+and negative terms have rank at most seven. If the margin is negative at
+t0, its margin at any `0<=t<=t0` is at most `8^(t-t0)` times that negative
+margin. Consequently every saving from .00256 through 1 is rejected.
+This is a family-wide tariff ceiling, not a root search on a finite range.
+In particular this family cannot reach selected kappa .00310045.
+
+The two smaller positive leaf counts also lose. At g=1 or g=2, the static
+rank K=2d already requires R/q>=4. Their linear margins are -112 and -16.
+Separated ranks then reject every concave moment. Thus the stated ceiling
+covers every positive leaf count, not only the long callers.
+
+For the requested g=31,q=2 case, R>=28. Its 104-port bill therefore needs
+at least 1456 rank-one thin queries, instead of the proposed 520. For the
+old g=127,q=1 case, R>=88 instead of ten. Both complete optimistic profiles
+are recorded. Additional nonnegative charges cannot repair their loss.
+
+## 3. A complete binary endpoint as a control
+
+WORD31.json gives a real 31-leaf binary word with 62 full calls and 16 thin
+maps of rank eight on each two-port block. Its full normalized endpoint is
+proved in COMMUTING.md and checked without expansion into 2^31 terms.
+At 104 ports it uses 52 blocks and 6656 rank-one thin queries. All source
+full-call helpers and paid terms remain in its profile. Its linear margin
+is -3472, and the same separated-rank argument rejects every concave moment.
+It is a positive operator control with a negative complete recursive price.
+
+This is not the requested five-rank-two word. The theorem proves that such
+a word cannot exist under the paired-star contract.
+
+## 4. Larger coupling and the remaining obligations
+
+At 31 leaves, five rank-q maps require q>=20. Using q=26 divides the 104
+ports. Its optimistic moment is positive at saving .0035. The smaller
+13-leaf, q=8, five-rank-eight profile is positive at .0034. Exact intervals
+are saved. Neither profile has a supplied word. COMMUTING.md proves that
+neither can use commuting full-call projectors. A larger scalar field with
+all maps linear over that field is not a substitute for this missing word.
+
+| Obligation | Status in this package |
+| --- | --- |
+| Chronology of the requested 31-leaf/five-rank-two word | Excluded by PROOF.md |
+| Every coefficient of the 31-leaf control word | Proved and exactly replayed |
+| Source full-call paid and helper profiles | Pinned complete source input |
+| Thin query tariff | Charged by actual rank, or by a proved lower bound |
+| Native realization of new coupled frames | Unknown; no zero-cost assumption |
+| Owned and borrowed state, input reads and dirty compensation | Unknown for new frames |
+| COPY, CLEAR, retained values and complete restoration | Unknown for new frames |
+| Physical routes, tapes, precision, stock and uniform compiler | Unknown for new frames |
+| Outer transfer and a new complete kappa | Not supplied |
+
+PR5701 gives separate characteristic-zero trace qualifications for direct
+square-zero lifts of the static PR5681 construction. This package does not
+repeat or bypass them. A positive binary word must still receive its actual
+native contract and a complete physical bill before it can improve kappa.
+
+Credit the PR5599 tariff, PR5673 profile, and all retained P104/helper/native/
+compiler contributors. The new cost conclusion uses the chronological bound
+in this package. Ali Romman with substantial OpenAI Codex assistance.
+Apache-2.0.

research/coupled31-chronology/DISCOVERY.md

@@ -0,0 +1,64 @@
+# Search record and limits
+
+The assigned target was 31 leaves, two coupled ports, and five rank-two thin
+connectors. Main and active claims were refreshed first. PR5681 had supplied
+static maps for this target; no new static construction was needed. PR5701
+had separately qualified two characteristic-zero lift contracts.
+
+The first new calculation used the thin row-space basis in the mixed
+chronology relation. Left multiplication by one stage projection isolates
+the prefix of every other stage. Untouched stages force the affine row map
+to lose a dimension whenever a prefix determinant becomes too large.
+Iteration gives the proof in PROOF.md. Thus the requested endpoint is
+impossible, before any larger synthesis or native compilation.
+
+The complete source tariff with the new rank lower bound then rejects every
+one- or two-port paired-star caller at saving .00256. The proof uses an exact
+tangent, so it does not leave an unsearched large-leaf range.
+
+Two bounded seed searches tested larger coupling as a possible next route.
+Both used g=3,d=4, arbitrary compatible rank-two full query halves, and all
+eleven call positions as solver variables. The fixed five rank-two thin maps
+use the PR5681 F/G/E formula. Their leaf signatures are `(0,1,1)` in one run
+and `(1,2,3)` in the other. The sum and square-zero identities hold in both.
+Each run checks the full first mixed coefficient and the pairwise pure stage
+coefficient. Any SAT model is then passed to the retained complete polynomial
+replay, which keeps all stage exponents. Both runs reached their 60-second
+solver limit without a model. They are **unknown**, not obstructions.
+
+```sh
+python3.12 -m venv /tmp/coupled31-discovery
+/tmp/coupled31-discovery/bin/python -m pip install z3-solver==5.3.2.0
+/tmp/coupled31-discovery/bin/python -B research/coupled31-chronology/discovery/coupled_seed.py --pattern pair --timeout 60000 --models 8 --output /tmp/coupled31-pair.json
+/tmp/coupled31-discovery/bin/python -B research/coupled31-chronology/discovery/coupled_seed.py --pattern triangle --timeout 60000 --models 8 --output /tmp/coupled31-triangle.json
+```
+
+The actual environment was Python 3.12.13 on macOS arm64, with Z3 5.3.2.
+The two saved JSON files retain the precise version, pattern, timeout and
+unknown reason. Timings and solver progress can vary. The default verifier
+does not import the solver or treat a timeout as mathematical evidence.
+
+A smaller projected-chronology census shows why a dimension bound alone is
+not a sufficient endpoint test. Of 19,440 ordered three-stage rank-one flags
+over F2, 9864 admit a one-extra-row representation of the extracted S_jk
+differences. They are necessary-condition candidates only. The census covers
+six flags per stage and all 90 words with two occurrences of each label.
+It does not specify thin matrices, their call order, or a full endpoint.
+
+```sh
+python3.12 -B research/coupled31-chronology/discovery/row_signature_census.py
+```
+
+Its saved JSON contains four examples. Compare the counts and examples;
+elapsed seconds are not a correctness criterion. No claim of a new caller
+comes from this census.
+
+The next investigation of a cheap five-map target must use larger port
+coupling and noncommuting full projectors. The commuting-projector count
+proof in COMMUTING.md excludes five maps at both 13 and 31 leaves. It also
+supplies a complete word at the larger map-count bound. WORD31.json and its
+negative complete recursive price are retained as a control.
+
+No changed native supplier, practical runtime gain, or kappa improvement
+was found. All failed or incomplete searches keep their stated scopes.
+Ali Romman with substantial OpenAI Codex assistance; Apache-2.0.