Derive first-pivot Schur state weights from sector incidence

research/schur-split-incidence/PROOF.md

@@ -0,0 +1,69 @@
+# Scalar sector incidence and the seven first-pivot weights
+
+Work over F2. Fix commuting idempotents P,Q on V with ordered joint sectors V00,V10,V01,V11 of dimensions r00,r10,r01,r11. A scalar split is a vector a and covector b with ba=1; the common first guard is bPa=bQa=1. Scalars, vectors and covectors are labeled; no quotient or division by any sector centralizer is taken in the count.
+
+## General scalar incidence formula
+
+Write a=(a_j), b=(b_j), and h=b11 a11. The three guard equations are equivalent to b00 a00=b10 a10=b01 a01=1+h, b11 a11=h. For a sector of dimension r, the simultaneous GL(r,2) action (a,b) -> (ga,bg^-1) has exactly these nonempty types:
+
+| Type | Incidence | Weight w_r |
+|---|---|---:|
+| Z | a=0,b=0 | 1 |
+| A | a nonzero,b=0 | 2^r-1 |
+| B | a=0,b nonzero | 2^r-1 |
+| N | a,b nonzero, ba=0 | (2^r-1)(2^(r-1)-1) |
+| C | ba=1 | (2^r-1)2^(r-1) |
+
+For r=0 only Z exists; for r=1 N does not exist. For positive r, count a first, then the covectors in its annihilator or affine complement to obtain these weights. Transitivity follows by extending a nonzero a to a basis, and, when b is nonzero, choosing the remaining basis in ker b (type C) or one vector outside ker b (type N). Types A and B are the single nonzero-vector and nonzero-covector orbits. Thus these are actual incidence orbits, not just ranks with a guessed multiplicity.
+
+Let T_0(r)={Z,A,B,N} with zero weights omitted and T_1(r)={C}, also omitting zero weights. For every compatible tuple tau in T_(1+h)(r00) x T_(1+h)(r10) x T_(1+h)(r01) x T_h(r11), choose one canonical sector realization, assemble a,b, and form the ordered residual pair R(tau) on ker b. Then, for any simultaneous-conjugacy class O of residual pairs,
+
+    B(O) = sum over h=0,1 and compatible tau with R(tau) in O of product_j w_(r_j)(tau_j).
+
+This is an all-dimension binary scalar-pivot formula. It does not claim an efficient general residual-classification algorithm or an arbitrary-field theorem. The proof is a disjoint partition into sector orbits: each tuple has the displayed product size, and the product sector group commutes with P,Q and sends the residual pair by simultaneous conjugacy. The guard equations themselves imply ba=1, so there is no extra compatibility factor or completion gauge. Different tuples may reach the same residual class; their weights must be added, not quotiented.
+
+For x in H=ker b the coordinate-free residual maps are
+
+    Sx = Px + Pa (bPx),    Tx = Qx + Qa (bQx).
+
+Both images lie in H. These are the usual Schur complements in any basis (a,N) with N a basis of H. They have image im P intersect H and kernel H intersect (ker P + <a>), and the analogous statements hold for Q. The image statement follows since bPa=1 and the displayed formula is the projection within im P onto its intersection with H. The kernel follows from Px in <Pa> and injectivity of P on <a>. This gives the promised image/kernel interpretation of the incidence types.
+
+## Profile (1,1,1,2): start with weights 1 and 3
+
+Use axes e0,e1,e2,e3,e4 with P=diag(0,1,0,1,1), Q=diag(0,0,1,1,1). For h=0, each one-dimensional sector is forced to C: a_i=b_i=1 for i=0,1,2. Write a=(1,1,1,u), b=(1,1,1,v), vu=0 on the two-dimensional 11 sector. Its four incidence types have weights 1,3,3,3.
+
+The residual images are {(0,vz,0,z)} and {(0,0,vz,z)}. They coincide exactly when v=0; otherwise their intersection has dimension one. The kernels are spanned respectively by (1,1,0,u),(0,1,1,u) and by (1,0,1,u),(0,1,1,u). They coincide exactly when u=0; otherwise their intersection has dimension one. Consequently Z gives S=T (state 1) with weight 1. A gives equal images and distinct kernels (state 2) with weight 3. B gives distinct images and equal kernels (state 5) with weight 3. N gives both intersections of dimension one (state 6) with weight 3. Sector transitivity proves each is a single residual class. Their intersection dimensions distinguish them, and direct substitution of one canonical seed per type identifies the displayed representatives in the calibration table. For N, the commutator has rank two; hence it cannot merge with any h=1 case below.
+
+For an explicit coordinate check, the deterministic increasing-vector basis of H used by verify.py gives the following seeds and invertible intertwiners K (all matrices encoded by integer rows). Each row satisfies S_seed K=K S_rep and T_seed K=K T_rep; invertibility is independently checked. These four witnesses make the state identification concrete without an orbit search.
+
+| Type | a,b | S_seed | T_seed | K |
+|---|---|---|---|---|
+| Z | 7,7 | (0,0,4,8) | (0,0,4,8) | (2,1,8,4) |
+| A | 15,7 | (0,0,5,8) | (0,0,6,8) | (2,3,10,4) |
+| B | 7,15 | (4,0,4,8) | (0,4,4,8) | (7,2,4,8) |
+| N | 15,23 | (8,0,13,8) | (0,8,14,8) | (6,3,10,4) |
+
+In particular, the first two weights are 1 and 3 before any centralizer enters. The credited stabilizers 36 and 4 give complete-header multiplicities per coordinate pair of 36 and 12, respectively. Orbit size alone does not encode how many input splits reach that orbit.
+
+## The h=1 branch
+
+The 11 sector is C, with weight (4-1)*2=6. Choose a11=e3, b11=e3*. Each of the three one-dimensional sectors is Z,A or B, each of weight one. This gives 27 incidence tuples, independently of the six realizations in sector 11. On H identify coordinates with (x0,x1,x2,x4) by x3=b0 x0+b1 x1+b2 x2. Since a_i b_i=0, the residual maps are the direct sum of the common identity on <e4> and the following rank-one projections on F2^3:
+
+    S'=e1 (a1 b0, 1, a1 b2),
+    T'=e2 (a2 b0, a2 b1, 1).
+
+Their images are distinct. S'T' is nonzero exactly when sector 10 is A and sector 01 is B; T'S' is nonzero exactly in the opposite case. These cases are mutually exclusive. Each allows three choices for sector 00, hence has three tuples. The remaining 21 tuples have both products zero.
+
+This is a sufficient three-way classification, not just a rank filter. When both products vanish, the two idempotents commute and simultaneously diagonalize with sector dimensions (1,1,1) on F2^3. When S'T' is nonzero and T'S'=0, write S'=u s and T'=v t. Then s(u)=t(v)=s(v)=1 and t(u)=0. The covectors s,t are independent, so a nonzero vector w spans their common kernel and is outside <u,v>. The basis (w,v,u) gives the same fixed ordered pair in every such case. Interchanging the roles proves the reverse-product case. Adding the common e4 line gives states 3,4,7 respectively. Their (rank ST,rank TS) are (1,1),(2,1),(1,2); their commutator ranks are 0,1,1. They cannot merge with the four h=0 classes: state 1 has equal maps; states 2 and 5 have equal images or equal kernels; state 6 has rank-two commutator.
+
+Therefore, in published order, the split weights are
+
+    (1, 3, 21*6, 3*6, 3, 3, 3*6) = (1,3,126,18,3,3,18).
+
+The h=0 and h=1 contributions are 10 and 162, disjoint because h is an actual scalar attached to the split. They exhaust all common-guard splits by the sector equations. The remaining 496-172 splits fail a common first guard; there is no enumeration of those splits in this proof.
+
+## Completion and credited continuation
+
+Each split (a,b) extends to exactly |GL4(F2)|=20160 headers by choosing an ordered basis of H. All 31 nonzero vectors a have 16 covectors b with ba=1, so the total split count is 496 and the complete-header denominator is 9999360. Completion conjugates the residual pair; an orbit with stabilizer z is hit z times per split. Thus first-guard headers in a state number B(O)*20160, while each residual coordinate pair occurs B(O)*z times. These are distinct quantities.
+
+Sagar Thakrar's retained exact README at commit 93bebe5e1ad3dd17a97ae79f27e1a35edd3630aa proves the complementary-plane continuation rule and reports stabilizers z=(36,4,1,1,4,4,1), depth-two orbit counts f=(100,468,366,816,468,270,816). These are credited premises, not a new continuation/centralizer calculation here. Combining the newly derived inputs with that rule gives sum B*z*f=93564. The per-state contributions are (3600,5616,46116,14688,5616,3240,14688). This recovers the published total without repeating its input census. The numerical continuation table is source-bound but not independently replayed by this package.

research/schur-split-incidence/README.md

@@ -0,0 +1,44 @@
+# First-pivot Schur state weights from sector incidence
+
+**Scoped binary counting proof; no new kappa.** Prepared by JoyboyBrian with substantial OpenAI Codex (gpt-6-astra) assistance. Apache-2.0.
+
+For the commuting-idempotent sector profile (1,1,1,2), [PROOF.md](PROOF.md) derives the seven first-pivot split multiplicities **(1,3,126,18,3,3,18)** from vector/covector incidence. It fills the input-count gap explicitly left by Sagar Thakrar's complementary-plane continuation rule. Neither all 496 splits nor GL4 is enumerated. The existing seven-state census, downstream transitions and centralizers remain credited predecessor results.
+
+The binary scalar-pivot formula applies to arbitrary nonnegative sector dimensions: partition each sector's vector/covector pair into Z/A/B/N/C incidence types, multiply their exact sizes, and add compatible tuples reaching the same residual class. General residual classification is not solved. For this fixed profile, h=0 yields four classes with weights 1,3,3,3; h=1 gives 27 incidence tuples of weight six, grouped as 21,3,3. The proof supplies sufficient image/kernel and rank-one normal forms, rather than assuming that rank fingerprints classify arbitrary projector pairs.
+
+| Published state | Split weight | Header multiplicity per coordinate pair | Credited full-guard contribution |
+|---:|---:|---:|---:|
+| 1 | 1 | 36 | 3600 |
+| 2 | 3 | 12 | 5616 |
+| 3 | 126 | 126 | 46116 |
+| 4 | 18 | 18 | 14688 |
+| 5 | 3 | 12 | 5616 |
+| 6 | 3 | 12 | 3240 |
+| 7 | 18 | 18 | 14688 |
+
+Each split has 20160 full-header completions. The middle column additionally uses the credited centralizers; the final column composes the new input weights with the credited continuation table and sums to 93564. The numerical continuation counts are a retained premise, not an independently rerun result. No physical header selection, odd-field normalizer, supplier admission or selected-frontier change follows.
+
+## Verification and source boundaries
+
+```sh
+python3.12 -B scripts/research_package.py --package research/schur-split-incidence
+python3.12 -B scripts/check_research_commit.py --package research/schur-split-incidence --check-source-history
+```
+
+Standalone Git-free replay is `python3.12 -I -B verify.py` or `python3.12 -I -O -B verify.py` from this package. Only the Python standard library is used. All checks use explicit failures under optimization. The verifier checks 31 canonical sector tuples against direct Schur maps and actual invertible intertwiners to the seven supplied representatives. Intertwiners are found in the linear solution space of SK=KS0 and TK=KT0, rather than by enumerating GL4. Thirty sector profiles in dimensions two and three compare weighted incidence with direct small split counts, including empty sectors. Five controls reject omitted completion fibres, orbit sizes substituted for incidence, unweighted sector types, omission of the six C realizations, and confusing all splits with admitted splits. RESULT.json fixes the output.
+
+Tests protect the sector-incidence partition and state mapping. The credible regressions are a missing multiplicity, reversed ordered state, or invalid zero-sector handling. Earlier census/continuation packages do not test this new derivation. The checks call the verifier's mathematical boundary directly; no production exports or flags are introduced.
+
+[RETAINED.json](RETAINED.json) authenticates the exact original README bytes from thakrarsagar/integer-mult-bounds commit `93bebe5e1ad3dd17a97ae79f27e1a35edd3630aa`, path `research/cbc3b1759ddd5fe5c461c509fecfae56/README.md`, and identifies its Apache-2.0 license and author. The retained calibration JSON is explicitly a small transcription, not an original file. It is compared only after deriving the input weights; it is never a filter defining the incidence classes. Base-main predecessor README/RESULT bytes are provenance-pinned in SOURCES.json. The remote successor is carried as actual package bytes, so standalone replay does not need a shared Git object or network. Its continuation proof/table is credited rather than reimplemented.
+
+Local checks completed on macOS with Python 3.12; both registered modes pass in under one second each. No heavy historical suite, GL4 census, Lean, Docker, production build or selected cold replay was run. Independent human/proof-kernel acceptance and general residual classification remain open.
+
+## Scope and attribution
+
+Canonical base `4c0a359d88f22f05189d51f48387750b801a45d4`, priority revision 7. This changes the formal-interface card to the precise algebraic handoff already claimed at [Discussion4653](https://github.com/CrocSwap/integer-mult-bounds/discussions/4653#discussioncomment-19140794). The root coordinator checked the active overlap/claims; coverage and exclusions are retained in TASK.json. The family decision is narrow: finish this missing input law without another profile census or construction round.
+
+Credit: Mihir Srivastava #4689 (`3a72fbad148294aa9ca7f900a48dbb10e64232be`) supplies the seven-state table and calibration; ssafwann #4678 (`af9cf805c501e4e9e947c98c0b97b2281b6b6e97`) and #4671 supply sector equations, factor counts and completion arguments; Sagar Thakrar supplies the complementary-plane successor and explicit first-pivot handoff; Nick Petalas #4915/#4597 and earlier scalar/header papers supply centralizer and Schur lineage. MatShep #4762, codyw912 #4735, Ryanson Jonathan, lee-phys, Cinna Davis and the normalizer lineage retain their predecessor credit. The retained successor preserves its own full credit and AI-assistance disclosure. The new claim is the input-incidence derivation, not the published seven-state count, downstream law, or centralizer calculation.
+
+## Open next questions
+
+Can the scalar sector-incidence formula be paired with a sufficient residual invariant for larger sector profiles? Start with a symbolic image/kernel decomposition for one changed profile; stop if its state classifier is unspecified rather than running another census. Higher-rank pivots require relative factorization data beyond the five scalar incidence types. Production use separately requires an actual header cover and complete selection, restoration, storage, stock and dispatch costs. These obligations are unknown, not zero.

research/schur-split-incidence/RESULT.json

@@ -0,0 +1,34 @@
+{
+  "split_weights": [
+    1,
+    3,
+    126,
+    18,
+    3,
+    3,
+    18
+  ],
+  "canonical_tuples": 31,
+  "tiny_profiles": 30,
+  "semantic_rejections": 5,
+  "complete_header_fibre": 20160,
+  "header_per_coordinate_pair": [
+    36,
+    12,
+    126,
+    18,
+    12,
+    12,
+    18
+  ],
+  "credited_full_guard_contributions": [
+    3600,
+    5616,
+    46116,
+    14688,
+    5616,
+    3240,
+    14688
+  ],
+  "credited_full_guard_total": 93564
+}

research/schur-split-incidence/RETAINED.json

@@ -0,0 +1,20 @@
+[
+  {
+    "retained_path": "retained/continuation-README.md",
+    "original_path": "research/cbc3b1759ddd5fe5c461c509fecfae56/README.md",
+    "original_head": "93bebe5e1ad3dd17a97ae79f27e1a35edd3630aa",
+    "author": "Sagar Thakrar; substantial OpenAI Codex assistance",
+    "license": "Apache-2.0",
+    "sha256": "3b8acd0ba3e174c24b56a46a10c29ac1e9d6942650592c9033afc0ea240f9225",
+    "retention": "exact source bytes"
+  },
+  {
+    "retained_path": "retained/calibration.json",
+    "original_path": "research/schur-residual-orbits/RESULT.json",
+    "original_head": "3a72fbad148294aa9ca7f900a48dbb10e64232be",
+    "author": "Mihir Srivastava; substantial OpenAI Codex assistance",
+    "license": "Apache-2.0",
+    "sha256": "f31f115733e4c4ddc7e7eec72b5b32e19274a9b34b583a4c543b0b2b88e6c8aa",
+    "retention": "selected numerical fields transcribed for independent calibration; not exact source bytes"
+  }
+]

research/schur-split-incidence/SOURCES.json

@@ -0,0 +1,36 @@
+{
+  "schema_version": 1,
+  "base_commit": "4c0a359d88f22f05189d51f48387750b801a45d4",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "c35482cd9035843b15a634cc8276a7e1e40e8395",
+      "sha256": "6fe0a099b89aa2aed796a13c3a21dafc63f3388ebf397464e44e0451893b9375"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "f126dd2e2dad2b669e75d1d0d0bd05c600725602",
+      "sha256": "f7a48bfa2659b88378282a8eee7d9fe52cdf505594124c4d1686b58510fffd72"
+    },
+    {
+      "path": "research/schur-header-count/README.md",
+      "usage": "provenance",
+      "git_blob": "5e644cf316312c0fdd489c8d33911583f1b88af2",
+      "sha256": "472295f32ebf3fcdc8daa4137af63db70d9943de7cbb97e47ed272823b2a227e"
+    },
+    {
+      "path": "research/schur-residual-orbits/README.md",
+      "usage": "provenance",
+      "git_blob": "a2361477d9373969ccb7ab0f4f3c4b9919c051ba",
+      "sha256": "15e2f1a7d4edcc8f71e75ead949928c2ac883a3fb8268bb5827f290de4d28d76"
+    },
+    {
+      "path": "research/schur-residual-orbits/RESULT.json",
+      "usage": "provenance",
+      "git_blob": "20146a875ccf38facac05d771d056d4c336e142b",
+      "sha256": "9c4a887900c8ca5202aebfb75bd30cf60d0075dcde7333843c7df6e6ebef9a1f"
+    }
+  ]
+}