Exclude 1,981 more G20 helper-split contexts (no new κ)

research/g20-free-carrier-split-obstruction/PROOF.md

@@ -0,0 +1,139 @@
+# A free choice of carrier does not expose another G20 split
+
+## Contract and new claim
+
+Fix Ali Romman's PR5708 word, `WORD.json.gz`, at
+`829d01fc031f7323ffcfa423fdfd1f24dcbe3190`. Its scalar normalized
+coordinates, native frame induction and existing helper endpoints are cited
+premises. This proof does not establish those source results again.
+
+A helper group G consists of all retained public helper roles with the same
+entrance subspace U and exit subspace V. Fix an event cut and one entire bank
+S of fields having the same physical frame F, where V is strictly contained
+in F and F is strictly contained in U. Include every field in S, including
+main fields and existing owned fields. No member of G need occur in S.
+Binary changes of basis at the input, cut and output may use every eligible
+coordinate. A split must preserve independence and restore every output
+outside G. Adding paid frame changes, changing the scalar word, mixing
+boundary groups with different endpoint frames and using address-dependent
+coefficients are outside this contract.
+
+The new finite claim is that all 1,981 distinct eligible contexts with
+`S intersect G` empty have zero boundary pairing. There are 46 such contexts
+with two nonzero kernel spaces; 45 even have nonzero internal pairing.
+Thus the failure is not merely the absence of a scalar pivot or the absence
+of available kernel vectors. No free choice of an existing physical carrier
+repairs the boundary pairing on this word.
+
+The executable also obtains zero boundary pairing in all 7,870 contexts,
+including the helper-pivot domain reported in PR5708. Those old cases are
+context for the expansion, not a separate contribution or supplier audit.
+
+## The necessary boundary pairing
+
+Use column states. Let A be the complete normalized prefix map from all
+entrance fields to the cut, and let B be the suffix map from that cut to all
+exit fields. The maps include the scalar effects of owned erasures. Queries
+change physical frames and leave normalized coefficients unchanged under
+the cited native contract.
+
+For a row a supported on S, eligibility means c = a A has no coordinates
+outside G. For a column b supported on S, eligibility means d = B b has no
+coordinates outside G. The full spaces of such a and b are kernels of the
+restrictions of A and B to the complementary boundary coordinates.
+
+An independent one-coordinate split requires
+
+    a b = 1 and c d = 1.
+
+The internal equation permits extraction and substitution in a cut basis.
+The boundary equation is necessary even if the cut carrier and the boundary
+helper pivot are different physical roles. To see this, write h for the
+original helper inputs and z for the new independent successor input.
+Extracting c h and substituting z along b changes the final helper vector to
+
+    h + d (z - c h).
+
+This uses the cited identity normalized endpoint on the helper group. The
+new combined output is
+
+    (c h, (I - d c) h + d z).
+
+If c d = 0, the nonzero input pair (h,z) = (d,1) maps to zero. If d = 0,
+then the successor input is itself lost. Either case contradicts independent
+output jobs. Invertible boundary bases cannot repair this rank loss.
+The equation c d = 1 follows for an independent split over F2.
+For several simultaneously split coordinates the same argument requires an
+invertible boundary pairing matrix; a zero matrix excludes every positive
+number of channels.
+
+The zero-pairing conclusion is unchanged by extending scalars to any field
+of characteristic two. The kernel spaces extend by scalar extension, and
+the zero bilinear matrix remains zero. Over an extension field the required
+one-channel pairing is nonzero and can be normalized to one; it is still
+excluded here.
+
+## What the executable enumerates
+
+There are 685 fields, 14,794 events and 14,795 event cuts, including both
+boundaries. Exact rational reduced row spaces identify 645 physical frame
+classes. The retained helper endpoint groups have sizes 413, 1 and 1.
+For each group, the checker lists every source frame strictly between its
+two endpoints. It does not impose a bank-size or kernel-support cutoff.
+
+The backward sweep computes the suffix columns. For `ADD d,s`, it applies
+`B[:,s] ^= B[:,d]`. For an erasure of d it stores B's old d column, then
+sets that column to zero. In the forward sweep it removes one event from the
+suffix: ADD is its own inverse, and an erasure restores the stored column.
+Prefix rows advance by `A[d,:] ^= A[s,:]` or by setting an erased row to
+zero. Frame transitions update the bank partition. At the final boundary
+the suffix must be the identity and every frame must equal its declared exit.
+
+An ADD changes only its one common-frame bank. An erasure, initialization or
+query changes only the old and new banks of its destination. Every initial
+bank and every changed bank is checked. Other banks retain their exact prefix
+rows, suffix columns and membership. Exact keys consisting of group, frame,
+slots, prefix rows and suffix columns remove repeated contexts. They do not
+merge distinct linear-algebra problems.
+
+For each context the checker computes bases L and R of the two eligible
+kernel spaces. It verifies their defining equations and independence.
+Opposite-pivot rank elimination separately checks completeness through
+`dim kernel = |S| - rank(restriction)`. It then forms every entry
+
+    C_ij = (L_i A) (B R_j).
+
+Every C is zero. This certifies the entire eligible spaces by bilinearity,
+rather than a bounded-support search for a and b. The result excludes a
+necessary equation; there is no delivery cost to optimistically set to zero.
+
+The output records every count and a deterministic digest of the context
+summaries. The source hashes are checked before parsing. The generated
+execution receipt separately binds the exact package bytes.
+
+## Controls and scope
+
+The checker compares the complete dependency space against literal exhaustive
+enumeration for all 512 triples of three-bit rows. A two-role borrowed-carrier
+example has a real channel in a bank containing no helper role and must be
+accepted. Orthogonal-image, unit-channel and foreign-coordinate controls
+separate the boundary and eligibility conditions. All checks use explicit
+exceptions and remain enabled under optimized Python.
+
+This is a finite exact certificate plus a scoped algebraic obstruction.
+It supplies neither a global BIT lower bound nor a complete multiplication
+theorem. It adds no native word, target, paid saving or kappa. Source native,
+compiler, precision, ownership, tape, outer-assembly and the five framework
+assumptions remain outside this proof. Independent human and formal
+proof-kernel review are unclaimed.
+
+## Credit
+
+This contribution was produced by Nick Petalas. Credit Ali Romman for the
+PR5679 independent-split construction and its different-physical-role open
+question, PR5708's exact final word and helper-pivot census, and PR5609's
+prefix/suffix cut method on the older word. The source construction retains
+Dugongue, ai-nanachi and the compact436, native, controller, helper, ordinary
+and stock lineage cited in those packages. Gaussian elimination, rank-nullity
+and bilinear base change are classical. No predecessor executable is imported
+and no predecessor credit line is changed. New material is Apache-2.0.

research/g20-free-carrier-split-obstruction/README.md

@@ -0,0 +1,97 @@
+# G20 split obstruction with a free choice of physical carrier
+
+On the fixed final G20 word of Ali Romman's [PR5708](https://github.com/CrocSwap/integer-mult-bounds/pull/5708),
+allowing a cut carrier outside the helper endpoint group exposes no additional
+independent split. All **1,981 newly admitted contexts have zero boundary
+pairing**. This answers the common-frame part of the different-physical-role
+question in [PR5679](https://github.com/CrocSwap/integer-mult-bounds/pull/5679),
+Open next question 1. Paid changes of frame and changed words remain open.
+
+Claim type: finite exact certificate with a scoped algebraic proof. No new
+kappa, supplier admission or complete multiplication theorem is claimed.
+This contribution was produced by Nick Petalas.
+
+The prior census required an actual helper-group role in the cut bank.
+The new test uses the entire common-frame bank and every helper-only prefix
+functional and suffix direction, even when the bank contains no such helper.
+Among the 1,981 added contexts, 46 have both kernels nonzero and 45 have a
+nonzero internal pairing. All still have zero boundary pairing. A change of
+carrier alone cannot make the boundary outputs independent.
+
+## Evidence and reproduction
+
+The standalone verifier imports no predecessor executable. It authenticates
+the exact source word and frames, covers 14,795 event cuts on 685 fields,
+and deduplicates 7,870 exact group/frame linear-algebra contexts. All boundary
+pairing matrices are zero. The retained endpoint groups have sizes 413, 1
+and 1. There are 645 rational frame classes.
+
+Every kernel has equation, independence and opposite-pivot rank-completeness
+checks. The 516 controls include exhaustive dependency spaces for 512 small
+inputs and a positive split with no helper role in the cut bank. The result
+and controls pass under normal and optimized Python.
+
+From the repository root, the local interpreter path is:
+
+```sh
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -B research/g20-free-carrier-split-obstruction/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -I -W error -O -B research/g20-free-carrier-split-obstruction/verify.py
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/research_package.py --package research/g20-free-carrier-split-obstruction
+/Users/nick/git/integer-mult-bounds/.venv/bin/python3.12 -B scripts/check_research_commit.py --package research/g20-free-carrier-split-obstruction --check-source-history
+```
+
+Any CPython 3.12 interpreter can replace that path. Only the standard library
+is needed. Expected scientific marker:
+`PASS_G20_FREE_CARRIER_SPLIT_OBSTRUCTION`. The context-summary digest is
+`ba0e0a6915ab530a5f4f31c8ddcf54055325aaa1521bc7057b776f92d085b276`.
+The proof and coverage argument are in [PROOF.md](PROOF.md).
+
+## Limits and predecessor credit
+
+The result concerns one unchanged normalized scalar word, the existing
+common-frame banks, individual helper endpoint groups and ordinary binary
+boundary bases. Its zero matrix also excludes scalar extensions in
+characteristic two. Mixed-frame bases, different endpoint groups, added
+contacts, address-dependent recoding and a changed word are not excluded.
+No native/operator admission, complete caller or recursive price is replayed.
+Independent human and formal proof-kernel review are unclaimed.
+
+Credit Ali Romman for PR5679's split construction and explicit open question,
+PR5708's changed word and prior helper-pivot census, and PR5609's cut method
+on the older word. Those results are cited and used as specifications, not
+audited as the deliverable. The new step is the expanded carrier domain and
+its exact boundary obstruction on the final word. Retain the source credit
+to Dugongue, ai-nanachi, compact436 and all native, controller, helper,
+ordinary and stock predecessors named in those packages. New material is
+Apache-2.0.
+
+## Open next questions
+
+- Can a paid multi-frame boundary give one nonzero eligible boundary pairing
+  on this exact word? Start with one frame conversion and its inverse, then
+  account for the changed query ranks, public targets, routes and restoration.
+  Neither such a channel nor a favorable complete bill is supplied here.
+- Can one changed contact make a nonzero boundary pairing in one of the 46
+  new contexts with nonzero kernels? First inspect the exact prefix/suffix
+  supports at those cuts, then prove the changed endpoint and price it. A
+  different carrier within the unchanged bank cannot suffice.
+
+The first steps and blockers are recorded in [TASK.json](TASK.json).
+
+## Verification design
+
+All loops have finite source-size bounds. The verifier limits inputs to
+16 MiB, fields to 700, events to 20,000, frame dimension to eight, frame
+records to 2,000 and distinct contexts to 30,000. It writes no files and
+has no recursion, subprocesses, dynamic imports or generated code. Each
+function is below 60 lines. Explicit invariant checks remain active with
+`-O`. Registered replay uses isolated mode and warnings as errors.
+
+Python allocates integers, rational values and collections during execution,
+so fixed steady-state allocation is a managed-runtime deviation from Power
+of Ten rule 3. The source limits, finite elimination widths and context cap
+bound the live collections. This command is a bounded research check, not a
+long-lived service; a fixed-storage implementation would be a separate
+requirement if larger instances are introduced. Interpreter and standard
+library internal allocation are not instrumented. The scientific result
+is independent of a memory-performance claim.

research/g20-free-carrier-split-obstruction/SOURCES.json

@@ -0,0 +1,54 @@
+{
+  "schema_version": 1,
+  "base_commit": "19fdb086ea96af9a9f87936a2b888e10af4ed810",
+  "files": [
+    {
+      "path": "certificates/selected-result.json",
+      "usage": "provenance",
+      "git_blob": "581f8d87008354eb5b869f7ed9de1317ad837ce8",
+      "sha256": "2a0220e866417774606e0f991e41b9c1d26b1f43b97857238cf478dbc7d330b5"
+    },
+    {
+      "path": "docs/research/agent-task-catalog.json",
+      "usage": "provenance",
+      "git_blob": "3404fbdd5e7529a0674eef26114b5071e4586cec",
+      "sha256": "ead6cdc9d0af6d58e8a49744d8ec8c7c15e13d2ba93c276c434bcf9b51b93a81"
+    },
+    {
+      "path": "research/g20-conjugation-admission/WORD.json.gz",
+      "usage": "input",
+      "git_blob": "3877a72d8a15adb03f6492f7d2fd8fa902ecb639",
+      "sha256": "8dd441fdb9c8923df06eb5ebfda37d03e4539f2305763e688d8c7025d196c4b1"
+    },
+    {
+      "path": "research/g20-conjugation-admission/prior/prior/prior/source/vendor/g20/inputs/FRAMES.json",
+      "usage": "input",
+      "git_blob": "9edf8d95b45a9c9c766a956bfcd3c19cf07bc13c",
+      "sha256": "0d99fc6b8f45c03dfba5252a03dd9e7fe23be3a7593dfe15368e34da6629a654"
+    },
+    {
+      "path": "research/g20-helper-split/README.md",
+      "usage": "provenance",
+      "git_blob": "8e534668c9afa886fb37e9abd38ae8f0e1c78936",
+      "sha256": "a20ddd3361267c3a26639f9e80f178746d32ec6b3541d0176a743d770e5686a2"
+    },
+    {
+      "path": "research/g20-helper-split/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "1253292326385f8039967d0a4ba94668a710fb1a",
+      "sha256": "6c9366313dcd72d2986a289e15e2c4b89f8ace8fdedf3d5bd17e6f9d98d8c008"
+    },
+    {
+      "path": "research/g20-conjugation-admission/README.md",
+      "usage": "provenance",
+      "git_blob": "b1655b59134ae7a5734628ba1efef6611b2dcd31",
+      "sha256": "e443b2fd7b988316953bfc7d21045690ea0d3ce9069ce1a06880f6ccfc7ec054"
+    },
+    {
+      "path": "research/bit-g20-helper-split-cuts/PROOF.md",
+      "usage": "provenance",
+      "git_blob": "c237f3c7deabee3f71ea3c8e2a0fb456b5c57849",
+      "sha256": "54bd732596db4517a3ee83090edaa4bb94d906d92ef06d674fbf617c832a729a"
+    }
+  ]
+}